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

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

Linux/Unix编程

开发平台：

Unix_Linux

ioctl32.c：源码内容
  1. /* $Id: ioctl32.c,v 1.12 2002/07/08 20:52:15 grundler 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.  *
  7.  * These routines maintain argument size conversion between 32bit and 64bit
  8.  * ioctls.
  9.  */
  11. #include <linux/config.h>
  12. #include <linux/types.h>
  13. #include "sys32.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/route.h>
  25. #include <linux/skbuff.h>
  26. #include <linux/netlink.h>
  27. #include <linux/vt.h>
  28. #include <linux/fs.h>
  29. #include <linux/file.h>
  30. #include <linux/fd.h>
  31. #include <linux/ppp_defs.h>
  32. #include <linux/if_ppp.h>
  33. #include <linux/if_pppox.h>
  34. #include <linux/mtio.h>
  35. #include <linux/cdrom.h>
  36. #include <linux/loop.h>
  37. #include <linux/auto_fs.h>
  38. #include <linux/devfs_fs.h>
  39. #include <linux/tty.h>
  40. #include <linux/vt_kern.h>
  41. #include <linux/fb.h>
  42. #include <linux/ext2_fs.h>
  43. #include <linux/videodev.h>
  44. #include <linux/netdevice.h>
  45. #include <linux/raw.h>
  46. #include <linux/smb_fs.h>
  47. #include <linux/blkpg.h>
  48. #include <linux/blk.h>
  49. #include <linux/elevator.h>
  50. #include <linux/rtc.h>
  51. #include <linux/serial.h>
  52. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  53. /* Ugh. This header really is not clean */
  54. /* #define min min
  55. #define max max */
  56. #include <linux/lvm.h>
  57. #endif /* LVM */
  59. #include <scsi/scsi.h>
  60. /* Ugly hack. */
  61. #undef __KERNEL__
  62. #include <scsi/scsi_ioctl.h>
  63. #define __KERNEL__
  64. #include <scsi/sg.h>
  66. #include <asm/types.h>
  67. #include <asm/uaccess.h>
  68. #include <asm/perf.h>
  69. #include <linux/ethtool.h>
  70. #include <linux/soundcard.h>
  72. #include <linux/atm.h>
  73. #include <linux/atmarp.h>
  74. #include <linux/atmclip.h>
  75. #include <linux/atmdev.h>
  76. #include <linux/atmioc.h>
  77. #include <linux/atmlec.h>
  78. #include <linux/atmmpc.h>
  79. #include <linux/atmsvc.h>
  80. #include <linux/atm_tcp.h>
  81. #include <linux/sonet.h>
  82. #include <linux/atm_suni.h>
  84. #include <asm/module.h> /* get #define module_map() */
  86. /* Use this to get at 32-bit user passed pointers. 
  87.    See sys_sparc32.c for description about these. */
  88. #define A(__x) ((unsigned long)(__x))
  90. /* Aiee. Someone does not find a difference between int and long */
  91. #define EXT2_IOC32_GETFLAGS               _IOR('f', 1, int)
  92. #define EXT2_IOC32_SETFLAGS               _IOW('f', 2, int)
  93. #define EXT2_IOC32_GETVERSION             _IOR('v', 1, int)
  94. #define EXT2_IOC32_SETVERSION             _IOW('v', 2, int)
  96. extern asmlinkage int sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
  98. static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
  99. {
  100. mm_segment_t old_fs = get_fs();
  101. int err;
  102. unsigned long val;
  104. set_fs (KERNEL_DS);
  105. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  106. set_fs (old_fs);
  107. if (!err && put_user(val, (u32 *)arg))
  108. return -EFAULT;
  109. return err;
  110. }
  111.  
  112. static int rw_long(unsigned int fd, unsigned int cmd, unsigned long arg)
  113. {
  114. mm_segment_t old_fs = get_fs();
  115. int err;
  116. unsigned long val;
  118. if(get_user(val, (u32 *)arg))
  119. return -EFAULT;
  120. set_fs (KERNEL_DS);
  121. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  122. set_fs (old_fs);
  123. if (!err && put_user(val, (u32 *)arg))
  124. return -EFAULT;
  125. return err;
  126. }
  128. static int siocprivate(unsigned int fd, unsigned int cmd, unsigned long arg)
  129. {
  130. int err = sys_ioctl(fd, cmd, arg);
  131. if ((unsigned) err > -4095)
  132. printk(KERN_WARNING 
  133. "ioctl(%d, 0x%x, %p) -- SIOCDEVPRIVATE-based ioctls aren't reallyn"
  134. "supported, though some will work by accident.n",
  135.     fd, cmd, (void *)arg);
  136. return err;
  137. }
  139. static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  140. {
  141. /* These are just misnamed, they actually get/put from/to user an int */
  142. switch (cmd) {
  143. case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;
  144. case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;
  145. case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;
  146. case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;
  147. }
  148. return sys_ioctl(fd, cmd, arg);
  149. }
  150.  
  151. static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
  152. {
  153. struct timeval32 *up = (struct timeval32 *)arg;
  154. struct timeval ktv;
  155. mm_segment_t old_fs = get_fs();
  156. int err;
  158. set_fs(KERNEL_DS);
  159. err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
  160. set_fs(old_fs);
  161. if(!err) {
  162. err = put_user(ktv.tv_sec, &up->tv_sec);
  163. err |= __put_user(ktv.tv_usec, &up->tv_usec);
  164. }
  165. return err;
  166. }
  168. struct ifmap32 {
  169. u32 mem_start;
  170. u32 mem_end;
  171. unsigned short base_addr;
  172. unsigned char irq;
  173. unsigned char dma;
  174. unsigned char port;
  175. };
  177. struct ifreq32 {
  178. #define IFHWADDRLEN     6
  179. #define IFNAMSIZ        16
  180.         union {
  181.                 char    ifrn_name[IFNAMSIZ];            /* if name, e.g. "en0" */
  182.         } ifr_ifrn;
  183.         union {
  184.                 struct  sockaddr ifru_addr;
  185.                 struct  sockaddr ifru_dstaddr;
  186.                 struct  sockaddr ifru_broadaddr;
  187.                 struct  sockaddr ifru_netmask;
  188.                 struct  sockaddr ifru_hwaddr;
  189.                 short   ifru_flags;
  190.                 int     ifru_ivalue;
  191.                 int     ifru_mtu;
  192.                 struct  ifmap32 ifru_map;
  193.                 char    ifru_slave[IFNAMSIZ];   /* Just fits the size */
  194. char ifru_newname[IFNAMSIZ];
  195.                 __kernel_caddr_t32 ifru_data;
  196.         } ifr_ifru;
  197. };
  199. struct ifconf32 {
  200.         int     ifc_len;                        /* size of buffer       */
  201.         __kernel_caddr_t32  ifcbuf;
  202. };
  204. static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
  205. {
  206. struct net_device *dev;
  207. struct ifreq32 ifr32;
  208. int err;
  210. if (copy_from_user(&ifr32, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  211. return -EFAULT;
  213. dev = dev_get_by_index(ifr32.ifr_ifindex);
  214. if (!dev)
  215. return -ENODEV;
  217. strcpy(ifr32.ifr_name, dev->name);
  219. err = copy_to_user((struct ifreq32 *)arg, &ifr32, sizeof(struct ifreq32));
  220. return (err ? -EFAULT : 0);
  221. }
  223. static inline int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
  224. {
  225. struct ifconf32 ifc32;
  226. struct ifconf ifc;
  227. struct ifreq32 *ifr32;
  228. struct ifreq *ifr;
  229. mm_segment_t old_fs;
  230. unsigned int i, j;
  231. int err;
  233. if (copy_from_user(&ifc32, (struct ifconf32 *)arg, sizeof(struct ifconf32)))
  234. return -EFAULT;
  236. if(ifc32.ifcbuf == 0) {
  237. ifc32.ifc_len = 0;
  238. ifc.ifc_len = 0;
  239. ifc.ifc_buf = NULL;
  240. } else {
  241. ifc.ifc_len = ((ifc32.ifc_len / sizeof (struct ifreq32)) + 1) *
  242. sizeof (struct ifreq);
  243. ifc.ifc_buf = kmalloc (ifc.ifc_len, GFP_KERNEL);
  244. if (!ifc.ifc_buf)
  245. return -ENOMEM;
  246. }
  247. ifr = ifc.ifc_req;
  248. ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
  249. for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) {
  250. if (copy_from_user(ifr++, ifr32++, sizeof (struct ifreq32))) {
  251. kfree (ifc.ifc_buf);
  252. return -EFAULT;
  253. }
  254. }
  255. old_fs = get_fs(); set_fs (KERNEL_DS);
  256. err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)&ifc);
  257. set_fs (old_fs);
  258. if (!err) {
  259. ifr = ifc.ifc_req;
  260. ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
  261. for (i = 0, j = 0; i < ifc32.ifc_len && j < ifc.ifc_len;
  262.      i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
  263. if (copy_to_user(ifr32++, ifr++, sizeof (struct ifreq32))) {
  264. err = -EFAULT;
  265. break;
  266. }
  267. }
  268. if (!err) {
  269. if (i <= ifc32.ifc_len)
  270. ifc32.ifc_len = i;
  271. else
  272. ifc32.ifc_len = i - sizeof (struct ifreq32);
  273. if (copy_to_user((struct ifconf32 *)arg, &ifc32, sizeof(struct ifconf32)))
  274. err = -EFAULT;
  275. }
  276. }
  277. if(ifc.ifc_buf != NULL)
  278. kfree (ifc.ifc_buf);
  279. return err;
  280. }
  282. static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
  283. {
  284. struct ifreq ifr;
  285. mm_segment_t old_fs;
  286. int err;
  288. switch (cmd) {
  289. case SIOCSIFMAP:
  290. err = copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(ifr.ifr_name));
  291. err |= __get_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
  292. err |= __get_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
  293. err |= __get_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
  294. err |= __get_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
  295. err |= __get_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
  296. err |= __get_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
  297. if (err)
  298. return -EFAULT;
  299. break;
  300. case SIOCGPPPSTATS:
  301. case SIOCGPPPCSTATS:
  302. case SIOCGPPPVER:
  303. case SIOCETHTOOL:
  304. if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  305. return -EFAULT;
  306. ifr.ifr_data = (__kernel_caddr_t)get_free_page(GFP_KERNEL);
  307. if (!ifr.ifr_data)
  308. return -EAGAIN;
  309. if(cmd == SIOCETHTOOL) {
  310. u32 data;
  312. __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
  313. if(copy_from_user(ifr.ifr_data,
  314.   (char *)A(data),
  315.   sizeof(struct ethtool_cmd))) {
  316. free_page((unsigned long)ifr.ifr_data);
  317. return -EFAULT;
  318. }
  319. }
  320. break;
  321. default:
  322. if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  323. return -EFAULT;
  324. break;
  325. }
  326. old_fs = get_fs();
  327. set_fs (KERNEL_DS);
  328. err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
  329. set_fs (old_fs);
  330. if (!err) {
  331. switch (cmd) {
  332. case SIOCGIFFLAGS:
  333. case SIOCGIFMETRIC:
  334. case SIOCGIFMTU:
  335. case SIOCGIFMEM:
  336. case SIOCGIFHWADDR:
  337. case SIOCGIFINDEX:
  338. case SIOCGIFADDR:
  339. case SIOCGIFBRDADDR:
  340. case SIOCGIFDSTADDR:
  341. case SIOCGIFNETMASK:
  342. case SIOCGIFTXQLEN:
  343. if (copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(struct ifreq32)))
  344. return -EFAULT;
  345. break;
  346. case SIOCGPPPSTATS:
  347. case SIOCGPPPCSTATS:
  348. case SIOCGPPPVER:
  349. case SIOCETHTOOL:
  350. {
  351. u32 data;
  352. int len;
  354. __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
  355. if(cmd == SIOCETHTOOL)
  356. len = sizeof(struct ethtool_cmd);
  357. if(cmd == SIOCGPPPVER)
  358. len = strlen((char *)ifr.ifr_data) + 1;
  359. else if(cmd == SIOCGPPPCSTATS)
  360. len = sizeof(struct ppp_comp_stats);
  361. else
  362. len = sizeof(struct ppp_stats);
  364. len = copy_to_user((char *)A(data), ifr.ifr_data, len);
  365. free_page((unsigned long)ifr.ifr_data);
  366. if(len)
  367. return -EFAULT;
  368. break;
  369. }
  370. case SIOCGIFMAP:
  371. err = copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(ifr.ifr_name));
  372. err |= __put_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
  373. err |= __put_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
  374. err |= __put_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
  375. err |= __put_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
  376. err |= __put_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
  377. err |= __put_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
  378. if (err)
  379. err = -EFAULT;
  380. break;
  381. }
  382. }
  383. return err;
  384. }
  386. struct rtentry32 {
  387.         u32    rt_pad1;
  388.         struct sockaddr rt_dst;         /* target address               */
  389.         struct sockaddr rt_gateway;     /* gateway addr (RTF_GATEWAY)   */
  390.         struct sockaddr rt_genmask;     /* target network mask (IP)     */
  391.         unsigned short  rt_flags;
  392.         short           rt_pad2;
  393.         u32    rt_pad3;
  394.         unsigned char   rt_tos;
  395.         unsigned char   rt_class;
  396.         short           rt_pad4;
  397.         short           rt_metric;      /* +1 for binary compatibility! */
  398.         /* char * */ u32 rt_dev;        /* forcing the device at add    */
  399.         u32    rt_mtu;         /* per route MTU/Window         */
  400.         u32    rt_window;      /* Window clamping              */
  401.         unsigned short  rt_irtt;        /* Initial RTT                  */
  403. };
  405. static inline int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  406. {
  407. struct rtentry r;
  408. char devname[16];
  409. u32 rtdev;
  410. int ret;
  411. mm_segment_t old_fs = get_fs();
  413. ret = copy_from_user (&r.rt_dst, &(((struct rtentry32 *)arg)->rt_dst), 3 * sizeof(struct sockaddr));
  414. ret |= __get_user (r.rt_flags, &(((struct rtentry32 *)arg)->rt_flags));
  415. ret |= __get_user (r.rt_metric, &(((struct rtentry32 *)arg)->rt_metric));
  416. ret |= __get_user (r.rt_mtu, &(((struct rtentry32 *)arg)->rt_mtu));
  417. ret |= __get_user (r.rt_window, &(((struct rtentry32 *)arg)->rt_window));
  418. ret |= __get_user (r.rt_irtt, &(((struct rtentry32 *)arg)->rt_irtt));
  419. ret |= __get_user (rtdev, &(((struct rtentry32 *)arg)->rt_dev));
  420. if (rtdev) {
  421. ret |= copy_from_user (devname, (char *)A(rtdev), 15);
  422. r.rt_dev = devname; devname[15] = 0;
  423. } else
  424. r.rt_dev = 0;
  425. if (ret)
  426. return -EFAULT;
  427. set_fs (KERNEL_DS);
  428. ret = sys_ioctl (fd, cmd, (long)&r);
  429. set_fs (old_fs);
  430. return ret;
  431. }
  433. struct hd_geometry32 {
  434. unsigned char heads;
  435. unsigned char sectors;
  436. unsigned short cylinders;
  437. u32 start;
  438. };
  439.                         
  440. static inline int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
  441. {
  442. mm_segment_t old_fs = get_fs();
  443. struct hd_geometry geo;
  444. int err;
  446. set_fs (KERNEL_DS);
  447. err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
  448. set_fs (old_fs);
  449. if (!err) {
  450. err = copy_to_user ((struct hd_geometry32 *)arg, &geo, 4);
  451. err |= __put_user (geo.start, &(((struct hd_geometry32 *)arg)->start));
  452. }
  453. return err ? -EFAULT : 0;
  454. }
  457. #if 0
  458. /* looks like SPARC only - eg sbus video */
  459. struct  fbcmap32 {
  460. int             index;          /* first element (0 origin) */
  461. int             count;
  462. u32 red;
  463. u32 green;
  464. u32 blue;
  465. };
  468. static inline int fbiogetputcmap(unsigned int fd, unsigned int cmd, unsigned long arg)
  469. {
  470. struct fbcmap f;
  471. int ret;
  472. char red[256], green[256], blue[256];
  473. u32 r, g, b;
  474. mm_segment_t old_fs = get_fs();
  476. ret = get_user(f.index, &(((struct fbcmap32 *)arg)->index));
  477. ret |= __get_user(f.count, &(((struct fbcmap32 *)arg)->count));
  478. ret |= __get_user(r, &(((struct fbcmap32 *)arg)->red));
  479. ret |= __get_user(g, &(((struct fbcmap32 *)arg)->green));
  480. ret |= __get_user(b, &(((struct fbcmap32 *)arg)->blue));
  481. if (ret)
  482. return -EFAULT;
  483. if ((f.index < 0) || (f.index > 255)) return -EINVAL;
  484. if (f.index + f.count > 256)
  485. f.count = 256 - f.index;
  486. if (cmd == FBIOPUTCMAP32) {
  487. ret = copy_from_user (red, (char *)A(r), f.count);
  488. ret |= copy_from_user (green, (char *)A(g), f.count);
  489. ret |= copy_from_user (blue, (char *)A(b), f.count);
  490. if (ret)
  491. return -EFAULT;
  492. }
  493. f.red = red; f.green = green; f.blue = blue;
  494. set_fs (KERNEL_DS);
  495. ret = sys_ioctl (fd, (cmd == FBIOPUTCMAP32) ? FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC, (long)&f);
  496. set_fs (old_fs);
  497. if (!ret && cmd == FBIOGETCMAP32) {
  498. ret = copy_to_user ((char *)A(r), red, f.count);
  499. ret |= copy_to_user ((char *)A(g), green, f.count);
  500. ret |= copy_to_user ((char *)A(b), blue, f.count);
  501. }
  502. return ret ? -EFAULT : 0;
  503. }
  505. struct fbcursor32 {
  506. short set; /* what to set, choose from the list above */
  507. short enable; /* cursor on/off */
  508. struct fbcurpos pos; /* cursor position */
  509. struct fbcurpos hot; /* cursor hot spot */
  510. struct fbcmap32 cmap; /* color map info */
  511. struct fbcurpos size; /* cursor bit map size */
  512. u32 image; /* cursor image bits */
  513. u32 mask; /* cursor mask bits */
  514. };
  516. static inline int fbiogscursor(unsigned int fd, unsigned int cmd, unsigned long arg)
  517. {
  518. struct fbcursor f;
  519. int ret;
  520. char red[2], green[2], blue[2];
  521. char image[128], mask[128];
  522. u32 r, g, b;
  523. u32 m, i;
  524. mm_segment_t old_fs = get_fs();
  526. ret = copy_from_user (&f, (struct fbcursor32 *)arg, 2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
  527. ret |= __get_user(f.size.fbx, &(((struct fbcursor32 *)arg)->size.fbx));
  528. ret |= __get_user(f.size.fby, &(((struct fbcursor32 *)arg)->size.fby));
  529. ret |= __get_user(f.cmap.index, &(((struct fbcursor32 *)arg)->cmap.index));
  530. ret |= __get_user(f.cmap.count, &(((struct fbcursor32 *)arg)->cmap.count));
  531. ret |= __get_user(r, &(((struct fbcursor32 *)arg)->cmap.red));
  532. ret |= __get_user(g, &(((struct fbcursor32 *)arg)->cmap.green));
  533. ret |= __get_user(b, &(((struct fbcursor32 *)arg)->cmap.blue));
  534. ret |= __get_user(m, &(((struct fbcursor32 *)arg)->mask));
  535. ret |= __get_user(i, &(((struct fbcursor32 *)arg)->image));
  536. if (ret)
  537. return -EFAULT;
  538. if (f.set & FB_CUR_SETCMAP) {
  539. if ((uint) f.size.fby > 32)
  540. return -EINVAL;
  541. ret = copy_from_user (mask, (char *)A(m), f.size.fby * 4);
  542. ret |= copy_from_user (image, (char *)A(i), f.size.fby * 4);
  543. if (ret)
  544. return -EFAULT;
  545. f.image = image; f.mask = mask;
  546. }
  547. if (f.set & FB_CUR_SETCMAP) {
  548. ret = copy_from_user (red, (char *)A(r), 2);
  549. ret |= copy_from_user (green, (char *)A(g), 2);
  550. ret |= copy_from_user (blue, (char *)A(b), 2);
  551. if (ret)
  552. return -EFAULT;
  553. f.cmap.red = red; f.cmap.green = green; f.cmap.blue = blue;
  554. }
  555. set_fs (KERNEL_DS);
  556. ret = sys_ioctl (fd, FBIOSCURSOR, (long)&f);
  557. set_fs (old_fs);
  558. return ret;
  559. }
  560. #endif /* 0 */
  562. struct fb_fix_screeninfo32 {
  563. char id[16];
  564.         __kernel_caddr_t32 smem_start;
  565. __u32 smem_len;
  566. __u32 type;
  567. __u32 type_aux;
  568. __u32 visual;
  569. __u16 xpanstep;
  570. __u16 ypanstep;
  571. __u16 ywrapstep;
  572. __u32 line_length;
  573.         __kernel_caddr_t32 mmio_start;
  574. __u32 mmio_len;
  575. __u32 accel;
  576. __u16 reserved[3];
  577. };
  579. struct fb_cmap32 {
  580. __u32 start;
  581. __u32 len;
  582. __kernel_caddr_t32 red;
  583. __kernel_caddr_t32 green;
  584. __kernel_caddr_t32 blue;
  585. __kernel_caddr_t32 transp;
  586. };
  588. static int fb_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  589. {
  590. mm_segment_t old_fs = get_fs();
  591. u32 red = 0, green = 0, blue = 0, transp = 0;
  592. struct fb_fix_screeninfo fix;
  593. struct fb_cmap cmap;
  594. void *karg;
  595. int err = 0;
  597. memset(&cmap, 0, sizeof(cmap));
  598. switch (cmd) {
  599. case FBIOGET_FSCREENINFO:
  600. karg = &fix;
  601. break;
  602. case FBIOGETCMAP:
  603. case FBIOPUTCMAP:
  604. karg = &cmap;
  605. err = __get_user(cmap.start, &((struct fb_cmap32 *)arg)->start);
  606. err |= __get_user(cmap.len, &((struct fb_cmap32 *)arg)->len);
  607. err |= __get_user(red, &((struct fb_cmap32 *)arg)->red);
  608. err |= __get_user(green, &((struct fb_cmap32 *)arg)->green);
  609. err |= __get_user(blue, &((struct fb_cmap32 *)arg)->blue);
  610. err |= __get_user(transp, &((struct fb_cmap32 *)arg)->transp);
  611. if (err) {
  612. err = -EFAULT;
  613. goto out;
  614. }
  615. err = -ENOMEM;
  616. cmap.red = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  617. if (!cmap.red)
  618. goto out;
  619. cmap.green = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  620. if (!cmap.green)
  621. goto out;
  622. cmap.blue = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  623. if (!cmap.blue)
  624. goto out;
  625. if (transp) {
  626. cmap.transp = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  627. if (!cmap.transp)
  628. goto out;
  629. }
  631. if (cmd == FBIOGETCMAP)
  632. break;
  634. err = __copy_from_user(cmap.red, (char *)A(red), cmap.len * sizeof(__u16));
  635. err |= __copy_from_user(cmap.green, (char *)A(green), cmap.len * sizeof(__u16));
  636. err |= __copy_from_user(cmap.blue, (char *)A(blue), cmap.len * sizeof(__u16));
  637. if (cmap.transp) err |= __copy_from_user(cmap.transp, (char *)A(transp), cmap.len * sizeof(__u16));
  638. if (err) {
  639. err = -EFAULT;
  640. goto out;
  641. }
  642. break;
  643. default:
  644. do {
  645. static int count = 0;
  646. if (++count <= 20)
  647. printk(KERN_WARNING
  648. "%s: Unknown fb ioctl cmd fd(%d) "
  649. "cmd(%08x) arg(%08lx)n",
  650. __FUNCTION__, fd, cmd, arg);
  651. } while(0);
  652. return -ENOSYS;
  653. }
  654. set_fs(KERNEL_DS);
  655. err = sys_ioctl(fd, cmd, (unsigned long)karg);
  656. set_fs(old_fs);
  657. if (err)
  658. goto out;
  659. switch (cmd) {
  660. struct fb_fix_screeninfo32 fix32;
  661. case FBIOGET_FSCREENINFO:
  662. memset(&fix32, 0, sizeof(fix32));
  663. memcpy(fix32.id, fix.id, sizeof(fix32.id));
  664. fix32.smem_start = (__u32)(unsigned long)fix.smem_start;
  665. fix32.smem_len = fix.smem_len;
  666. fix32.type = fix.type;
  667. fix32.type_aux = fix.type_aux;
  668. fix32.visual = fix.visual;
  669. fix32.xpanstep = fix.xpanstep;
  670. fix32.ypanstep = fix.ypanstep;
  671. fix32.ywrapstep = fix.ywrapstep;
  672. fix32.line_length = fix.line_length;
  673. fix32.mmio_start = (__u32)(unsigned long)fix.mmio_start;
  674. fix32.mmio_len = fix.mmio_len;
  675. fix32.accel = fix.accel;
  676. memcpy(fix32.reserved, fix.reserved, sizeof(fix32.reserved));
  677. err = __copy_to_user((void *) arg, (const void *) &fix32, sizeof(fix32));
  679. printk("fix  : %lx %x  %x %x %x  %x %x %x %x  %lx %x %xn",
  680. fix.smem_start, fix.smem_len,
  681. fix.type, fix.type_aux, fix.visual,
  682. fix.xpanstep, fix.ypanstep, fix.ywrapstep, fix.line_length,
  683. fix.mmio_start, fix.mmio_len, fix.accel);
  684. printk("fix32: %x %x  %x %x %x  %x %x %x %x  %x %x %xn",
  685. fix32.smem_start, fix32.smem_len,
  686. fix32.type, fix32.type_aux, fix32.visual,
  687. fix32.xpanstep, fix32.ypanstep, fix32.ywrapstep, fix32.line_length,
  688. fix32.mmio_start, fix32.mmio_len, fix32.accel);
  690. break;
  691. case FBIOGETCMAP:
  692. err = __copy_to_user((char *)A(red), cmap.red, cmap.len * sizeof(__u16));
  693. err |= __copy_to_user((char *)A(green), cmap.blue, cmap.len * sizeof(__u16));
  694. err |= __copy_to_user((char *)A(blue), cmap.blue, cmap.len * sizeof(__u16));
  695. if (cmap.transp)
  696. err |= __copy_to_user((char *)A(transp), cmap.transp, cmap.len * sizeof(__u16));
  697. break;
  698. case FBIOPUTCMAP:
  699. break;
  700. }
  701. if (err)
  702. err = -EFAULT;
  704. out: if (cmap.red) kfree(cmap.red);
  705. if (cmap.green) kfree(cmap.green);
  706. if (cmap.blue) kfree(cmap.blue);
  707. if (cmap.transp) kfree(cmap.transp);
  708. return err;
  709. }
  711. static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  712. {
  713. mm_segment_t old_fs = get_fs();
  714. unsigned long kval;
  715. unsigned int *uvp;
  716. int error;
  718. set_fs(KERNEL_DS);
  719. error = sys_ioctl(fd, cmd, (long)&kval);
  720. set_fs(old_fs);
  722. if(error == 0) {
  723. uvp = (unsigned int *)arg;
  724. if(put_user(kval, uvp))
  725. error = -EFAULT;
  726. }
  727. return error;
  728. }
  730. struct floppy_struct32 {
  731. unsigned int size;
  732. unsigned int sect;
  733. unsigned int head;
  734. unsigned int track;
  735. unsigned int stretch;
  736. unsigned char gap;
  737. unsigned char rate;
  738. unsigned char spec1;
  739. unsigned char fmt_gap;
  740. const __kernel_caddr_t32 name;
  741. };
  743. struct floppy_drive_params32 {
  744. char cmos;
  745. u32 max_dtr;
  746. u32 hlt;
  747. u32 hut;
  748. u32 srt;
  749. u32 spinup;
  750. u32 spindown;
  751. unsigned char spindown_offset;
  752. unsigned char select_delay;
  753. unsigned char rps;
  754. unsigned char tracks;
  755. u32 timeout;
  756. unsigned char interleave_sect;
  757. struct floppy_max_errors max_errors;
  758. char flags;
  759. char read_track;
  760. short autodetect[8];
  761. int checkfreq;
  762. int native_format;
  763. };
  765. struct floppy_drive_struct32 {
  766. signed char flags;
  767. u32 spinup_date;
  768. u32 select_date;
  769. u32 first_read_date;
  770. short probed_format;
  771. short track;
  772. short maxblock;
  773. short maxtrack;
  774. int generation;
  775. int keep_data;
  776. int fd_ref;
  777. int fd_device;
  778. int last_checked;
  779. __kernel_caddr_t32 dmabuf;
  780. int bufblocks;
  781. };
  783. struct floppy_fdc_state32 {
  784. int spec1;
  785. int spec2;
  786. int dtr;
  787. unsigned char version;
  788. unsigned char dor;
  789. u32 address;
  790. unsigned int rawcmd:2;
  791. unsigned int reset:1;
  792. unsigned int need_configure:1;
  793. unsigned int perp_mode:2;
  794. unsigned int has_fifo:1;
  795. unsigned int driver_version;
  796. unsigned char track[4];
  797. };
  799. struct floppy_write_errors32 {
  800. unsigned int write_errors;
  801. u32 first_error_sector;
  802. int first_error_generation;
  803. u32 last_error_sector;
  804. int last_error_generation;
  805. unsigned int badness;
  806. };
  808. #define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
  809. #define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
  810. #define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
  811. #define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
  812. #define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
  813. #define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
  814. #define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
  815. #define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
  816. #define FDWERRORGET32  _IOR(2, 0x17, struct floppy_write_errors32)
  818. static struct {
  819. unsigned int cmd32;
  820. unsigned int cmd;
  821. } fd_ioctl_trans_table[] = {
  822. { FDSETPRM32, FDSETPRM },
  823. { FDDEFPRM32, FDDEFPRM },
  824. { FDGETPRM32, FDGETPRM },
  825. { FDSETDRVPRM32, FDSETDRVPRM },
  826. { FDGETDRVPRM32, FDGETDRVPRM },
  827. { FDGETDRVSTAT32, FDGETDRVSTAT },
  828. { FDPOLLDRVSTAT32, FDPOLLDRVSTAT },
  829. { FDGETFDCSTAT32, FDGETFDCSTAT },
  830. { FDWERRORGET32, FDWERRORGET }
  831. };
  833. #define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
  835. static int fd_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  836. {
  837. mm_segment_t old_fs = get_fs();
  838. void *karg = NULL;
  839. unsigned int kcmd = 0;
  840. int i, err;
  842. for (i = 0; i < NR_FD_IOCTL_TRANS; i++)
  843. if (cmd == fd_ioctl_trans_table[i].cmd32) {
  844. kcmd = fd_ioctl_trans_table[i].cmd;
  845. break;
  846. }
  847. if (!kcmd)
  848. return -EINVAL;
  850. switch (cmd) {
  851. case FDSETPRM32:
  852. case FDDEFPRM32:
  853. case FDGETPRM32:
  854. {
  855. struct floppy_struct *f;
  857. f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL);
  858. if (!karg)
  859. return -ENOMEM;
  860. if (cmd == FDGETPRM32)
  861. break;
  862. err = __get_user(f->size, &((struct floppy_struct32 *)arg)->size);
  863. err |= __get_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
  864. err |= __get_user(f->head, &((struct floppy_struct32 *)arg)->head);
  865. err |= __get_user(f->track, &((struct floppy_struct32 *)arg)->track);
  866. err |= __get_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
  867. err |= __get_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
  868. err |= __get_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
  869. err |= __get_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
  870. err |= __get_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
  871. err |= __get_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
  872. if (err) {
  873. err = -EFAULT;
  874. goto out;
  875. }
  876. break;
  877. }
  878. case FDSETDRVPRM32:
  879. case FDGETDRVPRM32:
  880. {
  881. struct floppy_drive_params *f;
  883. f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL);
  884. if (!karg)
  885. return -ENOMEM;
  886. if (cmd == FDGETDRVPRM32)
  887. break;
  888. err = __get_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
  889. err |= __get_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
  890. err |= __get_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
  891. err |= __get_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
  892. err |= __get_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
  893. err |= __get_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
  894. err |= __get_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
  895. err |= __get_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
  896. err |= __get_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
  897. err |= __get_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
  898. err |= __get_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
  899. err |= __get_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
  900. err |= __get_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
  901. err |= __copy_from_user(&f->max_errors, &((struct floppy_drive_params32 *)arg)->max_errors, sizeof(f->max_errors));
  902. err |= __get_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
  903. err |= __get_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
  904. err |= __copy_from_user(f->autodetect, ((struct floppy_drive_params32 *)arg)->autodetect, sizeof(f->autodetect));
  905. err |= __get_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
  906. err |= __get_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
  907. if (err) {
  908. err = -EFAULT;
  909. goto out;
  910. }
  911. break;
  912. }
  913. case FDGETDRVSTAT32:
  914. case FDPOLLDRVSTAT32:
  915. karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL);
  916. if (!karg)
  917. return -ENOMEM;
  918. break;
  919. case FDGETFDCSTAT32:
  920. karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL);
  921. if (!karg)
  922. return -ENOMEM;
  923. break;
  924. case FDWERRORGET32:
  925. karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL);
  926. if (!karg)
  927. return -ENOMEM;
  928. break;
  929. default:
  930. return -EINVAL;
  931. }
  932. set_fs (KERNEL_DS);
  933. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  934. set_fs (old_fs);
  935. if (err)
  936. goto out;
  937. switch (cmd) {
  938. case FDGETPRM32:
  939. {
  940. struct floppy_struct *f = karg;
  942. err = __put_user(f->size, &((struct floppy_struct32 *)arg)->size);
  943. err |= __put_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
  944. err |= __put_user(f->head, &((struct floppy_struct32 *)arg)->head);
  945. err |= __put_user(f->track, &((struct floppy_struct32 *)arg)->track);
  946. err |= __put_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
  947. err |= __put_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
  948. err |= __put_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
  949. err |= __put_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
  950. err |= __put_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
  951. err |= __put_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
  952. break;
  953. }
  954. case FDGETDRVPRM32:
  955. {
  956. struct floppy_drive_params *f = karg;
  958. err = __put_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
  959. err |= __put_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
  960. err |= __put_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
  961. err |= __put_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
  962. err |= __put_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
  963. err |= __put_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
  964. err |= __put_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
  965. err |= __put_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
  966. err |= __put_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
  967. err |= __put_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
  968. err |= __put_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
  969. err |= __put_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
  970. err |= __put_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
  971. err |= __copy_to_user(&((struct floppy_drive_params32 *)arg)->max_errors, &f->max_errors, sizeof(f->max_errors));
  972. err |= __put_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
  973. err |= __put_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
  974. err |= __copy_to_user(((struct floppy_drive_params32 *)arg)->autodetect, f->autodetect, sizeof(f->autodetect));
  975. err |= __put_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
  976. err |= __put_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
  977. break;
  978. }
  979. case FDGETDRVSTAT32:
  980. case FDPOLLDRVSTAT32:
  981. {
  982. struct floppy_drive_struct *f = karg;
  984. err = __put_user(f->flags, &((struct floppy_drive_struct32 *)arg)->flags);
  985. err |= __put_user(f->spinup_date, &((struct floppy_drive_struct32 *)arg)->spinup_date);
  986. err |= __put_user(f->select_date, &((struct floppy_drive_struct32 *)arg)->select_date);
  987. err |= __put_user(f->first_read_date, &((struct floppy_drive_struct32 *)arg)->first_read_date);
  988. err |= __put_user(f->probed_format, &((struct floppy_drive_struct32 *)arg)->probed_format);
  989. err |= __put_user(f->track, &((struct floppy_drive_struct32 *)arg)->track);
  990. err |= __put_user(f->maxblock, &((struct floppy_drive_struct32 *)arg)->maxblock);
  991. err |= __put_user(f->maxtrack, &((struct floppy_drive_struct32 *)arg)->maxtrack);
  992. err |= __put_user(f->generation, &((struct floppy_drive_struct32 *)arg)->generation);
  993. err |= __put_user(f->keep_data, &((struct floppy_drive_struct32 *)arg)->keep_data);
  994. err |= __put_user(f->fd_ref, &((struct floppy_drive_struct32 *)arg)->fd_ref);
  995. err |= __put_user(f->fd_device, &((struct floppy_drive_struct32 *)arg)->fd_device);
  996. err |= __put_user(f->last_checked, &((struct floppy_drive_struct32 *)arg)->last_checked);
  997. err |= __put_user((u64)f->dmabuf, &((struct floppy_drive_struct32 *)arg)->dmabuf);
  998. err |= __put_user((u64)f->bufblocks, &((struct floppy_drive_struct32 *)arg)->bufblocks);
  999. break;
  1000. }
  1001. case FDGETFDCSTAT32:
  1002. {
  1003. struct floppy_fdc_state *f = karg;
  1005. err = __put_user(f->spec1, &((struct floppy_fdc_state32 *)arg)->spec1);
  1006. err |= __put_user(f->spec2, &((struct floppy_fdc_state32 *)arg)->spec2);
  1007. err |= __put_user(f->dtr, &((struct floppy_fdc_state32 *)arg)->dtr);
  1008. err |= __put_user(f->version, &((struct floppy_fdc_state32 *)arg)->version);
  1009. err |= __put_user(f->dor, &((struct floppy_fdc_state32 *)arg)->dor);
  1010. err |= __put_user(f->address, &((struct floppy_fdc_state32 *)arg)->address);
  1011. err |= __copy_to_user((char *)&((struct floppy_fdc_state32 *)arg)->address
  1012.         + sizeof(((struct floppy_fdc_state32 *)arg)->address),
  1013.    (char *)&f->address + sizeof(f->address), sizeof(int));
  1014. err |= __put_user(f->driver_version, &((struct floppy_fdc_state32 *)arg)->driver_version);
  1015. err |= __copy_to_user(((struct floppy_fdc_state32 *)arg)->track, f->track, sizeof(f->track));
  1016. break;
  1017. }
  1018. case FDWERRORGET32:
  1019. {
  1020. struct floppy_write_errors *f = karg;
  1022. err = __put_user(f->write_errors, &((struct floppy_write_errors32 *)arg)->write_errors);
  1023. err |= __put_user(f->first_error_sector, &((struct floppy_write_errors32 *)arg)->first_error_sector);
  1024. err |= __put_user(f->first_error_generation, &((struct floppy_write_errors32 *)arg)->first_error_generation);
  1025. err |= __put_user(f->last_error_sector, &((struct floppy_write_errors32 *)arg)->last_error_sector);
  1026. err |= __put_user(f->last_error_generation, &((struct floppy_write_errors32 *)arg)->last_error_generation);
  1027. err |= __put_user(f->badness, &((struct floppy_write_errors32 *)arg)->badness);
  1028. break;
  1029. }
  1030. default:
  1031. break;
  1032. }
  1033. if (err)
  1034. err = -EFAULT;
  1036. out: if (karg) kfree(karg);
  1037. return err;
  1038. }
  1040. struct ppp_option_data32 {
  1041. __kernel_caddr_t32 ptr;
  1042. __u32 length;
  1043. int transmit;
  1044. };
  1045. #define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
  1047. struct ppp_idle32 {
  1048. __kernel_time_t32 xmit_idle;
  1049. __kernel_time_t32 recv_idle;
  1050. };
  1051. #define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
  1053. static int ppp_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1054. {
  1055. mm_segment_t old_fs = get_fs();
  1056. struct ppp_option_data32 data32;
  1057. struct ppp_option_data data;
  1058. struct ppp_idle32 idle32;
  1059. struct ppp_idle idle;
  1060. unsigned int kcmd;
  1061. void *karg;
  1062. int err = 0;
  1064. switch (cmd) {
  1065. case PPPIOCGIDLE32:
  1066. kcmd = PPPIOCGIDLE;
  1067. karg = &idle;
  1068. break;
  1069. case PPPIOCSCOMPRESS32:
  1070. if (copy_from_user(&data32, (struct ppp_option_data32 *)arg, sizeof(struct ppp_option_data32)))
  1071. return -EFAULT;
  1072. data.ptr = kmalloc (data32.length, GFP_KERNEL);
  1073. if (!data.ptr)
  1074. return -ENOMEM;
  1075. if (copy_from_user(data.ptr, (__u8 *)A(data32.ptr), data32.length)) {
  1076. kfree(data.ptr);
  1077. return -EFAULT;
  1078. }
  1079. data.length = data32.length;
  1080. data.transmit = data32.transmit;
  1081. kcmd = PPPIOCSCOMPRESS;
  1082. karg = &data;
  1083. break;
  1084. default:
  1085. do {
  1086. static int count = 0;
  1087. if (++count <= 20)
  1088. printk(KERN_WARNING
  1089. "ppp_ioctl: Unknown cmd fd(%d) "
  1090. "cmd(%08x) arg(%08x)n",
  1091. (int)fd, (unsigned int)cmd, (unsigned int)arg);
  1092. } while(0);
  1093. return -EINVAL;
  1094. }
  1095. set_fs (KERNEL_DS);
  1096. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  1097. set_fs (old_fs);
  1098. switch (cmd) {
  1099. case PPPIOCGIDLE32:
  1100. if (err)
  1101. return err;
  1102. idle32.xmit_idle = idle.xmit_idle;
  1103. idle32.recv_idle = idle.recv_idle;
  1104. if (copy_to_user((struct ppp_idle32 *)arg, &idle32, sizeof(struct ppp_idle32)))
  1105. return -EFAULT;
  1106. break;
  1107. case PPPIOCSCOMPRESS32:
  1108. kfree(data.ptr);
  1109. break;
  1110. default:
  1111. break;
  1112. }
  1113. return err;
  1114. }
  1117. struct mtget32 {
  1118. __u32 mt_type;
  1119. __u32 mt_resid;
  1120. __u32 mt_dsreg;
  1121. __u32 mt_gstat;
  1122. __u32 mt_erreg;
  1123. __kernel_daddr_t32 mt_fileno;
  1124. __kernel_daddr_t32 mt_blkno;
  1125. };
  1126. #define MTIOCGET32 _IOR('m', 2, struct mtget32)
  1128. struct mtpos32 {
  1129. __u32 mt_blkno;
  1130. };
  1131. #define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
  1133. struct mtconfiginfo32 {
  1134. __u32 mt_type;
  1135. __u32 ifc_type;
  1136. __u16 irqnr;
  1137. __u16 dmanr;
  1138. __u16 port;
  1139. __u32 debug;
  1140. __u32 have_dens:1;
  1141. __u32 have_bsf:1;
  1142. __u32 have_fsr:1;
  1143. __u32 have_bsr:1;
  1144. __u32 have_eod:1;
  1145. __u32 have_seek:1;
  1146. __u32 have_tell:1;
  1147. __u32 have_ras1:1;
  1148. __u32 have_ras2:1;
  1149. __u32 have_ras3:1;
  1150. __u32 have_qfa:1;
  1151. __u32 pad1:5;
  1152. char reserved[10];
  1153. };
  1154. #define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
  1155. #define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
  1157. static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1158. {
  1159. mm_segment_t old_fs = get_fs();
  1160. struct mtconfiginfo info;
  1161. struct mtget get;
  1162. struct mtpos pos;
  1163. unsigned long kcmd;
  1164. void *karg;
  1165. int err = 0;
  1167. switch(cmd) {
  1168. case MTIOCPOS32:
  1169. kcmd = MTIOCPOS;
  1170. karg = &pos;
  1171. break;
  1172. case MTIOCGET32:
  1173. kcmd = MTIOCGET;
  1174. karg = &get;
  1175. break;
  1176. case MTIOCGETCONFIG32:
  1177. kcmd = MTIOCGETCONFIG;
  1178. karg = &info;
  1179. break;
  1180. case MTIOCSETCONFIG32:
  1181. kcmd = MTIOCSETCONFIG;
  1182. karg = &info;
  1183. err = __get_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
  1184. err |= __get_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
  1185. err |= __get_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
  1186. err |= __get_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
  1187. err |= __get_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
  1188. err |= __get_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
  1189. err |= __copy_from_user((char *)&info.debug + sizeof(info.debug),
  1190.      (char *)&((struct mtconfiginfo32 *)arg)->debug
  1191.      + sizeof(((struct mtconfiginfo32 *)arg)->debug), sizeof(__u32));
  1192. if (err)
  1193. return -EFAULT;
  1194. break;
  1195. default:
  1196. do {
  1197. static int count = 0;
  1198. if (++count <= 20)
  1199. printk(KERN_WARNING
  1200. "mt_ioctl: Unknown cmd fd(%d) "
  1201. "cmd(%08x) arg(%08x)n",
  1202. (int)fd, (unsigned int)cmd, (unsigned int)arg);
  1203. } while(0);
  1204. return -EINVAL;
  1205. }
  1206. set_fs (KERNEL_DS);
  1207. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  1208. set_fs (old_fs);
  1209. if (err)
  1210. return err;
  1211. switch (cmd) {
  1212. case MTIOCPOS32:
  1213. err = __put_user(pos.mt_blkno, &((struct mtpos32 *)arg)->mt_blkno);
  1214. break;
  1215. case MTIOCGET32:
  1216. err = __put_user(get.mt_type, &((struct mtget32 *)arg)->mt_type);
  1217. err |= __put_user(get.mt_resid, &((struct mtget32 *)arg)->mt_resid);
  1218. err |= __put_user(get.mt_dsreg, &((struct mtget32 *)arg)->mt_dsreg);
  1219. err |= __put_user(get.mt_gstat, &((struct mtget32 *)arg)->mt_gstat);
  1220. err |= __put_user(get.mt_erreg, &((struct mtget32 *)arg)->mt_erreg);
  1221. err |= __put_user(get.mt_fileno, &((struct mtget32 *)arg)->mt_fileno);
  1222. err |= __put_user(get.mt_blkno, &((struct mtget32 *)arg)->mt_blkno);
  1223. break;
  1224. case MTIOCGETCONFIG32:
  1225. err = __put_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
  1226. err |= __put_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
  1227. err |= __put_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
  1228. err |= __put_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
  1229. err |= __put_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
  1230. err |= __put_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
  1231. err |= __copy_to_user((char *)&((struct mtconfiginfo32 *)arg)->debug
  1232.         + sizeof(((struct mtconfiginfo32 *)arg)->debug),
  1233.    (char *)&info.debug + sizeof(info.debug), sizeof(__u32));
  1234. break;
  1235. case MTIOCSETCONFIG32:
  1236. break;
  1237. }
  1238. return err ? -EFAULT: 0;
  1239. }
  1241. struct cdrom_read32 {
  1242. int cdread_lba;
  1243. __kernel_caddr_t32 cdread_bufaddr;
  1244. int cdread_buflen;
  1245. };
  1247. struct cdrom_read_audio32 {
  1248. union cdrom_addr addr;
  1249. u_char addr_format;
  1250. int nframes;
  1251. __kernel_caddr_t32 buf;
  1252. };
  1254. struct cdrom_generic_command32 {
  1255. unsigned char cmd[CDROM_PACKET_SIZE];
  1256. __kernel_caddr_t32 buffer;
  1257. unsigned int buflen;
  1258. int stat;
  1259. __kernel_caddr_t32 sense;
  1260. __kernel_caddr_t32 reserved[3];
  1261. };
  1263. static int cdrom_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1264. {
  1265. mm_segment_t old_fs = get_fs();
  1266. struct cdrom_read cdread;
  1267. struct cdrom_read_audio cdreadaudio;
  1268. struct cdrom_generic_command cgc;
  1269. __kernel_caddr_t32 addr;
  1270. char *data = 0;
  1271. void *karg;
  1272. int err = 0;
  1274. switch(cmd) {
  1275. case CDROMREADMODE2:
  1276. case CDROMREADMODE1:
  1277. case CDROMREADRAW:
  1278. case CDROMREADCOOKED:
  1279. karg = &cdread;
  1280. err = __get_user(cdread.cdread_lba, &((struct cdrom_read32 *)arg)->cdread_lba);
  1281. err |= __get_user(addr, &((struct cdrom_read32 *)arg)->cdread_bufaddr);
  1282. err |= __get_user(cdread.cdread_buflen, &((struct cdrom_read32 *)arg)->cdread_buflen);
  1283. if (err)
  1284. return -EFAULT;
  1285. data = kmalloc(cdread.cdread_buflen, GFP_KERNEL);
  1286. if (!data)
  1287. return -ENOMEM;
  1288. cdread.cdread_bufaddr = data;
  1289. break;
  1290. case CDROMREADAUDIO:
  1291. karg = &cdreadaudio;
  1292. err = copy_from_user(&cdreadaudio.addr, &((struct cdrom_read_audio32 *)arg)->addr, sizeof(cdreadaudio.addr));
  1293. err |= __get_user(cdreadaudio.addr_format, &((struct cdrom_read_audio32 *)arg)->addr_format);
  1294. err |= __get_user(cdreadaudio.nframes, &((struct cdrom_read_audio32 *)arg)->nframes); 
  1295. err |= __get_user(addr, &((struct cdrom_read_audio32 *)arg)->buf);
  1296. if (err)
  1297. return -EFAULT;
  1298. data = kmalloc(cdreadaudio.nframes * 2352, GFP_KERNEL);
  1299. if (!data)
  1300. return -ENOMEM;
  1301. cdreadaudio.buf = data;
  1302. break;
  1303. case CDROM_SEND_PACKET:
  1304. karg = &cgc;
  1305. err = copy_from_user(cgc.cmd, &((struct cdrom_generic_command32 *)arg)->cmd, sizeof(cgc.cmd));
  1306. err |= __get_user(addr, &((struct cdrom_generic_command32 *)arg)->buffer);
  1307. err |= __get_user(cgc.buflen, &((struct cdrom_generic_command32 *)arg)->buflen);
  1308. if (err)
  1309. return -EFAULT;
  1310. if ((data = kmalloc(cgc.buflen, GFP_KERNEL)) == NULL)
  1311. return -ENOMEM;
  1312. cgc.buffer = data;
  1313. break;
  1314. default:
  1315. do {
  1316. static int count = 0;
  1317. if (++count <= 20)
  1318. printk(KERN_WARNING
  1319. "cdrom_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, cmd, (unsigned long)karg);
  1327. set_fs (old_fs);
  1328. if (err)
  1329. goto out;
  1330. switch (cmd) {
  1331. case CDROMREADMODE2:
  1332. case CDROMREADMODE1:
  1333. case CDROMREADRAW:
  1334. case CDROMREADCOOKED:
  1335. err = copy_to_user((char *)A(addr), data, cdread.cdread_buflen);
  1336. break;
  1337. case CDROMREADAUDIO:
  1338. err = copy_to_user((char *)A(addr), data, cdreadaudio.nframes * 2352);
  1339. break;
  1340. case CDROM_SEND_PACKET:
  1341. err = copy_to_user((char *)A(addr), data, cgc.buflen);
  1342. break;
  1343. default:
  1344. break;
  1345. }
  1346. out: if (data)
  1347. kfree(data);
  1348. return err ? -EFAULT : 0;
  1349. }
  1351. struct loop_info32 {
  1352. int lo_number;      /* ioctl r/o */
  1353. __kernel_dev_t32 lo_device;      /* ioctl r/o */
  1354. unsigned int lo_inode;       /* ioctl r/o */
  1355. __kernel_dev_t32 lo_rdevice;     /* ioctl r/o */
  1356. int lo_offset;
  1357. int lo_encrypt_type;
  1358. int lo_encrypt_key_size;    /* ioctl w/o */
  1359. int lo_flags;       /* ioctl r/o */
  1360. char lo_name[LO_NAME_SIZE];
  1361. unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
  1362. unsigned int lo_init[2];
  1363. char reserved[4];
  1364. };
  1366. static int loop_status(unsigned int fd, unsigned int cmd, unsigned long arg)
  1367. {
  1368. mm_segment_t old_fs = get_fs();
  1369. struct loop_info l;
  1370. int err = -EINVAL;
  1372. switch(cmd) {
  1373. case LOOP_SET_STATUS:
  1374. err = get_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
  1375. err |= __get_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
  1376. err |= __get_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
  1377. err |= __get_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
  1378. err |= __copy_from_user((char *)&l.lo_offset, (char *)&((struct loop_info32 *)arg)->lo_offset,
  1379.    8 + (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
  1380. if (err) {
  1381. err = -EFAULT;
  1382. } else {
  1383. set_fs (KERNEL_DS);
  1384. err = sys_ioctl (fd, cmd, (unsigned long)&l);
  1385. set_fs (old_fs);
  1386. }
  1387. break;
  1388. case LOOP_GET_STATUS:
  1389. set_fs (KERNEL_DS);
  1390. err = sys_ioctl (fd, cmd, (unsigned long)&l);
  1391. set_fs (old_fs);
  1392. if (!err) {
  1393. err = put_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
  1394. err |= __put_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
  1395. err |= __put_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
  1396. err |= __put_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
  1397. err |= __copy_to_user((char *)&((struct loop_info32 *)arg)->lo_offset,
  1398.    (char *)&l.lo_offset, (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
  1399. if (err)
  1400. err = -EFAULT;
  1401. }
  1402. break;
  1403. default: {
  1404. static int count = 0;
  1405. if (++count <= 20)
  1406. printk(KERN_WARNING
  1407. "%s: Unknown loop ioctl cmd, fd(%d) "
  1408. "cmd(%08x) arg(%08lx)n",
  1409. __FUNCTION__, fd, cmd, arg);
  1410. }
  1411. }
  1412. return err;
  1413. }
  1415. #ifdef CONFIG_VT
  1416. extern int tty_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg);
  1418. static int vt_check(struct file *file)
  1419. {
  1420. struct tty_struct *tty;
  1421. struct inode *inode = file->f_dentry->d_inode;
  1423. if (file->f_op->ioctl != tty_ioctl)
  1424. return -EINVAL;
  1425.                 
  1426. tty = (struct tty_struct *)file->private_data;
  1427. if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
  1428. return -EINVAL;
  1429.                                                 
  1430. if (tty->driver.ioctl != vt_ioctl)
  1431. return -EINVAL;
  1433. /*
  1434.  * To have permissions to do most of the vt ioctls, we either have
  1435.  * to be the owner of the tty, or super-user.
  1436.  */
  1437. if (current->tty == tty || suser())
  1438. return 1;
  1439. return 0;                                                    
  1440. }
  1442. struct consolefontdesc32 {
  1443. unsigned short charcount;       /* characters in font (256 or 512) */
  1444. unsigned short charheight;      /* scan lines per character (1-32) */
  1445. u32 chardata; /* font data in expanded form */
  1446. };
  1448. static int do_fontx_ioctl(unsigned int fd, int cmd, struct consolefontdesc32 *user_cfd, struct file *file)
  1449. {
  1450. struct consolefontdesc cfdarg;
  1451. struct console_font_op op;
  1452. int i, perm;
  1454. perm = vt_check(file);
  1455. if (perm < 0) return perm;
  1457. if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc32)))
  1458. return -EFAULT;
  1460. cfdarg.chardata = (unsigned char *)A(((struct consolefontdesc32 *)&cfdarg)->chardata);
  1461.  
  1462. switch (cmd) {
  1463. case PIO_FONTX:
  1464. if (!perm)
  1465. return -EPERM;
  1466. op.op = KD_FONT_OP_SET;
  1467. op.flags = 0;
  1468. op.width = 8;
  1469. op.height = cfdarg.charheight;
  1470. op.charcount = cfdarg.charcount;
  1471. op.data = cfdarg.chardata;
  1472. return con_font_op(fg_console, &op);
  1473. case GIO_FONTX:
  1474. if (!cfdarg.chardata)
  1475. return 0;
  1476. op.op = KD_FONT_OP_GET;
  1477. op.flags = 0;
  1478. op.width = 8;
  1479. op.height = cfdarg.charheight;
  1480. op.charcount = cfdarg.charcount;
  1481. op.data = cfdarg.chardata;
  1482. i = con_font_op(fg_console, &op);
  1483. if (i)
  1484. return i;
  1485. cfdarg.charheight = op.height;
  1486. cfdarg.charcount = op.charcount;
  1487. ((struct consolefontdesc32 *)&cfdarg)->chardata = (unsigned long)cfdarg.chardata;
  1488. if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc32)))
  1489. return -EFAULT;
  1490. return 0;
  1491. }
  1492. return -EINVAL;
  1493. }
  1495. struct console_font_op32 {
  1496. unsigned int op;        /* operation code KD_FONT_OP_* */
  1497. unsigned int flags;     /* KD_FONT_FLAG_* */
  1498. unsigned int width, height;     /* font size */
  1499. unsigned int charcount;
  1500. u32 data;    /* font data with height fixed to 32 */
  1501. };
  1502.                                         
  1503. static int do_kdfontop_ioctl(unsigned int fd, unsigned int cmd, struct console_font_op32 *fontop, struct file *file)
  1504. {
  1505. struct console_font_op op;
  1506. int perm = vt_check(file), i;
  1507. struct vt_struct *vt;
  1509. if (perm < 0) return perm;
  1511. if (copy_from_user(&op, (void *) fontop, sizeof(struct console_font_op32)))
  1512. return -EFAULT;
  1513. if (!perm && op.op != KD_FONT_OP_GET)
  1514. return -EPERM;
  1515. op.data = (unsigned char *)A(((struct console_font_op32 *)&op)->data);
  1516. op.flags |= KD_FONT_FLAG_OLD;
  1517. vt = (struct vt_struct *)((struct tty_struct *)file->private_data)->driver_data;
  1518. i = con_font_op(vt->vc_num, &op);
  1519. if (i) return i;
  1520. ((struct console_font_op32 *)&op)->data = (unsigned long)op.data;
  1521. if (copy_to_user((void *) fontop, &op, sizeof(struct console_font_op32)))
  1522. return -EFAULT;
  1523. return 0;
  1524. }
  1526. struct unimapdesc32 {
  1527. unsigned short entry_ct;
  1528. u32 entries;
  1529. };
  1531. static int do_unimap_ioctl(unsigned int fd, unsigned int cmd, struct unimapdesc32 *user_ud, struct file *file)
  1532. {
  1533. struct unimapdesc32 tmp;
  1534. int perm = vt_check(file);
  1536. if (perm < 0) return perm;
  1537. if (copy_from_user(&tmp, user_ud, sizeof tmp))
  1538. return -EFAULT;
  1539. switch (cmd) {
  1540. case PIO_UNIMAP:
  1541. if (!perm) return -EPERM;
  1542. return con_set_unimap(fg_console, tmp.entry_ct, (struct unipair *)A(tmp.entries));
  1543. case GIO_UNIMAP:
  1544. return con_get_unimap(fg_console, tmp.entry_ct, &(user_ud->entry_ct), (struct unipair *)A(tmp.entries));
  1545. }
  1546. return 0;
  1547. }
  1548. #endif
  1550. #if 0
  1551. static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, unsigned long arg)
  1552. {
  1553. mm_segment_t old_fs = get_fs();
  1554. __kernel_uid_t kuid;
  1555. int err;
  1557. cmd = SMB_IOC_GETMOUNTUID;
  1559. set_fs(KERNEL_DS);
  1560. err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
  1561. set_fs(old_fs);
  1563. if (err >= 0)
  1564. err = put_user(kuid, (__kernel_uid_t32 *)arg);
  1566. return err;
  1567. }
  1568. #endif
  1570. struct atmif_sioc32 {
  1571.         int                number;
  1572.         int                length;
  1573.         __kernel_caddr_t32 arg;
  1574. };
  1576. struct atm_iobuf32 {
  1577. int                length;
  1578. __kernel_caddr_t32 buffer;
  1579. };
  1581. #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
  1582. #define ATM_GETNAMES32    _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
  1583. #define ATM_GETTYPE32     _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
  1584. #define ATM_GETESI32   _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
  1585. #define ATM_GETADDR32   _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
  1586. #define ATM_RSTADDR32   _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
  1587. #define ATM_ADDADDR32   _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
  1588. #define ATM_DELADDR32   _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
  1589. #define ATM_GETCIRANGE32  _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
  1590. #define ATM_SETCIRANGE32  _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
  1591. #define ATM_SETESI32      _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
  1592. #define ATM_SETESIF32     _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
  1593. #define ATM_GETSTAT32     _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
  1594. #define ATM_GETSTATZ32    _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
  1595. #define ATM_GETLOOP32   _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
  1596. #define ATM_SETLOOP32   _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
  1597. #define ATM_QUERYLOOP32   _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
  1599. static struct {
  1600.         unsigned int cmd32;
  1601.         unsigned int cmd;
  1602. } atm_ioctl_map[] = {
  1603.         { ATM_GETLINKRATE32, ATM_GETLINKRATE },
  1604. { ATM_GETNAMES32,    ATM_GETNAMES },
  1605.         { ATM_GETTYPE32,     ATM_GETTYPE },
  1606.         { ATM_GETESI32,      ATM_GETESI },
  1607.         { ATM_GETADDR32,     ATM_GETADDR },
  1608.         { ATM_RSTADDR32,     ATM_RSTADDR },
  1609.         { ATM_ADDADDR32,     ATM_ADDADDR },
  1610.         { ATM_DELADDR32,     ATM_DELADDR },
  1611.         { ATM_GETCIRANGE32,  ATM_GETCIRANGE },
  1612. { ATM_SETCIRANGE32,  ATM_SETCIRANGE },
  1613. { ATM_SETESI32,      ATM_SETESI },
  1614. { ATM_SETESIF32,     ATM_SETESIF },
  1615. { ATM_GETSTAT32,     ATM_GETSTAT },
  1616. { ATM_GETSTATZ32,    ATM_GETSTATZ },
  1617. { ATM_GETLOOP32,     ATM_GETLOOP },
  1618. { ATM_SETLOOP32,     ATM_SETLOOP },
  1619. { ATM_QUERYLOOP32,   ATM_QUERYLOOP }
  1620. };
  1622. #define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
  1625. static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg)
  1626. {
  1627. struct atm_iobuf32 iobuf32;
  1628. struct atm_iobuf   iobuf = { 0, NULL };
  1629. mm_segment_t old_fs;
  1630. int err;
  1632. err = copy_from_user(&iobuf32, (struct atm_iobuf32*)arg,
  1633.     sizeof(struct atm_iobuf32));
  1634. if (err)
  1635. return -EFAULT;
  1637. iobuf.length = iobuf32.length;
  1639. if (iobuf32.buffer == (__kernel_caddr_t32) NULL || iobuf32.length == 0) {
  1640. iobuf.buffer = (void*)(unsigned long)iobuf32.buffer;
  1641. } else {
  1642. iobuf.buffer = kmalloc(iobuf.length, GFP_KERNEL);
  1643. if (iobuf.buffer == NULL) {
  1644. err = -ENOMEM;
  1645. goto out;
  1646. }
  1648. err = copy_from_user(iobuf.buffer, A(iobuf32.buffer), iobuf.length);
  1649. if (err) {
  1650. err = -EFAULT;
  1651. goto out;
  1652. }
  1653. }
  1655. old_fs = get_fs(); set_fs (KERNEL_DS);
  1656. err = sys_ioctl (fd, cmd, (unsigned long)&iobuf);      
  1657. set_fs (old_fs);
  1658.         if(err)
  1659. goto out;
  1661.         if(iobuf.buffer && iobuf.length > 0) {
  1662. err = copy_to_user(A(iobuf32.buffer), iobuf.buffer, iobuf.length);
  1663. if (err) {
  1664. err = -EFAULT;
  1665. goto out;
  1666. }
  1667. }
  1668. err = __put_user(iobuf.length, &(((struct atm_iobuf32*)arg)->length));
  1670.  out:
  1671.         if(iobuf32.buffer && iobuf32.length > 0)
  1672. kfree(iobuf.buffer);
  1674. return err;
  1675. }
  1678. static int do_atmif_sioc(unsigned int fd, unsigned int cmd, unsigned long arg)
  1679. {
  1680.         struct atmif_sioc32 sioc32;
  1681.         struct atmif_sioc   sioc = { 0, 0, NULL };
  1682.         mm_segment_t old_fs;
  1683.         int err;
  1684.         
  1685.         err = copy_from_user(&sioc32, (struct atmif_sioc32*)arg,
  1686.      sizeof(struct atmif_sioc32));
  1687.         if (err)
  1688.                 return -EFAULT;
  1690.         sioc.number = sioc32.number;
  1691.         sioc.length = sioc32.length;
  1692.         
  1693. if (sioc32.arg == (__kernel_caddr_t32) NULL || sioc32.length == 0) {
  1694. sioc.arg = (void*)(unsigned long)sioc32.arg;
  1695.         } else {
  1696.                 sioc.arg = kmalloc(sioc.length, GFP_KERNEL);
  1697.                 if (sioc.arg == NULL) {
  1698.                         err = -ENOMEM;
  1699. goto out;
  1700. }
  1701.                 
  1702.                 err = copy_from_user(sioc.arg, A(sioc32.arg), sioc32.length);
  1703.                 if (err) {
  1704.                         err = -EFAULT;
  1705.                         goto out;
  1706.                 }
  1707.         }
  1708.         
  1709.         old_fs = get_fs(); set_fs (KERNEL_DS);
  1710.         err = sys_ioctl (fd, cmd, (unsigned long)&sioc);
  1711.         set_fs (old_fs);
  1712.         if(err) {
  1713.                 goto out;
  1714. }
  1715.         
  1716.         if(sioc.arg && sioc.length > 0) {
  1717.                 err = copy_to_user(A(sioc32.arg), sioc.arg, sioc.length);
  1718.                 if (err) {
  1719.                         err = -EFAULT;
  1720.                         goto out;
  1721.                 }
  1722.         }
  1723.         err = __put_user(sioc.length, &(((struct atmif_sioc32*)arg)->length));
  1724.         
  1725.  out:
  1726.         if(sioc32.arg && sioc32.length > 0)
  1727. kfree(sioc.arg);
  1728.         
  1729. return err;
  1730. }
  1733. static int do_atm_ioctl(unsigned int fd, unsigned int cmd32, unsigned long arg)
  1734. {
  1735.         int i;
  1736.         unsigned int cmd = 0;
  1737.         
  1738. switch (cmd32) {
  1739. case SONET_GETSTAT:
  1740. case SONET_GETSTATZ:
  1741. case SONET_GETDIAG:
  1742. case SONET_SETDIAG:
  1743. case SONET_CLRDIAG:
  1744. case SONET_SETFRAMING:
  1745. case SONET_GETFRAMING:
  1746. case SONET_GETFRSENSE:
  1747. return do_atmif_sioc(fd, cmd32, arg);
  1748. }
  1750. for (i = 0; i < NR_ATM_IOCTL; i++) {
  1751. if (cmd32 == atm_ioctl_map[i].cmd32) {
  1752. cmd = atm_ioctl_map[i].cmd;
  1753. break;
  1754. }
  1755. }
  1756.         if (i == NR_ATM_IOCTL) {
  1757.         return -EINVAL;
  1758.         }
  1759.         
  1760.         switch (cmd) {
  1761. case ATM_GETNAMES:
  1762. return do_atm_iobuf(fd, cmd, arg);
  1763.     
  1764. case ATM_GETLINKRATE:
  1765.         case ATM_GETTYPE:
  1766.         case ATM_GETESI:
  1767.         case ATM_GETADDR:
  1768.         case ATM_RSTADDR:
  1769.         case ATM_ADDADDR:
  1770.         case ATM_DELADDR:
  1771.         case ATM_GETCIRANGE:
  1772. case ATM_SETCIRANGE:
  1773. case ATM_SETESI:
  1774. case ATM_SETESIF:
  1775. case ATM_GETSTAT:
  1776. case ATM_GETSTATZ:
  1777. case ATM_GETLOOP:
  1778. case ATM_SETLOOP:
  1779. case ATM_QUERYLOOP:
  1780.                 return do_atmif_sioc(fd, cmd, arg);
  1781.         }
  1783.         return -EINVAL;
  1784. }
  1786. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  1787. /* Ugh, LVM. Pitty it was not cleaned up before accepted :((. */
  1788. typedef struct {
  1789. uint8_t vg_name[NAME_LEN];
  1790. uint32_t vg_number;
  1791. uint32_t vg_access;
  1792. uint32_t vg_status;
  1793. uint32_t lv_max;
  1794. uint32_t lv_cur;
  1795. uint32_t lv_open;
  1796. uint32_t pv_max;
  1797. uint32_t pv_cur;
  1798. uint32_t pv_act;
  1799. uint32_t dummy;
  1800. uint32_t vgda;
  1801. uint32_t pe_size;
  1802. uint32_t pe_total;
  1803. uint32_t pe_allocated;
  1804. uint32_t pvg_total;
  1805. u32 proc;
  1806. u32 pv[ABS_MAX_PV + 1];
  1807. u32 lv[ABS_MAX_LV + 1];
  1808.      uint8_t vg_uuid[UUID_LEN+1]; /* volume group UUID */
  1809. uint8_t dummy1[200];
  1810. } vg32_t;
  1812. typedef struct {
  1813. uint8_t id[2];
  1814. uint16_t version;
  1815. lvm_disk_data_t pv_on_disk;
  1816. lvm_disk_data_t vg_on_disk;
  1817. lvm_disk_data_t pv_namelist_on_disk;
  1818. lvm_disk_data_t lv_on_disk;
  1819. lvm_disk_data_t pe_on_disk;
  1820. uint8_t pv_name[NAME_LEN];
  1821. uint8_t vg_name[NAME_LEN];
  1822. uint8_t system_id[NAME_LEN];
  1823. kdev_t pv_dev;
  1824. uint32_t pv_number;
  1825. uint32_t pv_status;
  1826. uint32_t pv_allocatable;
  1827. uint32_t pv_size;
  1828. uint32_t lv_cur;
  1829. uint32_t pe_size;
  1830. uint32_t pe_total;
  1831. uint32_t pe_allocated;
  1832. uint32_t pe_stale;
  1833. u32 pe;
  1834. u32 inode;
  1835. uint8_t pv_uuid[UUID_LEN+1];
  1836. } pv32_t;
  1838. typedef struct {
  1839. char lv_name[NAME_LEN];
  1840. u32 lv;
  1841. } lv_req32_t;
  1843. typedef struct {
  1844. u32 lv_index;
  1845. u32 lv;
  1846. /* Transfer size because user space and kernel space differ */
  1847. uint16_t size;
  1848. } lv_status_byindex_req32_t;
  1850. typedef struct {
  1851. __kernel_dev_t32 dev;
  1852. u32   lv;
  1853. } lv_status_bydev_req32_t;
  1855. typedef struct {
  1856. uint8_t lv_name[NAME_LEN];
  1857. kdev_t old_dev;
  1858. kdev_t new_dev;
  1859. u32 old_pe;
  1860. u32 new_pe;
  1861. } le_remap_req32_t;
  1863. typedef struct {
  1864. char pv_name[NAME_LEN];
  1865. u32 pv;
  1866. } pv_status_req32_t;
  1868. typedef struct {
  1869. uint8_t lv_name[NAME_LEN];
  1870. uint8_t vg_name[NAME_LEN];
  1871. uint32_t lv_access;
  1872. uint32_t lv_status;
  1873. uint32_t lv_open;
  1874. kdev_t lv_dev;
  1875. uint32_t lv_number;
  1876. uint32_t lv_mirror_copies;
  1877. uint32_t lv_recovery;
  1878. uint32_t lv_schedule;
  1879. uint32_t lv_size;
  1880. u32 lv_current_pe;
  1881. uint32_t lv_current_le;
  1882. uint32_t lv_allocated_le;
  1883. uint32_t lv_stripes;
  1884. uint32_t lv_stripesize;
  1885. uint32_t lv_badblock;
  1886. uint32_t lv_allocation;
  1887. uint32_t lv_io_timeout;
  1888. uint32_t lv_read_ahead;
  1889. /* delta to version 1 starts here */
  1890. u32 lv_snapshot_org;
  1891. u32 lv_snapshot_prev;
  1892. u32 lv_snapshot_next;
  1893. u32 lv_block_exception;
  1894. uint32_t lv_remap_ptr;
  1895. uint32_t lv_remap_end;
  1896. uint32_t lv_chunk_size;
  1897. uint32_t lv_snapshot_minor;
  1898. char dummy[200];
  1899. } lv32_t;
  1901. typedef struct {
  1902. u32 hash[2];
  1903. u32 rsector_org;
  1904. kdev_t rdev_org;
  1905. u32 rsector_new;
  1906. kdev_t rdev_new;
  1907. } lv_block_exception32_t;
  1909. static void put_lv_t(lv_t *l)
  1910. {
  1911. if (l->lv_current_pe) vfree(l->lv_current_pe);
  1912. if (l->lv_block_exception) vfree(l->lv_block_exception);
  1913. kfree(l);
  1914. }
  1916. static lv_t *get_lv_t(u32 p, int *errp)
  1917. {
  1918. int err, i;
  1919. u32 ptr1, ptr2;
  1920. size_t size;
  1921. lv_block_exception32_t *lbe32;
  1922. lv_block_exception_t *lbe;
  1923. lv32_t *ul = (lv32_t *)A(p);
  1924. lv_t *l = (lv_t *) kmalloc(sizeof(lv_t), GFP_KERNEL);
  1926. if (!l) {
  1927. *errp = -ENOMEM;
  1928. return NULL;
  1929. }
  1930. memset(l, 0, sizeof(lv_t));
  1931. err = copy_from_user(l, ul, (long)&((lv32_t *)0)->lv_current_pe);
  1932. err |= __copy_from_user(&l->lv_current_le, &ul->lv_current_le,
  1933. ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
  1934. err |= __copy_from_user(&l->lv_remap_ptr, &ul->lv_remap_ptr,
  1935. ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
  1936. err |= __get_user(ptr1, &ul->lv_current_pe);
  1937. err |= __get_user(ptr2, &ul->lv_block_exception);
  1938. if (err) {
  1939. kfree(l);
  1940. *errp = -EFAULT;
  1941. return NULL;
  1942. }
  1943. if (ptr1) {
  1944. size = l->lv_allocated_le * sizeof(pe_t);
  1945. l->lv_current_pe = vmalloc(size);
  1946. if (l->lv_current_pe)
  1947. err = copy_from_user(l->lv_current_pe, (void *)A(ptr1), size);
  1948. }
  1949. if (!err && ptr2) {
  1950. size = l->lv_remap_end * sizeof(lv_block_exception_t);
  1951. l->lv_block_exception = lbe = vmalloc(size);
  1952. if (l->lv_block_exception) {
  1953. lbe32 = (lv_block_exception32_t *)A(ptr2);
  1954. memset(lbe, 0, size);
  1955. for (i = 0; i < l->lv_remap_end; i++, lbe++, lbe32++) {
  1956. err |= get_user(lbe->rsector_org, &lbe32->rsector_org);
  1957. err |= __get_user(lbe->rdev_org, &lbe32->rdev_org);
  1958. err |= __get_user(lbe->rsector_new, &lbe32->rsector_new);
  1959. err |= __get_user(lbe->rdev_new, &lbe32->rdev_new);
  1960. }
  1961. }
  1962. }
  1963. if (err || (ptr1 && !l->lv_current_pe) || (ptr2 && !l->lv_block_exception)) {
  1964. if (!err)
  1965. *errp = -ENOMEM;
  1966. else
  1967. *errp = -EFAULT;
  1968. put_lv_t(l);
  1969. return NULL;
  1970. }
  1971. return l;
  1972. }
  1974. static int copy_lv_t(u32 ptr, lv_t *l)
  1975. {
  1976. int err;
  1977. lv32_t *ul = (lv32_t *)A(ptr);
  1978. u32 ptr1;
  1979. size_t size;
  1981. err = get_user(ptr1, &ul->lv_current_pe);
  1982. if (err)
  1983. return -EFAULT;
  1984. err = copy_to_user(ul, l, (long)&((lv32_t *)0)->lv_current_pe);
  1985. err |= __copy_to_user(&ul->lv_current_le, &l->lv_current_le,
  1986. ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
  1987. err |= __copy_to_user(&ul->lv_remap_ptr, &l->lv_remap_ptr,
  1988. ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
  1989. size = l->lv_allocated_le * sizeof(pe_t);
  1990. if (ptr1)
  1991. err |= __copy_to_user((void *)A(ptr1), l->lv_current_pe, size);
  1992. return err ? -EFAULT : 0;
  1993. }
  1995. static int do_lvm_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  1996. {
  1997. vg_t *v = NULL;
  1998. union {
  1999. lv_req_t lv_req;
  2000. le_remap_req_t le_remap;
  2001. lv_status_byindex_req_t lv_byindex;
  2002.         lv_status_bydev_req_t lv_bydev;
  2003. pv_status_req_t pv_status;
  2004. } u;
  2005. pv_t p;
  2006. int err;
  2007. u32 ptr = 0;
  2008. int i;
  2009. mm_segment_t old_fs;
  2010. void *karg = &u;
  2012. switch (cmd) {
  2013. case VG_STATUS:
  2014. v = kmalloc(sizeof(vg_t), GFP_KERNEL);
  2015. if (!v)
  2016. return -ENOMEM;
  2017. karg = v;
  2018. break;
  2020. case VG_CREATE_OLD:
  2021. case VG_CREATE:
  2022. v = kmalloc(sizeof(vg_t), GFP_KERNEL);
  2023. if (!v)
  2024. return -ENOMEM;
  2025. if (copy_from_user(v, (void *)arg, (long)&((vg32_t *)0)->proc)) {
  2026. kfree(v);
  2027. return -EFAULT;
  2028. }
  2029. /* 'proc' field is unused, just NULL it out. */
  2030. v->proc = NULL;
  2031. if (copy_from_user(v->vg_uuid, ((vg32_t *)arg)->vg_uuid, UUID_LEN+1)) {
  2032. kfree(v);
  2033. return -EFAULT;
  2034. }
  2035.     
  2036. karg = v;
  2037. memset(v->pv, 0, sizeof(v->pv) + sizeof(v->lv));
  2038. if (v->pv_max > ABS_MAX_PV || v->lv_max > ABS_MAX_LV)
  2039. return -EPERM;
  2040. for (i = 0; i < v->pv_max; i++) {
  2041. err = __get_user(ptr, &((vg32_t *)arg)->pv[i]);
  2042. if (err)
  2043. break;
  2044. if (ptr) {
  2045. v->pv[i] = kmalloc(sizeof(pv_t), GFP_KERNEL);
  2046. if (!v->pv[i]) {
  2047. err = -ENOMEM;
  2048. break;
  2049. }
  2050. err = copy_from_user(v->pv[i], (void *)A(ptr),
  2051.      sizeof(pv32_t) - 8 - UUID_LEN+1);
  2052. if (err) {
  2053. err = -EFAULT;
  2054. break;
  2055. }
  2056. err = copy_from_user(v->pv[i]->pv_uuid,
  2057.      ((pv32_t *)A(ptr))->pv_uuid,
  2058.      UUID_LEN+1);
  2059. if (err) {
  2060.         err = -EFAULT;
  2061. break;
  2062. }
  2064. v->pv[i]->pe = NULL;
  2065. v->pv[i]->bd = NULL;
  2066. }
  2067. }
  2068. if (!err) {
  2069. for (i = 0; i < v->lv_max; i++) {
  2070. err = __get_user(ptr, &((vg32_t *)arg)->lv[i]);
  2071. if (err)
  2072. break;
  2073. if (ptr) {
  2074. v->lv[i] = get_lv_t(ptr, &err);
  2075. if (err)
  2076. break;
  2077. }
  2078. }
  2079. }
  2080. break;
  2082. case LV_CREATE:
  2083. case LV_EXTEND:
  2084. case LV_REDUCE:
  2085. case LV_REMOVE:
  2086. case LV_RENAME:
  2087. case LV_STATUS_BYNAME:
  2088.         err = copy_from_user(&u.pv_status, arg, sizeof(u.pv_status.pv_name));
  2089. if (err)
  2090. return -EFAULT;
  2091. if (cmd != LV_REMOVE) {
  2092. err = __get_user(ptr, &((lv_req32_t *)arg)->lv);
  2093. if (err)
  2094. return err;
  2095. u.lv_req.lv = get_lv_t(ptr, &err);
  2096. } else
  2097. u.lv_req.lv = NULL;
  2098. break;
  2100. case LV_STATUS_BYINDEX:
  2101. err = get_user(u.lv_byindex.lv_index,
  2102.        &((lv_status_byindex_req32_t *)arg)->lv_index);
  2103. err |= __get_user(ptr, &((lv_status_byindex_req32_t *)arg)->lv);
  2104. if (err)
  2105. return err;
  2106. u.lv_byindex.lv = get_lv_t(ptr, &err);
  2107. break;
  2109. case LV_STATUS_BYDEV:
  2110.         err = get_user(u.lv_bydev.dev, &((lv_status_bydev_req32_t *)arg)->dev);
  2111. err |= __get_user(ptr, &((lv_status_bydev_req32_t *)arg)->lv);
  2112. if (err)
  2113. return err;
  2114. u.lv_bydev.lv = get_lv_t(ptr, &err);
  2115. break;
  2117. case VG_EXTEND:
  2118. err = copy_from_user(&p, (void *)arg, sizeof(pv32_t) - 8 - UUID_LEN+1);
  2119. if (err)
  2120. return -EFAULT;
  2121. err = copy_from_user(p.pv_uuid, ((pv32_t *)arg)->pv_uuid, UUID_LEN+1);
  2122. if (err)
  2123. return -EFAULT;
  2124. p.pe = NULL;
  2125. p.bd = NULL;
  2126. karg = &p;
  2127. break;
  2129. case PV_CHANGE:
  2130. case PV_STATUS:
  2131. err = copy_from_user(&u.pv_status, arg, sizeof(u.lv_req.lv_name));
  2132. if (err)
  2133. return -EFAULT;
  2134. err = __get_user(ptr, &((pv_status_req32_t *)arg)->pv);
  2135. if (err)
  2136. return err;
  2137. u.pv_status.pv = &p;
  2138. if (cmd == PV_CHANGE) {
  2139. err = copy_from_user(&p, (void *)A(ptr),
  2140.      sizeof(pv32_t) - 8 - UUID_LEN+1);
  2141. if (err)
  2142. return -EFAULT;
  2143. p.pe = NULL;
  2144. p.bd = NULL;
  2145. }
  2146. break;
  2147. };
  2149.         old_fs = get_fs(); set_fs (KERNEL_DS);
  2150.         err = sys_ioctl (fd, cmd, (unsigned long)karg);
  2151.         set_fs (old_fs);
  2153. switch (cmd) {
  2154. case VG_STATUS:
  2155. if (!err) {
  2156. if (copy_to_user((void *)arg, v, (long)&((vg32_t *)0)->proc) ||
  2157.     clear_user(&((vg32_t *)arg)->proc, sizeof(vg32_t) - (long)&((vg32_t *)0)->proc))
  2158. err = -EFAULT;
  2159. }
  2160. if (copy_to_user(((vg32_t *)arg)->vg_uuid, v->vg_uuid, UUID_LEN+1)) {
  2161.         err = -EFAULT;
  2162. }
  2163. kfree(v);
  2164. break;
  2166. case VG_CREATE_OLD:
  2167. case VG_CREATE:
  2168. for (i = 0; i < v->pv_max; i++) {
  2169. if (v->pv[i])
  2170. kfree(v->pv[i]);
  2171. }
  2172. for (i = 0; i < v->lv_max; i++) {
  2173. if (v->lv[i])
  2174. put_lv_t(v->lv[i]);
  2175. }
  2176. kfree(v);
  2177. break;
  2179. case LV_STATUS_BYNAME:
  2180. if (!err && u.lv_req.lv)
  2181. err = copy_lv_t(ptr, u.lv_req.lv);
  2182. /* Fall through */
  2184.         case LV_CREATE:
  2185. case LV_EXTEND:
  2186. case LV_REDUCE:
  2187. if (u.lv_req.lv)
  2188. put_lv_t(u.lv_req.lv);
  2189. break;
  2191. case LV_STATUS_BYINDEX:
  2192. if (u.lv_byindex.lv) {
  2193. if (!err)
  2194. err = copy_lv_t(ptr, u.lv_byindex.lv);
  2195. put_lv_t(u.lv_byindex.lv);
  2196. }
  2197. break;
  2199. case LV_STATUS_BYDEV:
  2200.         if (u.lv_bydev.lv) {
  2201. if (!err)
  2202. err = copy_lv_t(ptr, u.lv_bydev.lv);
  2203. put_lv_t(u.lv_byindex.lv);
  2204.         }
  2205.         break;
  2207. case PV_STATUS:
  2208. if (!err) {
  2209. err = copy_to_user((void *)A(ptr), &p, sizeof(pv32_t) - 8 - UUID_LEN+1);
  2210. if (err)
  2211. return -EFAULT;
  2212. err = copy_to_user(((pv_t *)A(ptr))->pv_uuid, p.pv_uuid, UUID_LEN + 1);
  2213. if (err)
  2214. return -EFAULT;
  2215. }
  2216. break;
  2217. };
  2219. return err;
  2220. }
  2221. #endif
  2223. #ifdef CONFIG_GENRTC
  2224. #endif
  2226. #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
  2227. /* This really belongs in include/linux/drm.h -DaveM */
  2228. #include "../../../drivers/char/drm/drm.h"
  2230. typedef struct drm32_version {
  2231. int    version_major;   /* Major version     */
  2232. int    version_minor;   /* Minor version     */
  2233. int    version_patchlevel;/* Patch level     */
  2234. int    name_len;   /* Length of name buffer     */
  2235. u32    name;   /* Name of driver     */
  2236. int    date_len;   /* Length of date buffer     */
  2237. u32    date;   /* User-space buffer to hold date     */
  2238. int    desc_len;   /* Length of desc buffer     */
  2239. u32    desc;   /* User-space buffer to hold desc     */
  2240. } drm32_version_t;
  2241. #define DRM32_IOCTL_VERSION    DRM_IOWR(0x00, drm32_version_t)
  2243. static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
  2244. {
  2245. drm32_version_t *uversion = (drm32_version_t *)arg;
  2246. char *name_ptr, *date_ptr, *desc_ptr;
  2247. u32 tmp1, tmp2, tmp3;
  2248. drm_version_t kversion;
  2249. mm_segment_t old_fs;
  2250. int ret;
  2252. memset(&kversion, 0, sizeof(kversion));
  2253. if (get_user(kversion.name_len, &uversion->name_len) ||
  2254.     get_user(kversion.date_len, &uversion->date_len) ||
  2255.     get_user(kversion.desc_len, &uversion->desc_len) ||
  2256.     get_user(tmp1, &uversion->name) ||
  2257.     get_user(tmp2, &uversion->date) ||
  2258.     get_user(tmp3, &uversion->desc))
  2259. return -EFAULT;
  2261. name_ptr = (char *) A(tmp1);
  2262. date_ptr = (char *) A(tmp2);
  2263. desc_ptr = (char *) A(tmp3);
  2265. ret = -ENOMEM;
  2266. if (kversion.name_len && name_ptr) {
  2267. kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
  2268. if (!kversion.name)
  2269. goto out;
  2270. }
  2271. if (kversion.date_len && date_ptr) {
  2272. kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
  2273. if (!kversion.date)
  2274. goto out;
  2275. }
  2276. if (kversion.desc_len && desc_ptr) {
  2277. kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
  2278. if (!kversion.desc)
  2279. goto out;
  2280. }
  2282.         old_fs = get_fs();
  2283. set_fs(KERNEL_DS);
  2284.         ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
  2285.         set_fs(old_fs);
  2287. if (!ret) {
  2288. if ((kversion.name &&
  2289.      copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
  2290.     (kversion.date &&
  2291.      copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
  2292.     (kversion.desc &&
  2293.      copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
  2294. ret = -EFAULT;
  2295. if (put_user(kversion.version_major, &uversion->version_major) ||
  2296.     put_user(kversion.version_minor, &uversion->version_minor) ||
  2297.     put_user(kversion.version_patchlevel, &uversion->version_patchlevel) ||
  2298.     put_user(kversion.name_len, &uversion->name_len) ||
  2299.     put_user(kversion.date_len, &uversion->date_len) ||
  2300.     put_user(kversion.desc_len, &uversion->desc_len))
  2301. ret = -EFAULT;
  2302. }
  2304. out:
  2305. if (kversion.name)
  2306. kfree(kversion.name);
  2307. if (kversion.date)
  2308. kfree(kversion.date);
  2309. if (kversion.desc)
  2310. kfree(kversion.desc);
  2311. return ret;
  2312. }
  2314. typedef struct drm32_unique {
  2315. int unique_len;   /* Length of unique     */
  2316. u32 unique;   /* Unique name for driver instantiation   */
  2317. } drm32_unique_t;
  2318. #define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
  2319. #define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
  2321. static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
  2322. {
  2323. drm32_unique_t *uarg = (drm32_unique_t *)arg;
  2324. drm_unique_t karg;
  2325. mm_segment_t old_fs;
  2326. char *uptr;
  2327. u32 tmp;
  2328. int ret;
  2330. if (get_user(karg.unique_len, &uarg->unique_len))
  2331. return -EFAULT;
  2332. karg.unique = NULL;
  2334. if (get_user(tmp, &uarg->unique))
  2335. return -EFAULT;
  2337. uptr = (char *) A(tmp);
  2339. if (uptr) {
  2340. karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
  2341. if (!karg.unique)
  2342. return -ENOMEM;
  2343. if (cmd == DRM32_IOCTL_SET_UNIQUE &&
  2344.     copy_from_user(karg.unique, uptr, karg.unique_len)) {
  2345. kfree(karg.unique);
  2346. return -EFAULT;
  2347. }
  2348. }
  2350. old_fs = get_fs();
  2351. set_fs(KERNEL_DS);
  2352. if (cmd == DRM32_IOCTL_GET_UNIQUE)
  2353. ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
  2354. else
  2355. ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
  2356.         set_fs(old_fs);
  2358. if (!ret) {
  2359. if (cmd == DRM32_IOCTL_GET_UNIQUE &&
  2360.     uptr != NULL &&
  2361.     copy_to_user(uptr, karg.unique, karg.unique_len))
  2362. ret = -EFAULT;
  2363. if (put_user(karg.unique_len, &uarg->unique_len))
  2364. ret = -EFAULT;
  2365. }
  2367. if (karg.unique != NULL)
  2368. kfree(karg.unique);
  2370. return ret;
  2371. }
  2373. typedef struct drm32_map {
  2374. u32 offset;  /* Requested physical address (0 for SAREA)*/
  2375. u32 size;  /* Requested physical size (bytes)     */
  2376. drm_map_type_t type;  /* Type of memory to map     */
  2377. drm_map_flags_t flags;  /* Flags     */
  2378. u32 handle;  /* User-space: "Handle" to pass to mmap    */
  2379.  /* Kernel-space: kernel-virtual address    */
  2380. int mtrr;  /* MTRR slot used     */
  2381.  /* Private data     */
  2382. } drm32_map_t;
  2383. #define DRM32_IOCTL_ADD_MAP    DRM_IOWR(0x15, drm32_map_t)
  2385. static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
  2386. {
  2387. drm32_map_t *uarg = (drm32_map_t *) arg;
  2388. drm_map_t karg;
  2389. mm_segment_t old_fs;
  2390. u32 tmp;
  2391. int ret;
  2393. ret  = get_user(karg.offset, &uarg->offset);
  2394. ret |= get_user(karg.size, &uarg->size);
  2395. ret |= get_user(karg.type, &uarg->type);
  2396. ret |= get_user(karg.flags, &uarg->flags);
  2397. ret |= get_user(tmp, &uarg->handle);
  2398. ret |= get_user(karg.mtrr, &uarg->mtrr);
  2399. if (ret)
  2400. return -EFAULT;
  2402. karg.handle = (void *) A(tmp);
  2404. old_fs = get_fs();
  2405. set_fs(KERNEL_DS);
  2406. ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
  2407. set_fs(old_fs);
  2409. if (!ret) {
  2410. ret  = put_user(karg.offset, &uarg->offset);
  2411. ret |= put_user(karg.size, &uarg->size);
  2412. ret |= put_user(karg.type, &uarg->type);
  2413. ret |= put_user(karg.flags, &uarg->flags);
  2414. tmp = (u32) (long)karg.handle;
  2415. ret |= put_user(tmp, &uarg->handle);
  2416. ret |= put_user(karg.mtrr, &uarg->mtrr);
  2417. if (ret)
  2418. ret = -EFAULT;
  2419. }
  2421. return ret;
  2422. }
  2424. typedef struct drm32_buf_info {
  2425. int        count; /* Entries in list      */
  2426. u32        list;    /* (drm_buf_desc_t *) */ 
  2427. } drm32_buf_info_t;
  2428. #define DRM32_IOCTL_INFO_BUFS  DRM_IOWR(0x18, drm32_buf_info_t)
  2430. static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
  2431. {
  2432. drm32_buf_info_t *uarg = (drm32_buf_info_t *)arg;
  2433. drm_buf_desc_t *ulist;
  2434. drm_buf_info_t karg;
  2435. mm_segment_t old_fs;
  2436. int orig_count, ret;
  2437. u32 tmp;
  2439. if (get_user(karg.count, &uarg->count) ||
  2440.     get_user(tmp, &uarg->list))
  2441. return -EFAULT;
  2443. ulist = (drm_buf_desc_t *) A(tmp);
  2445. orig_count = karg.count;
  2447. karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
  2448. if (!karg.list)
  2449. return -EFAULT;
  2451. old_fs = get_fs();
  2452. set_fs(KERNEL_DS);
  2453. ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
  2454. set_fs(old_fs);
  2456. if (!ret) {
  2457. if (karg.count <= orig_count &&
  2458.     (copy_to_user(ulist, karg.list,
  2459.   karg.count * sizeof(drm_buf_desc_t))))
  2460. ret = -EFAULT;
  2461. if (put_user(karg.count, &uarg->count))
  2462. ret = -EFAULT;
  2463. }
  2465. kfree(karg.list);
  2467. return ret;
  2468. }
  2470. typedef struct drm32_buf_free {
  2471. int        count;
  2472. u32        list; /* (int *) */
  2473. } drm32_buf_free_t;
  2474. #define DRM32_IOCTL_FREE_BUFS  DRM_IOW( 0x1a, drm32_buf_free_t)
  2476. static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
  2477. {
  2478. drm32_buf_free_t *uarg = (drm32_buf_free_t *)arg;
  2479. drm_buf_free_t karg;
  2480. mm_segment_t old_fs;
  2481. int *ulist;
  2482. int ret;
  2483. u32 tmp;
  2485. if (get_user(karg.count, &uarg->count) ||
  2486.     get_user(tmp, &uarg->list))
  2487. return -EFAULT;
  2489. ulist = (int *) A(tmp);
  2491. karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
  2492. if (!karg.list)
  2493. return -ENOMEM;
  2495. ret = -EFAULT;
  2496. if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
  2497. goto out;
  2499. old_fs = get_fs();
  2500. set_fs(KERNEL_DS);
  2501. ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
  2502. set_fs(old_fs);
  2504. out:
  2505. kfree(karg.list);
  2507. return ret;
  2508. }
  2510. typedef struct drm32_buf_pub {
  2511. int   idx;        /* Index into master buflist      */
  2512. int   total;       /* Buffer size      */
  2513. int   used;        /* Amount of buffer in use (for DMA)  */
  2514. u32   address;     /* Address of buffer (void *)      */
  2515. } drm32_buf_pub_t;
  2517. typedef struct drm32_buf_map {
  2518. int       count; /* Length of buflist     */
  2519. u32       virtual; /* Mmaped area in user-virtual (void *)     */
  2520. u32        list; /* Buffer information (drm_buf_pub_t *)     */
  2521. } drm32_buf_map_t;
  2522. #define DRM32_IOCTL_MAP_BUFS   DRM_IOWR(0x19, drm32_buf_map_t)
  2524. static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
  2525. {
  2526. drm32_buf_map_t *uarg = (drm32_buf_map_t *)arg;
  2527. drm32_buf_pub_t *ulist;
  2528. drm_buf_map_t karg;
  2529. mm_segment_t old_fs;
  2530. int orig_count, ret, i;
  2531. u32 tmp1, tmp2;
  2533. if (get_user(karg.count, &uarg->count) ||
  2534.     get_user(tmp1, &uarg->virtual) ||
  2535.     get_user(tmp2, &uarg->list))
  2536. return -EFAULT;
  2538. karg.virtual = (void *) A(tmp1);
  2539. ulist = (drm32_buf_pub_t *) A(tmp2);
  2541. orig_count = karg.count;
  2543. karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
  2544. if (!karg.list)
  2545. return -ENOMEM;
  2547. ret = -EFAULT;
  2548. for (i = 0; i < karg.count; i++) {
  2549. if (get_user(karg.list[i].idx, &ulist[i].idx) ||
  2550.     get_user(karg.list[i].total, &ulist[i].total) ||
  2551.     get_user(karg.list[i].used, &ulist[i].used) ||
  2552.     get_user(tmp1, &ulist[i].address))
  2553. goto out;
  2555. karg.list[i].address = (void *) A(tmp1);
  2556. }
  2558. old_fs = get_fs();
  2559. set_fs(KERNEL_DS);
  2560. ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
  2561. set_fs(old_fs);
  2563. if (!ret) {
  2564. for (i = 0; i < orig_count; i++) {
  2565. tmp1 = (u32) (long) karg.list[i].address;
  2566. if (put_user(karg.list[i].idx, &ulist[i].idx) ||
  2567.     put_user(karg.list[i].total, &ulist[i].total) ||
  2568.     put_user(karg.list[i].used, &ulist[i].used) ||
  2569.     put_user(tmp1, &ulist[i].address)) {
  2570. ret = -EFAULT;
  2571. goto out;
  2572. }
  2573. }
  2574. if (put_user(karg.count, &uarg->count))
  2575. ret = -EFAULT;
  2576. }
  2578. out:
  2579. kfree(karg.list);
  2580. return ret;
  2581. }
  2583. typedef struct drm32_dma {
  2584. /* Indices here refer to the offset into
  2585.    buflist in drm_buf_get_t.  */
  2586. int context;   /* Context handle     */
  2587. int send_count;   /* Number of buffers to send     */
  2588. u32 send_indices;   /* List of handles to buffers (int *) */
  2589. u32 send_sizes;   /* Lengths of data to send (int *) */
  2590. drm_dma_flags_t flags;   /* Flags     */
  2591. int request_count;   /* Number of buffers requested    */
  2592. int request_size;   /* Desired size for buffers     */
  2593. u32 request_indices;  /* Buffer information (int *)     */
  2594. u32 request_sizes;    /* (int *) */
  2595. int granted_count;   /* Number of buffers granted     */
  2596. } drm32_dma_t;
  2597. #define DRM32_IOCTL_DMA      DRM_IOWR(0x29, drm32_dma_t)
  2599. /* RED PEN The DRM layer blindly dereferences the send/request
  2600.  *  indice/size arrays even though they are userland
  2601.  *  pointers.  -DaveM
  2602.  */
  2603. static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
  2604. {
  2605. drm32_dma_t *uarg = (drm32_dma_t *) arg;
  2606. int *u_si, *u_ss, *u_ri, *u_rs;
  2607. drm_dma_t karg;
  2608. mm_segment_t old_fs;
  2609. int ret;
  2610. u32 tmp1, tmp2, tmp3, tmp4;
  2612. karg.send_indices = karg.send_sizes = NULL;
  2613. karg.request_indices = karg.request_sizes = NULL;
  2615. if (get_user(karg.context, &uarg->context) ||
  2616.     get_user(karg.send_count, &uarg->send_count) ||
  2617.     get_user(tmp1, &uarg->send_indices) ||
  2618.     get_user(tmp2, &uarg->send_sizes) ||
  2619.     get_user(karg.flags, &uarg->flags) ||
  2620.     get_user(karg.request_count, &uarg->request_count) ||
  2621.     get_user(karg.request_size, &uarg->request_size) ||
  2622.     get_user(tmp3, &uarg->request_indices) ||
  2623.     get_user(tmp4, &uarg->request_sizes) ||
  2624.     get_user(karg.granted_count, &uarg->granted_count))
  2625. return -EFAULT;
  2627. u_si = (int *) A(tmp1);
  2628. u_ss = (int *) A(tmp2);
  2629. u_ri = (int *) A(tmp3);
  2630. u_rs = (int *) A(tmp4);
  2632. if (karg.send_count) {
  2633. karg.send_indices = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
  2634. karg.send_sizes = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
  2636. ret = -ENOMEM;
  2637. if (!karg.send_indices || !karg.send_sizes)
  2638. goto out;
  2640. ret = -EFAULT;
  2641. if (copy_from_user(karg.send_indices, u_si,
  2642.    (karg.send_count * sizeof(int))) ||
  2643.     copy_from_user(karg.send_sizes, u_ss,
  2644.    (karg.send_count * sizeof(int))))
  2645. goto out;
  2646. }
  2648. if (karg.request_count) {
  2649. karg.request_indices = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
  2650. karg.request_sizes = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
  2652. ret = -ENOMEM;
  2653. if (!karg.request_indices || !karg.request_sizes)
  2654. goto out;
  2656. ret = -EFAULT;
  2657. if (copy_from_user(karg.request_indices, u_ri,
  2658.    (karg.request_count * sizeof(int))) ||
  2659.     copy_from_user(karg.request_sizes, u_rs,
  2660.    (karg.request_count * sizeof(int))))
  2661. goto out;
  2662. }
  2664. old_fs = get_fs();
  2665. set_fs(KERNEL_DS);
  2666. ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
  2667. set_fs(old_fs);
  2669. if (!ret) {
  2670. if (put_user(karg.context, &uarg->context) ||
  2671.     put_user(karg.send_count, &uarg->send_count) ||
  2672.     put_user(karg.flags, &uarg->flags) ||
  2673.     put_user(karg.request_count, &uarg->request_count) ||
  2674.     put_user(karg.request_size, &uarg->request_size) ||
  2675.     put_user(karg.granted_count, &uarg->granted_count))
  2676. ret = -EFAULT;
  2678. if (karg.send_count) {
  2679. if (copy_to_user(u_si, karg.send_indices,
  2680.  (karg.send_count * sizeof(int))) ||
  2681.     copy_to_user(u_ss, karg.send_sizes,
  2682.  (karg.send_count * sizeof(int))))
  2683. ret = -EFAULT;
  2684. }
  2685. if (karg.request_count) {
  2686. if (copy_to_user(u_ri, karg.request_indices,
  2687.  (karg.request_count * sizeof(int))) ||
  2688.     copy_to_user(u_rs, karg.request_sizes,
  2689.  (karg.request_count * sizeof(int))))
  2690. ret = -EFAULT;
  2691. }
  2692. }
  2694. out:
  2695. if (karg.send_indices)
  2696. kfree(karg.send_indices);
  2697. if (karg.send_sizes)
  2698. kfree(karg.send_sizes);
  2699. if (karg.request_indices)
  2700. kfree(karg.request_indices);
  2701. if (karg.request_sizes)
  2702. kfree(karg.request_sizes);
  2704. return ret;
  2705. }
  2707. typedef struct drm32_ctx_res {
  2708. int count;
  2709. u32 contexts; /* (drm_ctx_t *) */
  2710. } drm32_ctx_res_t;
  2711. #define DRM32_IOCTL_RES_CTX    DRM_IOWR(0x26, drm32_ctx_res_t)
  2713. static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
  2714. {
  2715. drm32_ctx_res_t *uarg = (drm32_ctx_res_t *) arg;
  2716. drm_ctx_t *ulist;
  2717. drm_ctx_res_t karg;
  2718. mm_segment_t old_fs;
  2719. int orig_count, ret;
  2720. u32 tmp;
  2722. karg.contexts = NULL;
  2723. if (get_user(karg.count, &uarg->count) ||
  2724.     get_user(tmp, &uarg->contexts))
  2725. return -EFAULT;
  2727. ulist = (drm_ctx_t *) A(tmp);
  2729. orig_count = karg.count;
  2730. if (karg.count && ulist) {
  2731. karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
  2732. if (!karg.contexts)
  2733. return -ENOMEM;
  2734. if (copy_from_user(karg.contexts, ulist,
  2735.    (karg.count * sizeof(drm_ctx_t)))) {
  2736. kfree(karg.contexts);
  2737. return -EFAULT;
  2738. }
  2739. }
  2741. old_fs = get_fs();
  2742. set_fs(KERNEL_DS);
  2743. ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
  2744. set_fs(old_fs);
  2746. if (!ret) {
  2747. if (orig_count) {
  2748. if (copy_to_user(ulist, karg.contexts,
  2749.  (orig_count * sizeof(drm_ctx_t))))
  2750. ret = -EFAULT;
  2751. }
  2752. if (put_user(karg.count, &uarg->count))
  2753. ret = -EFAULT;
  2754. }
  2756. if (karg.contexts)
  2757. kfree(karg.contexts);
  2759. return ret;
  2760. }
  2762. #endif
  2764. static int ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
  2765. {
  2766. return -EINVAL;
  2767. }
  2769. static int broken_blkgetsize(unsigned int fd, unsigned int cmd, unsigned long arg)
  2770. {
  2771. /* The mkswap binary hard codes it to Intel value :-((( */
  2772. return w_long(fd, BLKGETSIZE, arg);
  2773. }
  2775. struct blkpg_ioctl_arg32 {
  2776. int op;
  2777. int flags;
  2778. int datalen;
  2779. u32 data;
  2780. };
  2781.                                 
  2782. static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd, struct blkpg_ioctl_arg32 *arg)
  2783. {
  2784. struct blkpg_ioctl_arg a;
  2785. struct blkpg_partition p;
  2786. int err;
  2787. mm_segment_t old_fs = get_fs();
  2789. err = get_user(a.op, &arg->op);
  2790. err |= __get_user(a.flags, &arg->flags);
  2791. err |= __get_user(a.datalen, &arg->datalen);
  2792. err |= __get_user((long)a.data, &arg->data);
  2793. if (err) return err;
  2794. switch (a.op) {
  2795. case BLKPG_ADD_PARTITION:
  2796. case BLKPG_DEL_PARTITION:
  2797. if (a.datalen < sizeof(struct blkpg_partition))
  2798. return -EINVAL;
  2799.                 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
  2800. return -EFAULT;
  2801. a.data = &p;
  2802. set_fs (KERNEL_DS);
  2803. err = sys_ioctl(fd, cmd, (unsigned long)&a);
  2804. set_fs (old_fs);
  2805. default:
  2806. return -EINVAL;
  2807. }                                        
  2808. return err;
  2809. }
  2811. static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
  2812. {
  2813. return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
  2814. }
  2817. struct serial_struct32 {
  2818. int type;
  2819. int line;
  2820. unsigned int port;
  2821. int irq;
  2822. int flags;
  2823. int xmit_fifo_size;
  2824. int custom_divisor;
  2825. int baud_base;
  2826. unsigned short close_delay;
  2827. char io_type;
  2828. char reserved_char[1];
  2829. int hub6;
  2830. unsigned short closing_wait; /* time to wait before closing */
  2831. unsigned short closing_wait2; /* no longer used... */
  2832. unsigned int iomem_base; /* char * really */
  2833. unsigned short iomem_reg_shift;
  2834. unsigned int port_high;
  2835. int reserved[1];
  2836. };
  2838. static int do_tiocgserial(unsigned int fd, unsigned int cmd, unsigned long arg)
  2839. {
  2840. struct serial_struct ss;
  2841. int ret;
  2842. struct serial_struct32 * uptr = (struct serial_struct32 *)arg;
  2843. mm_segment_t old_fs = get_fs();
  2845. set_fs (KERNEL_DS);
  2846. ret = sys_ioctl(fd, cmd, (unsigned long) &ss);
  2847. set_fs(old_fs);
  2849. if (!ret) {
  2850. /* structs match up to iomem_base */
  2851. ret = copy_to_user(uptr, &ss, sizeof(struct serial_struct32));
  2852. ret |= put_user(ss.iomem_base, &uptr->iomem_base);
  2853. ret |= put_user(ss.iomem_reg_shift, &uptr->iomem_reg_shift);
  2854. ret |= put_user(ss.port_high, &uptr->port_high);
  2855. if (ret)
  2856. ret = -EFAULT;
  2857. }
  2858. return ret;
  2859. }
  2862. struct ioctl_trans {
  2863. unsigned long handler;
  2864. unsigned int cmd;
  2865. unsigned int next;
  2866. };
  2867. #define HANDLE_IOCTL(cmd, handler) asm volatile(".dword %1n.word %0, 0" : : "i" (cmd), "i" (handler));
  2869. #define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd, sys_ioctl) 
  2872. #define IOCTL_TABLE_START void ioctl32_foo(void) { asm volatile(".datanioctl_translations:");
  2873. #define IOCTL_TABLE_END asm volatile("nioctl_translations_end:nt.previous"); }
  2875. IOCTL_TABLE_START
  2876. /* List here exlicitly which ioctl's are known to have
  2877.  * compatable types passed or none at all...
  2878.  */
  2879. /* Big T */
  2880. COMPATIBLE_IOCTL(TCGETA)
  2881. COMPATIBLE_IOCTL(TCSETA)
  2882. COMPATIBLE_IOCTL(TCSETAW)
  2883. COMPATIBLE_IOCTL(TCSETAF)
  2884. COMPATIBLE_IOCTL(TCSBRK)
  2885. COMPATIBLE_IOCTL(TCXONC)
  2886. COMPATIBLE_IOCTL(TCFLSH)
  2887. COMPATIBLE_IOCTL(TCGETS)
  2888. COMPATIBLE_IOCTL(TCSETS)
  2889. COMPATIBLE_IOCTL(TCSETSW)
  2890. COMPATIBLE_IOCTL(TCSETSF)
  2891. COMPATIBLE_IOCTL(TIOCLINUX)
  2892. /* Little t */
  2893. COMPATIBLE_IOCTL(TIOCGETD)
  2894. COMPATIBLE_IOCTL(TIOCSETD)
  2895. COMPATIBLE_IOCTL(TIOCEXCL)
  2896. COMPATIBLE_IOCTL(TIOCNXCL)
  2897. COMPATIBLE_IOCTL(TIOCCONS)
  2898. COMPATIBLE_IOCTL(TIOCGSOFTCAR)
  2899. COMPATIBLE_IOCTL(TIOCSSOFTCAR)
  2900. COMPATIBLE_IOCTL(TIOCSWINSZ)
  2901. COMPATIBLE_IOCTL(TIOCGWINSZ)
  2902. COMPATIBLE_IOCTL(TIOCMGET)
  2903. COMPATIBLE_IOCTL(TIOCMBIC)
  2904. COMPATIBLE_IOCTL(TIOCMBIS)
  2905. COMPATIBLE_IOCTL(TIOCMSET)
  2906. COMPATIBLE_IOCTL(TIOCPKT)
  2907. COMPATIBLE_IOCTL(TIOCNOTTY)
  2908. COMPATIBLE_IOCTL(TIOCSTI)
  2909. COMPATIBLE_IOCTL(TIOCOUTQ)
  2910. COMPATIBLE_IOCTL(TIOCSPGRP)
  2911. COMPATIBLE_IOCTL(TIOCGPGRP)
  2912. COMPATIBLE_IOCTL(TIOCSCTTY)
  2913. COMPATIBLE_IOCTL(TIOCGPTN)
  2914. COMPATIBLE_IOCTL(TIOCSPTLCK)
  2915. COMPATIBLE_IOCTL(TIOCSSERIAL)
  2916. COMPATIBLE_IOCTL(TIOCSERGETLSR)
  2917. /* Big F */
  2918. #if 0
  2919. COMPATIBLE_IOCTL(FBIOGTYPE)
  2920. COMPATIBLE_IOCTL(FBIOSATTR)
  2921. COMPATIBLE_IOCTL(FBIOGATTR)
  2922. COMPATIBLE_IOCTL(FBIOSVIDEO)
  2923. COMPATIBLE_IOCTL(FBIOGVIDEO)
  2924. COMPATIBLE_IOCTL(FBIOGCURSOR32)  /* This is not implemented yet. Later it should be converted... */
  2925. COMPATIBLE_IOCTL(FBIOSCURPOS)
  2926. COMPATIBLE_IOCTL(FBIOGCURPOS)
  2927. COMPATIBLE_IOCTL(FBIOGCURMAX)
  2928. #endif
  2929. COMPATIBLE_IOCTL(FBIOGET_VSCREENINFO)
  2930. COMPATIBLE_IOCTL(FBIOPUT_VSCREENINFO)
  2932. COMPATIBLE_IOCTL(FBIOPAN_DISPLAY)
  2933. COMPATIBLE_IOCTL(FBIOGET_FCURSORINFO)
  2934. COMPATIBLE_IOCTL(FBIOGET_VCURSORINFO)
  2935. COMPATIBLE_IOCTL(FBIOPUT_VCURSORINFO)
  2936. COMPATIBLE_IOCTL(FBIOGET_CURSORSTATE)
  2937. COMPATIBLE_IOCTL(FBIOPUT_CURSORSTATE)
  2938. COMPATIBLE_IOCTL(FBIOGET_CON2FBMAP)
  2939. COMPATIBLE_IOCTL(FBIOPUT_CON2FBMAP)
  2940. /* Little f */
  2941. COMPATIBLE_IOCTL(FIOCLEX)
  2942. COMPATIBLE_IOCTL(FIONCLEX)
  2943. COMPATIBLE_IOCTL(FIOASYNC)
  2944. COMPATIBLE_IOCTL(FIONBIO)
  2945. COMPATIBLE_IOCTL(FIONREAD)  /* This is also TIOCINQ */
  2946. /* 0x00 */
  2947. COMPATIBLE_IOCTL(FIBMAP)
  2948. COMPATIBLE_IOCTL(FIGETBSZ)
  2949. /* 0x03 -- HD/IDE ioctl's used by hdparm and friends.
  2950.  *         Some need translations, these do not.
  2951.  */
  2952. COMPATIBLE_IOCTL(HDIO_GET_IDENTITY)
  2953. COMPATIBLE_IOCTL(HDIO_SET_DMA)
  2954. COMPATIBLE_IOCTL(HDIO_SET_KEEPSETTINGS)
  2955. COMPATIBLE_IOCTL(HDIO_SET_UNMASKINTR)
  2956. COMPATIBLE_IOCTL(HDIO_SET_NOWERR)
  2957. COMPATIBLE_IOCTL(HDIO_SET_32BIT)
  2958. COMPATIBLE_IOCTL(HDIO_SET_MULTCOUNT)
  2959. COMPATIBLE_IOCTL(HDIO_DRIVE_CMD)
  2960. COMPATIBLE_IOCTL(HDIO_SET_PIO_MODE)
  2961. COMPATIBLE_IOCTL(HDIO_SCAN_HWIF)
  2962. COMPATIBLE_IOCTL(HDIO_SET_NICE)
  2963. /* 0x02 -- Floppy ioctls */
  2964. COMPATIBLE_IOCTL(FDMSGON)
  2965. COMPATIBLE_IOCTL(FDMSGOFF)
  2966. COMPATIBLE_IOCTL(FDSETEMSGTRESH)
  2967. COMPATIBLE_IOCTL(FDFLUSH)
  2968. COMPATIBLE_IOCTL(FDWERRORCLR)
  2969. COMPATIBLE_IOCTL(FDSETMAXERRS)
  2970. COMPATIBLE_IOCTL(FDGETMAXERRS)
  2971. COMPATIBLE_IOCTL(FDGETDRVTYP)
  2972. COMPATIBLE_IOCTL(FDEJECT)
  2973. COMPATIBLE_IOCTL(FDCLRPRM)
  2974. COMPATIBLE_IOCTL(FDFMTBEG)
  2975. COMPATIBLE_IOCTL(FDFMTEND)
  2976. COMPATIBLE_IOCTL(FDRESET)
  2977. COMPATIBLE_IOCTL(FDTWADDLE)
  2978. COMPATIBLE_IOCTL(FDFMTTRK)
  2979. COMPATIBLE_IOCTL(FDRAWCMD)
  2980. /* 0x12 */
  2981. COMPATIBLE_IOCTL(BLKROSET)
  2982. COMPATIBLE_IOCTL(BLKROGET)
  2983. COMPATIBLE_IOCTL(BLKRRPART)
  2984. COMPATIBLE_IOCTL(BLKFLSBUF)
  2985. COMPATIBLE_IOCTL(BLKRASET)
  2986. COMPATIBLE_IOCTL(BLKFRASET)
  2987. COMPATIBLE_IOCTL(BLKSECTSET)
  2988. COMPATIBLE_IOCTL(BLKSSZGET)
  2990. /* RAID */
  2991. COMPATIBLE_IOCTL(RAID_VERSION)
  2992. COMPATIBLE_IOCTL(GET_ARRAY_INFO)
  2993. COMPATIBLE_IOCTL(GET_DISK_INFO)
  2994. COMPATIBLE_IOCTL(PRINT_RAID_DEBUG)
  2995. COMPATIBLE_IOCTL(CLEAR_ARRAY)
  2996. COMPATIBLE_IOCTL(ADD_NEW_DISK)
  2997. COMPATIBLE_IOCTL(HOT_REMOVE_DISK)
  2998. COMPATIBLE_IOCTL(SET_ARRAY_INFO)
  2999. COMPATIBLE_IOCTL(SET_DISK_INFO)
  3000. COMPATIBLE_IOCTL(WRITE_RAID_INFO)
  3001. COMPATIBLE_IOCTL(UNPROTECT_ARRAY)
  3002. COMPATIBLE_IOCTL(PROTECT_ARRAY)
  3003. COMPATIBLE_IOCTL(HOT_ADD_DISK)
  3004. COMPATIBLE_IOCTL(SET_DISK_FAULTY)
  3005. COMPATIBLE_IOCTL(RUN_ARRAY)
  3006. COMPATIBLE_IOCTL(START_ARRAY)
  3007. COMPATIBLE_IOCTL(STOP_ARRAY)
  3008. COMPATIBLE_IOCTL(STOP_ARRAY_RO)
  3009. COMPATIBLE_IOCTL(RESTART_ARRAY_RW)
  3011. /* Big K */
  3012. COMPATIBLE_IOCTL(PIO_FONT)
  3013. COMPATIBLE_IOCTL(GIO_FONT)
  3014. COMPATIBLE_IOCTL(KDSIGACCEPT)
  3015. COMPATIBLE_IOCTL(KDGETKEYCODE)
  3016. COMPATIBLE_IOCTL(KDSETKEYCODE)
  3017. COMPATIBLE_IOCTL(KIOCSOUND)
  3018. COMPATIBLE_IOCTL(KDMKTONE)
  3019. COMPATIBLE_IOCTL(KDGKBTYPE)
  3020. COMPATIBLE_IOCTL(KDSETMODE)
  3021. COMPATIBLE_IOCTL(KDGETMODE)
  3022. COMPATIBLE_IOCTL(KDSKBMODE)
  3023. COMPATIBLE_IOCTL(KDGKBMODE)
  3024. COMPATIBLE_IOCTL(KDSKBMETA)
  3025. COMPATIBLE_IOCTL(KDGKBMETA)
  3026. COMPATIBLE_IOCTL(KDGKBENT)
  3027. COMPATIBLE_IOCTL(KDSKBENT)
  3028. COMPATIBLE_IOCTL(KDGKBSENT)
  3029. COMPATIBLE_IOCTL(KDSKBSENT)
  3030. COMPATIBLE_IOCTL(KDGKBDIACR)
  3031. COMPATIBLE_IOCTL(KDSKBDIACR)
  3032. COMPATIBLE_IOCTL(KDGKBLED)
  3033. COMPATIBLE_IOCTL(KDSKBLED)
  3034. COMPATIBLE_IOCTL(KDGETLED)
  3035. COMPATIBLE_IOCTL(KDSETLED)
  3036. COMPATIBLE_IOCTL(GIO_SCRNMAP)
  3037. COMPATIBLE_IOCTL(PIO_SCRNMAP)
  3038. COMPATIBLE_IOCTL(GIO_UNISCRNMAP)
  3039. COMPATIBLE_IOCTL(PIO_UNISCRNMAP)
  3040. COMPATIBLE_IOCTL(PIO_FONTRESET)
  3041. COMPATIBLE_IOCTL(PIO_UNIMAPCLR)
  3042. /* Little k */
  3043. #if 0
  3044. COMPATIBLE_IOCTL(KIOCTYPE)
  3045. COMPATIBLE_IOCTL(KIOCLAYOUT)
  3046. COMPATIBLE_IOCTL(KIOCGTRANS)
  3047. COMPATIBLE_IOCTL(KIOCTRANS)
  3048. COMPATIBLE_IOCTL(KIOCCMD)
  3049. COMPATIBLE_IOCTL(KIOCSDIRECT)
  3050. COMPATIBLE_IOCTL(KIOCSLED)
  3051. COMPATIBLE_IOCTL(KIOCGLED)
  3052. COMPATIBLE_IOCTL(KIOCSRATE)
  3053. COMPATIBLE_IOCTL(KIOCGRATE)
  3054. #endif
  3055. /* Big S */
  3056. COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN)
  3057. COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK)
  3058. COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK)
  3059. COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY)
  3060. COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_ENABLE)
  3061. COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_DISABLE)
  3062. COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER)
  3063. COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND)
  3064. /* Big V */
  3065. COMPATIBLE_IOCTL(VT_SETMODE)
  3066. COMPATIBLE_IOCTL(VT_GETMODE)
  3067. COMPATIBLE_IOCTL(VT_GETSTATE)
  3068. COMPATIBLE_IOCTL(VT_OPENQRY)
  3069. COMPATIBLE_IOCTL(VT_ACTIVATE)
  3070. COMPATIBLE_IOCTL(VT_WAITACTIVE)
  3071. COMPATIBLE_IOCTL(VT_RELDISP)
  3072. COMPATIBLE_IOCTL(VT_DISALLOCATE)
  3073. COMPATIBLE_IOCTL(VT_RESIZE)
  3074. COMPATIBLE_IOCTL(VT_RESIZEX)
  3075. COMPATIBLE_IOCTL(VT_LOCKSWITCH)
  3076. COMPATIBLE_IOCTL(VT_UNLOCKSWITCH)
  3077. /* Little v, the video4linux ioctls */
  3078. COMPATIBLE_IOCTL(VIDIOCGCAP)
  3079. COMPATIBLE_IOCTL(VIDIOCGCHAN)
  3080. COMPATIBLE_IOCTL(VIDIOCSCHAN)
  3081. COMPATIBLE_IOCTL(VIDIOCGPICT)
  3082. COMPATIBLE_IOCTL(VIDIOCSPICT)
  3083. COMPATIBLE_IOCTL(VIDIOCCAPTURE)
  3084. COMPATIBLE_IOCTL(VIDIOCKEY)
  3085. COMPATIBLE_IOCTL(VIDIOCGAUDIO)
  3086. COMPATIBLE_IOCTL(VIDIOCSAUDIO)
  3087. COMPATIBLE_IOCTL(VIDIOCSYNC)
  3088. COMPATIBLE_IOCTL(VIDIOCMCAPTURE)
  3089. COMPATIBLE_IOCTL(VIDIOCGMBUF)
  3090. COMPATIBLE_IOCTL(VIDIOCGUNIT)
  3091. COMPATIBLE_IOCTL(VIDIOCGCAPTURE)
  3092. COMPATIBLE_IOCTL(VIDIOCSCAPTURE)
  3093. /* BTTV specific... */
  3094. COMPATIBLE_IOCTL(_IOW('v',  BASE_VIDIOCPRIVATE+0, char [256]))
  3095. COMPATIBLE_IOCTL(_IOR('v',  BASE_VIDIOCPRIVATE+1, char [256]))
  3096. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int))
  3097. COMPATIBLE_IOCTL(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16])) /* struct bttv_pll_info */
  3098. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+4, int))
  3099. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+5, int))
  3100. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+6, int))
  3101. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+7, int))
  3102. /* Little m */
  3103. COMPATIBLE_IOCTL(MTIOCTOP)
  3104. /* Socket level stuff */
  3105. COMPATIBLE_IOCTL(FIOSETOWN)
  3106. COMPATIBLE_IOCTL(SIOCSPGRP)
  3107. COMPATIBLE_IOCTL(FIOGETOWN)
  3108. COMPATIBLE_IOCTL(SIOCGPGRP)
  3109. COMPATIBLE_IOCTL(SIOCATMARK)
  3110. COMPATIBLE_IOCTL(SIOCSIFLINK)
  3111. COMPATIBLE_IOCTL(SIOCSIFENCAP)
  3112. COMPATIBLE_IOCTL(SIOCGIFENCAP)
  3113. COMPATIBLE_IOCTL(SIOCSIFBR)
  3114. COMPATIBLE_IOCTL(SIOCGIFBR)
  3115. COMPATIBLE_IOCTL(SIOCSARP)
  3116. COMPATIBLE_IOCTL(SIOCGARP)
  3117. COMPATIBLE_IOCTL(SIOCDARP)
  3118. COMPATIBLE_IOCTL(SIOCSRARP)
  3119. COMPATIBLE_IOCTL(SIOCGRARP)
  3120. COMPATIBLE_IOCTL(SIOCDRARP)
  3121. COMPATIBLE_IOCTL(SIOCADDDLCI)
  3122. COMPATIBLE_IOCTL(SIOCDELDLCI)
  3123. /* SG stuff */
  3124. COMPATIBLE_IOCTL(SG_SET_TIMEOUT)
  3125. COMPATIBLE_IOCTL(SG_GET_TIMEOUT)
  3126. COMPATIBLE_IOCTL(SG_EMULATED_HOST)
  3127. COMPATIBLE_IOCTL(SG_SET_TRANSFORM)
  3128. COMPATIBLE_IOCTL(SG_GET_TRANSFORM)
  3129. COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE)
  3130. COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE)
  3131. COMPATIBLE_IOCTL(SG_GET_SCSI_ID)
  3132. COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA)
  3133. COMPATIBLE_IOCTL(SG_GET_LOW_DMA)
  3134. COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID)
  3135. COMPATIBLE_IOCTL(SG_GET_PACK_ID)
  3136. COMPATIBLE_IOCTL(SG_GET_NUM_WAITING)
  3137. COMPATIBLE_IOCTL(SG_SET_DEBUG)
  3138. COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE)
  3139. COMPATIBLE_IOCTL(SG_GET_COMMAND_Q)
  3140. COMPATIBLE_IOCTL(SG_SET_COMMAND_Q)
  3141. COMPATIBLE_IOCTL(SG_GET_VERSION_NUM)
  3142. COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN)
  3143. COMPATIBLE_IOCTL(SG_SCSI_RESET)
  3144. COMPATIBLE_IOCTL(SG_IO)
  3145. COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE)
  3146. COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN)
  3147. COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN)
  3148. /* PPP stuff */
  3149. COMPATIBLE_IOCTL(PPPIOCGFLAGS)
  3150. COMPATIBLE_IOCTL(PPPIOCSFLAGS)
  3151. COMPATIBLE_IOCTL(PPPIOCGASYNCMAP)
  3152. COMPATIBLE_IOCTL(PPPIOCSASYNCMAP)
  3153. COMPATIBLE_IOCTL(PPPIOCGUNIT)
  3154. COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP)
  3155. COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP)
  3156. COMPATIBLE_IOCTL(PPPIOCGMRU)
  3157. COMPATIBLE_IOCTL(PPPIOCSMRU)
  3158. COMPATIBLE_IOCTL(PPPIOCSMAXCID)
  3159. COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP)
  3160. COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP)
  3161. COMPATIBLE_IOCTL(PPPIOCXFERUNIT)
  3162. COMPATIBLE_IOCTL(PPPIOCGNPMODE)
  3163. COMPATIBLE_IOCTL(PPPIOCSNPMODE)
  3164. COMPATIBLE_IOCTL(PPPIOCGDEBUG)
  3165. COMPATIBLE_IOCTL(PPPIOCSDEBUG)
  3166. COMPATIBLE_IOCTL(PPPIOCNEWUNIT)
  3167. COMPATIBLE_IOCTL(PPPIOCATTACH)
  3168. COMPATIBLE_IOCTL(PPPIOCDETACH)
  3169. COMPATIBLE_IOCTL(PPPIOCSMRRU)
  3170. COMPATIBLE_IOCTL(PPPIOCCONNECT)
  3171. COMPATIBLE_IOCTL(PPPIOCDISCONN)
  3172. COMPATIBLE_IOCTL(PPPIOCATTCHAN)
  3173. /* PPPOX */
  3174. COMPATIBLE_IOCTL(PPPOEIOCSFWD);
  3175. COMPATIBLE_IOCTL(PPPOEIOCDFWD);
  3176. /* CDROM stuff */
  3177. COMPATIBLE_IOCTL(CDROMPAUSE)
  3178. COMPATIBLE_IOCTL(CDROMRESUME)
  3179. COMPATIBLE_IOCTL(CDROMPLAYMSF)
  3180. COMPATIBLE_IOCTL(CDROMPLAYTRKIND)
  3181. COMPATIBLE_IOCTL(CDROMREADTOCHDR)
  3182. COMPATIBLE_IOCTL(CDROMREADTOCENTRY)
  3183. COMPATIBLE_IOCTL(CDROMSTOP)
  3184. COMPATIBLE_IOCTL(CDROMSTART)
  3185. COMPATIBLE_IOCTL(CDROMEJECT)
  3186. COMPATIBLE_IOCTL(CDROMVOLCTRL)
  3187. COMPATIBLE_IOCTL(CDROMSUBCHNL)
  3188. COMPATIBLE_IOCTL(CDROMEJECT_SW)
  3189. COMPATIBLE_IOCTL(CDROMMULTISESSION)
  3190. COMPATIBLE_IOCTL(CDROM_GET_MCN)
  3191. COMPATIBLE_IOCTL(CDROMRESET)
  3192. COMPATIBLE_IOCTL(CDROMVOLREAD)
  3193. COMPATIBLE_IOCTL(CDROMSEEK)
  3194. COMPATIBLE_IOCTL(CDROMPLAYBLK)
  3195. COMPATIBLE_IOCTL(CDROMCLOSETRAY)
  3196. COMPATIBLE_IOCTL(CDROM_SET_OPTIONS)
  3197. COMPATIBLE_IOCTL(CDROM_CLEAR_OPTIONS)
  3198. COMPATIBLE_IOCTL(CDROM_SELECT_SPEED)
  3199. COMPATIBLE_IOCTL(CDROM_SELECT_DISC)
  3200. COMPATIBLE_IOCTL(CDROM_MEDIA_CHANGED)
  3201. COMPATIBLE_IOCTL(CDROM_DRIVE_STATUS)
  3202. COMPATIBLE_IOCTL(CDROM_DISC_STATUS)
  3203. COMPATIBLE_IOCTL(CDROM_CHANGER_NSLOTS)
  3204. COMPATIBLE_IOCTL(CDROM_LOCKDOOR)
  3205. COMPATIBLE_IOCTL(CDROM_DEBUG)
  3206. COMPATIBLE_IOCTL(CDROM_GET_CAPABILITY)
  3207. /* Big L */
  3208. COMPATIBLE_IOCTL(LOOP_SET_FD)
  3209. COMPATIBLE_IOCTL(LOOP_CLR_FD)
  3210. /* Big Q for sound/OSS */
  3211. COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET)
  3212. COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC)
  3213. COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO)
  3214. COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE)
  3215. COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT)
  3216. COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT)
  3217. COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE)
  3218. COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR)
  3219. COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI)
  3220. COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES)
  3221. COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS)
  3222. COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS)
  3223. COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO)
  3224. COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD)
  3225. COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL)
  3226. COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE)
  3227. COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC)
  3228. COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND)
  3229. COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME)
  3230. COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID)
  3231. COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL)
  3232. COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE)
  3233. /* Big T for sound/OSS */
  3234. COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE)
  3235. COMPATIBLE_IOCTL(SNDCTL_TMR_START)
  3236. COMPATIBLE_IOCTL(SNDCTL_TMR_STOP)
  3237. COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE)
  3238. COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO)
  3239. COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE)
  3240. COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME)
  3241. COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT)
  3242. /* Little m for sound/OSS */
  3243. COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME)
  3244. COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE)
  3245. COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD)
  3246. /* Big P for sound/OSS */
  3247. COMPATIBLE_IOCTL(SNDCTL_DSP_RESET)
  3248. COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC)
  3249. COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED)
  3250. COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO)
  3251. COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE)
  3252. COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS)
  3253. COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER)
  3254. COMPATIBLE_IOCTL(SNDCTL_DSP_POST)
  3255. COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE)
  3256. COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT)
  3257. COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS)
  3258. COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT)
  3259. COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE)
  3260. COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE)
  3261. COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK)
  3262. COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS)
  3263. COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER)
  3264. COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER)
  3265. COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR)
  3266. COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR)
  3267. /* SNDCTL_DSP_MAPINBUF,  XXX needs translation */
  3268. /* SNDCTL_DSP_MAPOUTBUF,  XXX needs translation */
  3269. COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO)
  3270. COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX)
  3271. COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY)
  3272. COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE)
  3273. COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE)
  3274. COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS)
  3275. COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS)
  3276. COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER)
  3277. /* Big C for sound/OSS */
  3278. COMPATIBLE_IOCTL(SNDCTL_COPR_RESET)
  3279. COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD)
  3280. COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA)
  3281. COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE)
  3282. COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA)
  3283. COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE)
  3284. COMPATIBLE_IOCTL(SNDCTL_COPR_RUN)
  3285. COMPATIBLE_IOCTL(SNDCTL_COPR_HALT)
  3286. COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG)
  3287. COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG)
  3288. /* Big M for sound/OSS */
  3289. COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME)
  3290. COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS)
  3291. COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE)
  3292. COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH)
  3293. COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM)
  3294. COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER)
  3295. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE)
  3296. COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC)
  3297. COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD)
  3298. COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX)
  3299. COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM)
  3300. COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV)
  3301. COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN)
  3302. COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN)
  3303. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1)
  3304. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2)
  3305. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3)
  3306. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1))
  3307. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2))
  3308. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3))
  3309. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN))
  3310. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT))
  3311. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO))
  3312. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO))
  3313. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR))
  3314. COMPATIBLE_IOCTL(SOUND_MIXER_MUTE)
  3315. /* SOUND_MIXER_READ_ENHANCE,  same value as READ_MUTE */
  3316. /* SOUND_MIXER_READ_LOUD,  same value as READ_MUTE */
  3317. COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC)
  3318. COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK)
  3319. COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK)
  3320. COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS)
  3321. COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS)
  3322. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME)
  3323. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS)
  3324. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE)
  3325. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH)
  3326. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM)
  3327. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER)
  3328. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE)
  3329. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC)
  3330. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD)
  3331. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX)
  3332. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM)
  3333. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV)
  3334. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN)
  3335. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN)
  3336. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1)
  3337. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2)
  3338. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3)
  3339. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1))
  3340. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2))
  3341. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3))
  3342. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN))
  3343. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT))
  3344. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO))
  3345. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO))
  3346. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR))
  3347. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE)
  3348. /* SOUND_MIXER_WRITE_ENHANCE,  same value as WRITE_MUTE */
  3349. /* SOUND_MIXER_WRITE_LOUD,  same value as WRITE_MUTE */
  3350. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC)
  3351. COMPATIBLE_IOCTL(SOUND_MIXER_INFO)
  3352. COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO)
  3353. COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS)
  3354. COMPATIBLE_IOCTL(SOUND_MIXER_AGC)
  3355. COMPATIBLE_IOCTL(SOUND_MIXER_3DSE)
  3356. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1)
  3357. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2)
  3358. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3)
  3359. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4)
  3360. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5)
  3361. COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS)
  3362. COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS)
  3363. COMPATIBLE_IOCTL(OSS_GETVERSION)
  3364. /* AUTOFS */
  3365. COMPATIBLE_IOCTL(AUTOFS_IOC_READY)
  3366. COMPATIBLE_IOCTL(AUTOFS_IOC_FAIL)
  3367. COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC)
  3368. COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER)
  3369. COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE)
  3370. /* DEVFS */
  3371. COMPATIBLE_IOCTL(DEVFSDIOC_GET_PROTO_REV)
  3372. COMPATIBLE_IOCTL(DEVFSDIOC_SET_EVENT_MASK)
  3373. COMPATIBLE_IOCTL(DEVFSDIOC_RELEASE_EVENT_QUEUE)
  3374. COMPATIBLE_IOCTL(DEVFSDIOC_SET_DEBUG_MASK)
  3375. /* Raw devices */
  3376. COMPATIBLE_IOCTL(RAW_SETBIND)
  3377. COMPATIBLE_IOCTL(RAW_GETBIND)
  3378. /* SMB ioctls which do not need any translations */
  3379. COMPATIBLE_IOCTL(SMB_IOC_NEWCONN)
  3380. /* Little a */
  3381. COMPATIBLE_IOCTL(ATMSIGD_CTRL)
  3382. COMPATIBLE_IOCTL(ATMARPD_CTRL)
  3383. COMPATIBLE_IOCTL(ATMLEC_CTRL)
  3384. COMPATIBLE_IOCTL(ATMLEC_MCAST)
  3385. COMPATIBLE_IOCTL(ATMLEC_DATA)
  3386. COMPATIBLE_IOCTL(ATM_SETSC)
  3387. COMPATIBLE_IOCTL(SIOCSIFATMTCP)
  3388. COMPATIBLE_IOCTL(SIOCMKCLIP)
  3389. COMPATIBLE_IOCTL(ATMARP_MKIP)
  3390. COMPATIBLE_IOCTL(ATMARP_SETENTRY)
  3391. COMPATIBLE_IOCTL(ATMARP_ENCAP)
  3392. COMPATIBLE_IOCTL(ATMTCP_CREATE)
  3393. COMPATIBLE_IOCTL(ATMTCP_REMOVE)
  3394. COMPATIBLE_IOCTL(ATMMPC_CTRL)
  3395. COMPATIBLE_IOCTL(ATMMPC_DATA)
  3396. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  3397. /* 0xfe - lvm */
  3398. COMPATIBLE_IOCTL(VG_SET_EXTENDABLE)
  3399. COMPATIBLE_IOCTL(VG_STATUS_GET_COUNT)
  3400. COMPATIBLE_IOCTL(VG_STATUS_GET_NAMELIST)
  3401. COMPATIBLE_IOCTL(VG_REMOVE)
  3402. COMPATIBLE_IOCTL(VG_RENAME)
  3403. COMPATIBLE_IOCTL(VG_REDUCE)
  3404. COMPATIBLE_IOCTL(PE_LOCK_UNLOCK)
  3405. COMPATIBLE_IOCTL(PV_FLUSH)
  3406. COMPATIBLE_IOCTL(LVM_LOCK_LVM)
  3407. COMPATIBLE_IOCTL(LVM_GET_IOP_VERSION)
  3408. #ifdef LVM_TOTAL_RESET
  3409. COMPATIBLE_IOCTL(LVM_RESET)
  3410. #endif
  3411. COMPATIBLE_IOCTL(LV_SET_ACCESS)
  3412. COMPATIBLE_IOCTL(LV_SET_STATUS)
  3413. COMPATIBLE_IOCTL(LV_SET_ALLOCATION)
  3414. COMPATIBLE_IOCTL(LE_REMAP)
  3415. COMPATIBLE_IOCTL(LV_BMAP)
  3416. COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)
  3417. #endif /* LVM */
  3418. #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
  3419. COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
  3420. COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)
  3421. COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC)
  3422. COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK)
  3423. COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK)
  3424. COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL)
  3425. COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS)
  3426. COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS)
  3427. COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX)
  3428. COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX)
  3429. COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX)
  3430. COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX)
  3431. COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX)
  3432. COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX)
  3433. COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW)
  3434. COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW)
  3435. COMPATIBLE_IOCTL(DRM_IOCTL_LOCK)
  3436. COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK)
  3437. COMPATIBLE_IOCTL(DRM_IOCTL_FINISH)
  3438. #endif /* DRM */
  3439. /* elevator */
  3440. COMPATIBLE_IOCTL(BLKELVGET)
  3441. COMPATIBLE_IOCTL(BLKELVSET)
  3442. /* And these ioctls need translation */
  3443. HANDLE_IOCTL(TIOCGSERIAL, do_tiocgserial)
  3444. HANDLE_IOCTL(SIOCGIFNAME, dev_ifname32)
  3445. HANDLE_IOCTL(SIOCGIFCONF, dev_ifconf)
  3446. HANDLE_IOCTL(SIOCGIFFLAGS, dev_ifsioc)
  3447. HANDLE_IOCTL(SIOCSIFFLAGS, dev_ifsioc)
  3448. HANDLE_IOCTL(SIOCGIFMETRIC, dev_ifsioc)
  3449. HANDLE_IOCTL(SIOCSIFMETRIC, dev_ifsioc)
  3450. HANDLE_IOCTL(SIOCGIFMTU, dev_ifsioc)
  3451. HANDLE_IOCTL(SIOCSIFMTU, dev_ifsioc)
  3452. HANDLE_IOCTL(SIOCGIFMEM, dev_ifsioc)
  3453. HANDLE_IOCTL(SIOCSIFMEM, dev_ifsioc)
  3454. HANDLE_IOCTL(SIOCGIFHWADDR, dev_ifsioc)
  3455. HANDLE_IOCTL(SIOCSIFHWADDR, dev_ifsioc)
  3456. HANDLE_IOCTL(SIOCADDMULTI, dev_ifsioc)
  3457. HANDLE_IOCTL(SIOCDELMULTI, dev_ifsioc)
  3458. HANDLE_IOCTL(SIOCGIFINDEX, dev_ifsioc)
  3459. HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc)
  3460. HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc)
  3461. HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc)
  3462. HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc)
  3463. HANDLE_IOCTL(SIOCGIFBRDADDR, dev_ifsioc)
  3464. HANDLE_IOCTL(SIOCSIFBRDADDR, dev_ifsioc)
  3465. HANDLE_IOCTL(SIOCGIFDSTADDR, dev_ifsioc)
  3466. HANDLE_IOCTL(SIOCSIFDSTADDR, dev_ifsioc)
  3467. HANDLE_IOCTL(SIOCGIFNETMASK, dev_ifsioc)
  3468. HANDLE_IOCTL(SIOCSIFNETMASK, dev_ifsioc)
  3469. HANDLE_IOCTL(SIOCSIFPFLAGS, dev_ifsioc)
  3470. HANDLE_IOCTL(SIOCGIFPFLAGS, dev_ifsioc)
  3471. HANDLE_IOCTL(SIOCGPPPSTATS, dev_ifsioc)
  3472. HANDLE_IOCTL(SIOCGPPPCSTATS, dev_ifsioc)
  3473. HANDLE_IOCTL(SIOCGPPPVER, dev_ifsioc)
  3474. HANDLE_IOCTL(SIOCGIFTXQLEN, dev_ifsioc)
  3475. HANDLE_IOCTL(SIOCSIFTXQLEN, dev_ifsioc)
  3476. HANDLE_IOCTL(SIOCADDRT, routing_ioctl)
  3477. HANDLE_IOCTL(SIOCDELRT, routing_ioctl)
  3478. /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
  3479. HANDLE_IOCTL(SIOCRTMSG, ret_einval)
  3480. HANDLE_IOCTL(SIOCGSTAMP, do_siocgstamp)
  3481. HANDLE_IOCTL(HDIO_GETGEO, hdio_getgeo)
  3482. HANDLE_IOCTL(BLKRAGET, w_long)
  3483. HANDLE_IOCTL(BLKGETSIZE, w_long)
  3484. HANDLE_IOCTL(0x1260, broken_blkgetsize)
  3485. HANDLE_IOCTL(BLKFRAGET, w_long)
  3486. HANDLE_IOCTL(BLKSECTGET, w_long)
  3487. HANDLE_IOCTL(BLKPG, blkpg_ioctl_trans)
  3489. HANDLE_IOCTL(FBIOGET_FSCREENINFO, fb_ioctl_trans)
  3490. HANDLE_IOCTL(FBIOGETCMAP, fb_ioctl_trans)
  3491. HANDLE_IOCTL(FBIOPUTCMAP, fb_ioctl_trans)
  3493. HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans)
  3494. HANDLE_IOCTL(HDIO_GET_UNMASKINTR, hdio_ioctl_trans)
  3495. HANDLE_IOCTL(HDIO_GET_DMA, hdio_ioctl_trans)
  3496. HANDLE_IOCTL(HDIO_GET_32BIT, hdio_ioctl_trans)
  3497. HANDLE_IOCTL(HDIO_GET_MULTCOUNT, hdio_ioctl_trans)
  3498. HANDLE_IOCTL(HDIO_GET_NOWERR, hdio_ioctl_trans)
  3499. HANDLE_IOCTL(HDIO_GET_NICE, hdio_ioctl_trans)
  3500. HANDLE_IOCTL(FDSETPRM32, fd_ioctl_trans)
  3501. HANDLE_IOCTL(FDDEFPRM32, fd_ioctl_trans)
  3502. HANDLE_IOCTL(FDGETPRM32, fd_ioctl_trans)
  3503. HANDLE_IOCTL(FDSETDRVPRM32, fd_ioctl_trans)
  3504. HANDLE_IOCTL(FDGETDRVPRM32, fd_ioctl_trans)
  3505. HANDLE_IOCTL(FDGETDRVSTAT32, fd_ioctl_trans)
  3506. HANDLE_IOCTL(FDPOLLDRVSTAT32, fd_ioctl_trans)
  3507. HANDLE_IOCTL(FDGETFDCSTAT32, fd_ioctl_trans)
  3508. HANDLE_IOCTL(FDWERRORGET32, fd_ioctl_trans)
  3509. HANDLE_IOCTL(PPPIOCGIDLE32, ppp_ioctl_trans)
  3510. HANDLE_IOCTL(PPPIOCSCOMPRESS32, ppp_ioctl_trans)
  3511. HANDLE_IOCTL(MTIOCGET32, mt_ioctl_trans)
  3512. HANDLE_IOCTL(MTIOCPOS32, mt_ioctl_trans)
  3513. HANDLE_IOCTL(MTIOCGETCONFIG32, mt_ioctl_trans)
  3514. HANDLE_IOCTL(MTIOCSETCONFIG32, mt_ioctl_trans)
  3515. HANDLE_IOCTL(CDROMREADMODE2, cdrom_ioctl_trans)
  3516. HANDLE_IOCTL(CDROMREADMODE1, cdrom_ioctl_trans)
  3517. HANDLE_IOCTL(CDROMREADRAW, cdrom_ioctl_trans)
  3518. HANDLE_IOCTL(CDROMREADCOOKED, cdrom_ioctl_trans)
  3519. HANDLE_IOCTL(CDROMREADAUDIO, cdrom_ioctl_trans)
  3520. HANDLE_IOCTL(CDROMREADALL, cdrom_ioctl_trans)
  3521. HANDLE_IOCTL(CDROM_SEND_PACKET, cdrom_ioctl_trans)
  3522. HANDLE_IOCTL(LOOP_SET_STATUS, loop_status)
  3523. HANDLE_IOCTL(LOOP_GET_STATUS, loop_status)
  3524. #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
  3525. HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout)
  3526. #ifdef CONFIG_VT
  3527. HANDLE_IOCTL(PIO_FONTX, do_fontx_ioctl)
  3528. HANDLE_IOCTL(GIO_FONTX, do_fontx_ioctl)
  3529. HANDLE_IOCTL(PIO_UNIMAP, do_unimap_ioctl)
  3530. HANDLE_IOCTL(GIO_UNIMAP, do_unimap_ioctl)
  3531. HANDLE_IOCTL(KDFONTOP, do_kdfontop_ioctl)
  3532. #endif
  3533. HANDLE_IOCTL(EXT2_IOC32_GETFLAGS, do_ext2_ioctl)
  3534. HANDLE_IOCTL(EXT2_IOC32_SETFLAGS, do_ext2_ioctl)
  3535. HANDLE_IOCTL(EXT2_IOC32_GETVERSION, do_ext2_ioctl)
  3536. HANDLE_IOCTL(EXT2_IOC32_SETVERSION, do_ext2_ioctl)
  3537. #if 0
  3538. /* One SMB ioctl needs translations. */
  3539. #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, __kernel_uid_t32)
  3540. HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid)
  3541. #endif
  3542. HANDLE_IOCTL(ATM_GETLINKRATE32, do_atm_ioctl)
  3543. HANDLE_IOCTL(ATM_GETNAMES32, do_atm_ioctl)
  3544. HANDLE_IOCTL(ATM_GETTYPE32, do_atm_ioctl)
  3545. HANDLE_IOCTL(ATM_GETESI32, do_atm_ioctl)
  3546. HANDLE_IOCTL(ATM_GETADDR32, do_atm_ioctl)
  3547. HANDLE_IOCTL(ATM_RSTADDR32, do_atm_ioctl)
  3548. HANDLE_IOCTL(ATM_ADDADDR32, do_atm_ioctl)
  3549. HANDLE_IOCTL(ATM_DELADDR32, do_atm_ioctl)
  3550. HANDLE_IOCTL(ATM_GETCIRANGE32, do_atm_ioctl)
  3551. HANDLE_IOCTL(ATM_SETCIRANGE32, do_atm_ioctl)
  3552. HANDLE_IOCTL(ATM_SETESI32, do_atm_ioctl)
  3553. HANDLE_IOCTL(ATM_SETESIF32, do_atm_ioctl)
  3554. HANDLE_IOCTL(ATM_GETSTAT32, do_atm_ioctl)
  3555. HANDLE_IOCTL(ATM_GETSTATZ32, do_atm_ioctl)
  3556. HANDLE_IOCTL(ATM_GETLOOP32, do_atm_ioctl)
  3557. HANDLE_IOCTL(ATM_SETLOOP32, do_atm_ioctl)
  3558. HANDLE_IOCTL(ATM_QUERYLOOP32, do_atm_ioctl)
  3559. HANDLE_IOCTL(SONET_GETSTAT, do_atm_ioctl)
  3560. HANDLE_IOCTL(SONET_GETSTATZ, do_atm_ioctl)
  3561. HANDLE_IOCTL(SONET_GETDIAG, do_atm_ioctl)
  3562. HANDLE_IOCTL(SONET_SETDIAG, do_atm_ioctl)
  3563. HANDLE_IOCTL(SONET_CLRDIAG, do_atm_ioctl)
  3564. HANDLE_IOCTL(SONET_SETFRAMING, do_atm_ioctl)
  3565. HANDLE_IOCTL(SONET_GETFRAMING, do_atm_ioctl)
  3566. HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl)
  3567. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  3568. HANDLE_IOCTL(VG_STATUS, do_lvm_ioctl)
  3569. HANDLE_IOCTL(VG_CREATE_OLD, do_lvm_ioctl)
  3570. HANDLE_IOCTL(VG_CREATE, do_lvm_ioctl)
  3571. HANDLE_IOCTL(VG_EXTEND, do_lvm_ioctl)
  3572. HANDLE_IOCTL(LV_CREATE, do_lvm_ioctl)
  3573. HANDLE_IOCTL(LV_REMOVE, do_lvm_ioctl)
  3574. HANDLE_IOCTL(LV_EXTEND, do_lvm_ioctl)
  3575. HANDLE_IOCTL(LV_REDUCE, do_lvm_ioctl)
  3576. HANDLE_IOCTL(LV_RENAME, do_lvm_ioctl)
  3577. HANDLE_IOCTL(LV_STATUS_BYNAME, do_lvm_ioctl)
  3578. HANDLE_IOCTL(LV_STATUS_BYINDEX, do_lvm_ioctl)
  3579. HANDLE_IOCTL(LV_STATUS_BYDEV, do_lvm_ioctl)
  3580. HANDLE_IOCTL(PV_CHANGE, do_lvm_ioctl)
  3581. HANDLE_IOCTL(PV_STATUS, do_lvm_ioctl)
  3582. #endif /* LVM */
  3583. #if defined(CONFIG_GENRTC)
  3584. COMPATIBLE_IOCTL(RTC_AIE_ON)
  3585. COMPATIBLE_IOCTL(RTC_AIE_OFF)
  3586. COMPATIBLE_IOCTL(RTC_UIE_ON)
  3587. COMPATIBLE_IOCTL(RTC_UIE_OFF)
  3588. COMPATIBLE_IOCTL(RTC_PIE_ON)
  3589. COMPATIBLE_IOCTL(RTC_PIE_OFF)
  3590. COMPATIBLE_IOCTL(RTC_WIE_ON)
  3591. COMPATIBLE_IOCTL(RTC_WIE_OFF)
  3592. COMPATIBLE_IOCTL(RTC_ALM_SET)   /* struct rtc_time only has ints */
  3593. COMPATIBLE_IOCTL(RTC_ALM_READ)  /* struct rtc_time only has ints */
  3594. COMPATIBLE_IOCTL(RTC_RD_TIME)   /* struct rtc_time only has ints */
  3595. COMPATIBLE_IOCTL(RTC_SET_TIME)  /* struct rtc_time only has ints */
  3596. HANDLE_IOCTL(RTC_IRQP_READ, w_long)
  3597. COMPATIBLE_IOCTL(RTC_IRQP_SET)
  3598. HANDLE_IOCTL(RTC_EPOCH_READ, w_long)
  3599. COMPATIBLE_IOCTL(RTC_EPOCH_SET)
  3600. #endif
  3601. #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
  3602. HANDLE_IOCTL(DRM32_IOCTL_VERSION, drm32_version);
  3603. HANDLE_IOCTL(DRM32_IOCTL_GET_UNIQUE, drm32_getsetunique);
  3604. HANDLE_IOCTL(DRM32_IOCTL_SET_UNIQUE, drm32_getsetunique);
  3605. HANDLE_IOCTL(DRM32_IOCTL_ADD_MAP, drm32_addmap);
  3606. HANDLE_IOCTL(DRM32_IOCTL_INFO_BUFS, drm32_info_bufs);
  3607. HANDLE_IOCTL(DRM32_IOCTL_FREE_BUFS, drm32_free_bufs);
  3608. HANDLE_IOCTL(DRM32_IOCTL_MAP_BUFS, drm32_map_bufs);
  3609. HANDLE_IOCTL(DRM32_IOCTL_DMA, drm32_dma);
  3610. HANDLE_IOCTL(DRM32_IOCTL_RES_CTX, drm32_res_ctx);
  3611. #endif /* DRM */
  3612. COMPATIBLE_IOCTL(PA_PERF_ON)
  3613. COMPATIBLE_IOCTL(PA_PERF_OFF)
  3614. COMPATIBLE_IOCTL(PA_PERF_VERSION)
  3615. IOCTL_TABLE_END
  3617. unsigned int ioctl32_hash_table[1024];
  3619. extern inline unsigned long ioctl32_hash(unsigned long cmd)
  3620. {
  3621. return ((cmd >> 6) ^ (cmd >> 4) ^ cmd) & 0x3ff;
  3622. }
  3624. static void ioctl32_insert_translation(struct ioctl_trans *trans)
  3625. {
  3626. unsigned long hash;
  3627. struct ioctl_trans *t;
  3629. hash = ioctl32_hash (trans->cmd);
  3630. if (!ioctl32_hash_table[hash])
  3631. ioctl32_hash_table[hash] = (u32)(long)trans;
  3632. else {
  3633. t = (struct ioctl_trans *)(long)ioctl32_hash_table[hash];
  3634. while (t->next)
  3635. t = (struct ioctl_trans *)(long)t->next;
  3636. trans->next = 0;
  3637. t->next = (u32)(long)trans;
  3638. }
  3639. }
  3641. static int __init init_sys32_ioctl(void)
  3642. {
  3643. int i;
  3644. extern struct ioctl_trans ioctl_translations[], ioctl_translations_end[];
  3646. for (i = 0; &ioctl_translations[i] < &ioctl_translations_end[0]; i++)
  3647. ioctl32_insert_translation(&ioctl_translations[i]);
  3648. return 0;
  3649. }
  3651. __initcall(init_sys32_ioctl);
  3653. static struct ioctl_trans *additional_ioctls;
  3655. /* Always call these with kernel lock held! */
  3657. int register_ioctl32_conversion(unsigned int cmd, int (*handler)(unsigned int, unsigned int, unsigned long, struct file *))
  3658. {
  3659. int i;
  3661. panic("register_ioctl32_conversion() is B0RKEN! Called by %pn", __builtin_return_address(0));
  3663. if (!additional_ioctls) {
  3664. additional_ioctls = module_map(PAGE_SIZE);
  3665. if (!additional_ioctls)
  3666. return -ENOMEM;
  3667. memset(additional_ioctls, 0, PAGE_SIZE);
  3668. }
  3669. for (i = 0; i < PAGE_SIZE/sizeof(struct ioctl_trans); i++)
  3670. if (!additional_ioctls[i].cmd)
  3671. break;
  3672. if (i == PAGE_SIZE/sizeof(struct ioctl_trans))
  3673. return -ENOMEM;
  3674. additional_ioctls[i].cmd = cmd;
  3675. if (!handler)
  3676. additional_ioctls[i].handler = (u32)(long)sys_ioctl;
  3677. else
  3678. additional_ioctls[i].handler = (u32)(long)handler;
  3679. ioctl32_insert_translation(&additional_ioctls[i]);
  3680. return 0;
  3681. }
  3683. int unregister_ioctl32_conversion(unsigned int cmd)
  3684. {
  3685. unsigned long hash = ioctl32_hash(cmd);
  3686. struct ioctl_trans *t, *t1;
  3688. t = (struct ioctl_trans *)(long)ioctl32_hash_table[hash];
  3689. if (!t) return -EINVAL;
  3690. if (t->cmd == cmd && t >= additional_ioctls &&
  3691.     (unsigned long)t < ((unsigned long)additional_ioctls) + PAGE_SIZE) {
  3692. ioctl32_hash_table[hash] = t->next;
  3693. t->cmd = 0;
  3694. return 0;
  3695. } else while (t->next) {
  3696. t1 = (struct ioctl_trans *)(long)t->next;
  3697. if (t1->cmd == cmd && t1 >= additional_ioctls &&
  3698.     (unsigned long)t1 < ((unsigned long)additional_ioctls) + PAGE_SIZE) {
  3699. t1->cmd = 0;
  3700. t->next = t1->next;
  3701. return 0;
  3702. }
  3703. t = t1;
  3704. }
  3705. return -EINVAL;
  3706. }
  3708. asmlinkage int sys32_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  3709. {
  3710. struct file * filp;
  3711. int (*handler)(unsigned int, unsigned int, unsigned long, struct file * filp);
  3712. unsigned long pafnptr[4];
  3713. extern char __gp;
  3714. struct ioctl_trans *t;
  3715. int error = -EBADF;
  3717. filp = fget(fd);
  3718. if(!filp)
  3719. goto out2;
  3721. if (!filp->f_op || !filp->f_op->ioctl) {
  3722. error = sys_ioctl (fd, cmd, arg);
  3723. goto out;
  3724. }
  3726. /* intercept private networking ioctl() calls here since it is
  3727.  * an onerous task to figure out which ones of the HANDLE_IOCTL
  3728.  * list map to these values.
  3729.  */
  3730. if (cmd >= SIOCDEVPRIVATE && cmd <= SIOCDEVPRIVATE + 0xf) {
  3731. error = siocprivate(fd, cmd, arg);
  3732. goto out;
  3733. }
  3735. t = (struct ioctl_trans *)(long)ioctl32_hash_table [ioctl32_hash (cmd)];
  3737. while (t && t->cmd != cmd)
  3738. t = (struct ioctl_trans *)(long)t->next;
  3739. if (t) {
  3740. handler = (void *) pafnptr;
  3741. pafnptr[0] = pafnptr[1] = 0UL;
  3742. pafnptr[2] = (unsigned long) t->handler;
  3743. pafnptr[3] = A(&__gp);
  3744. error = handler(fd, cmd, arg, filp);
  3745. } else {
  3746. static int count = 0;
  3747. if (++count <= 20)
  3748. printk(KERN_WARNING
  3749. "sys32_ioctl: Unknown cmd fd(%d) "
  3750. "cmd(%08x) arg(%08x)n",
  3751. (int)fd, (unsigned int)cmd, (unsigned int)arg);
  3752. error = -EINVAL;
  3753. }
  3754. out:
  3755. fput(filp);
  3756. out2:
  3757. return error;
  3758. }