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

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

Linux/Unix编程

开发平台：

Unix_Linux

ioctl32.c：源码内容
  1. /*
  2.  * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
  3.  *
  4.  * Copyright (C) 2000 Silicon Graphics, Inc.
  5.  * Written by Ulf Carlsson (ulfc@engr.sgi.com)
  6.  * Copyright (C) 2000 Ralf Baechle
  7.  *
  8.  * Mostly stolen from the sparc64 ioctl32 implementation.
  9.  */
  10. #include <linux/config.h>
  11. #include <linux/types.h>
  12. #include <linux/kernel.h>
  13. #include <linux/sched.h>
  14. #include <linux/if.h>
  15. #include <linux/mm.h>
  16. #include <linux/mtio.h>
  17. #include <linux/init.h>
  18. #include <linux/file.h>
  19. #include <linux/fs.h>
  20. #include <linux/ppp_defs.h>
  21. #include <linux/if_ppp.h>
  22. #include <linux/if_pppox.h>
  23. #include <linux/cdrom.h>
  24. #include <linux/loop.h>
  25. #include <linux/vt.h>
  26. #include <linux/kd.h>
  27. #include <linux/netdevice.h>
  28. #include <linux/route.h>
  29. #include <linux/hdreg.h>
  30. #include <linux/blkpg.h>
  31. #include <linux/blkdev.h>
  32. #include <linux/elevator.h>
  33. #include <linux/auto_fs.h>
  34. #include <linux/ext2_fs.h>
  35. #include <linux/raid/md_u.h>
  37. #include <scsi/scsi.h>
  38. #undef __KERNEL__ /* This file was born to be ugly ...  */
  39. #include <scsi/scsi_ioctl.h>
  40. #define __KERNEL__
  41. #include <asm/types.h>
  42. #include <asm/uaccess.h>
  44. #include <linux/rtc.h>
  46. long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
  48. static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
  49. {
  50. mm_segment_t old_fs = get_fs();
  51. int err;
  52. unsigned long val;
  54. set_fs (KERNEL_DS);
  55. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  56. set_fs (old_fs);
  57. if (!err && put_user((unsigned int) val, (u32 *)arg))
  58. return -EFAULT;
  59. return err;
  60. }
  62. static int rw_long(unsigned int fd, unsigned int cmd, unsigned long arg)
  63. {
  64. mm_segment_t old_fs = get_fs();
  65. int err;
  66. unsigned long val;
  68. if (get_user(val, (u32 *)arg))
  69. return -EFAULT;
  70. set_fs(KERNEL_DS);
  71. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  72. set_fs (old_fs);
  73. if (!err && put_user(val, (u32 *)arg))
  74. return -EFAULT;
  75. return err;
  76. }
  78. #define A(__x) ((unsigned long)(__x))
  80. struct timeval32 {
  81. int tv_sec;
  82. int tv_usec;
  83. };
  85. static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
  86. {
  87. struct timeval32 *up = (struct timeval32 *)arg;
  88. struct timeval ktv;
  89. mm_segment_t old_fs = get_fs();
  90. int err;
  92. set_fs(KERNEL_DS);
  93. err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
  94. set_fs(old_fs);
  95. if (!err) {
  96. err = put_user(ktv.tv_sec, &up->tv_sec);
  97. err |= __put_user(ktv.tv_usec, &up->tv_usec);
  98. }
  100. return err;
  101. }
  103. #define EXT2_IOC32_GETFLAGS               _IOR('f', 1, int)
  104. #define EXT2_IOC32_SETFLAGS               _IOW('f', 2, int)
  105. #define EXT2_IOC32_GETVERSION             _IOR('v', 1, int)
  106. #define EXT2_IOC32_SETVERSION             _IOW('v', 2, int)
  108. struct ifmap32 {
  109. unsigned int mem_start;
  110. unsigned int mem_end;
  111. unsigned short base_addr;
  112. unsigned char irq;
  113. unsigned char dma;
  114. unsigned char port;
  115. };
  117. struct ifreq32 {
  118. #define IFHWADDRLEN     6
  119. #define IFNAMSIZ        16
  120.         union {
  121.                 char    ifrn_name[IFNAMSIZ]; /* if name, e.g. "en0" */
  122.         } ifr_ifrn;
  123.         union {
  124.                 struct  sockaddr ifru_addr;
  125.                 struct  sockaddr ifru_dstaddr;
  126.                 struct  sockaddr ifru_broadaddr;
  127.                 struct  sockaddr ifru_netmask;
  128.                 struct  sockaddr ifru_hwaddr;
  129.                 short   ifru_flags;
  130.                 int     ifru_ivalue;
  131.                 int     ifru_mtu;
  132.                 struct  ifmap32 ifru_map;
  133.                 char    ifru_slave[IFNAMSIZ];   /* Just fits the size */
  134. char ifru_newname[IFNAMSIZ];
  135.                 __kernel_caddr_t32 ifru_data;
  136.         } ifr_ifru;
  137. };
  139. struct ifconf32 {
  140.         int     ifc_len;                        /* size of buffer       */
  141.         __kernel_caddr_t32  ifcbuf;
  142. };
  144. #ifdef CONFIG_NET
  146. static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
  147. {
  148. struct ireq32 *uir32 = (struct ireq32 *)arg;
  149. struct net_device *dev;
  150. struct ifreq32 ifr32;
  152. if (copy_from_user(&ifr32, uir32, sizeof(struct ifreq32)))
  153. return -EFAULT;
  155. read_lock(&dev_base_lock);
  156. dev = __dev_get_by_index(ifr32.ifr_ifindex);
  157. if (!dev) {
  158. read_unlock(&dev_base_lock);
  159. return -ENODEV;
  160. }
  162. strcpy(ifr32.ifr_name, dev->name);
  163. read_unlock(&dev_base_lock);
  165. if (copy_to_user(uir32, &ifr32, sizeof(struct ifreq32)))
  166.     return -EFAULT;
  168. return 0;
  169. }
  171. static inline int dev_ifconf(unsigned int fd, unsigned int cmd,
  172.      unsigned long arg)
  173. {
  174. struct ioconf32 *uifc32 = (struct ioconf32 *)arg;
  175. struct ifconf32 ifc32;
  176. struct ifconf ifc;
  177. struct ifreq32 *ifr32;
  178. struct ifreq *ifr;
  179. mm_segment_t old_fs;
  180. int len;
  181. int err;
  183. if (copy_from_user(&ifc32, uifc32, sizeof(struct ifconf32)))
  184. return -EFAULT;
  186. if(ifc32.ifcbuf == 0) {
  187. ifc32.ifc_len = 0;
  188. ifc.ifc_len = 0;
  189. ifc.ifc_buf = NULL;
  190. } else {
  191. ifc.ifc_len = ((ifc32.ifc_len / sizeof (struct ifreq32))) *
  192. sizeof (struct ifreq);
  193. ifc.ifc_buf = kmalloc (ifc.ifc_len, GFP_KERNEL);
  194. if (!ifc.ifc_buf)
  195. return -ENOMEM;
  196. }
  197. ifr = ifc.ifc_req;
  198. ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
  199. len = ifc32.ifc_len / sizeof (struct ifreq32);
  200. while (len--) {
  201. if (copy_from_user(ifr++, ifr32++, sizeof (struct ifreq32))) {
  202. err = -EFAULT;
  203. goto out;
  204. }
  205. }
  207. old_fs = get_fs();
  208. set_fs (KERNEL_DS);
  209. err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)&ifc);
  210. set_fs (old_fs);
  211. if (err)
  212. goto out;
  214. ifr = ifc.ifc_req;
  215. ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
  216. len = ifc.ifc_len / sizeof (struct ifreq);
  217. ifc32.ifc_len = len * sizeof (struct ifreq32);
  219. while (len--) {
  220. if (copy_to_user(ifr32++, ifr++, sizeof (struct ifreq32))) {
  221. err = -EFAULT;
  222. goto out;
  223. }
  224. }
  226. if (copy_to_user(uifc32, &ifc32, sizeof(struct ifconf32))) {
  227. err = -EFAULT;
  228. goto out;
  229. }
  230. out:
  231. if(ifc.ifc_buf != NULL)
  232. kfree (ifc.ifc_buf);
  233. return err;
  234. }
  236. static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
  237. {
  238. struct ifreq ifr;
  239. mm_segment_t old_fs;
  240. int err;
  242. switch (cmd) {
  243. case SIOCSIFMAP:
  244. err = copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(ifr.ifr_name));
  245. err |= __get_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
  246. err |= __get_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
  247. err |= __get_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
  248. err |= __get_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
  249. err |= __get_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
  250. err |= __get_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
  251. if (err)
  252. return -EFAULT;
  253. break;
  254. default:
  255. if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  256. return -EFAULT;
  257. break;
  258. }
  259. old_fs = get_fs();
  260. set_fs (KERNEL_DS);
  261. err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
  262. set_fs (old_fs);
  263. if (!err) {
  264. switch (cmd) {
  265. case SIOCGIFFLAGS:
  266. case SIOCGIFMETRIC:
  267. case SIOCGIFMTU:
  268. case SIOCGIFMEM:
  269. case SIOCGIFHWADDR:
  270. case SIOCGIFINDEX:
  271. case SIOCGIFADDR:
  272. case SIOCGIFBRDADDR:
  273. case SIOCGIFDSTADDR:
  274. case SIOCGIFNETMASK:
  275. case SIOCGIFTXQLEN:
  276. if (copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(struct ifreq32)))
  277. return -EFAULT;
  278. break;
  279. case SIOCGIFMAP:
  280. err = copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(ifr.ifr_name));
  281. err |= __put_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
  282. err |= __put_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
  283. err |= __put_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
  284. err |= __put_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
  285. err |= __put_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
  286. err |= __put_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
  287. if (err)
  288. err = -EFAULT;
  289. break;
  290. }
  291. }
  292. return err;
  293. }
  295. struct rtentry32
  296. {
  297. unsigned int rt_pad1;
  298. struct sockaddr rt_dst; /* target address */
  299. struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
  300. struct sockaddr rt_genmask; /* target network mask (IP) */
  301. unsigned short rt_flags;
  302. short rt_pad2;
  303. unsigned int rt_pad3;
  304. unsigned int rt_pad4;
  305. short rt_metric; /* +1 for binary compatibility! */
  306. unsigned int rt_dev; /* forcing the device at add */
  307. unsigned int rt_mtu; /* per route MTU/Window  */
  308. #ifndef __KERNEL__
  309. #define rt_mss rt_mtu /* Compatibility :-(            */
  310. #endif
  311. unsigned int rt_window; /* Window clamping  */
  312. unsigned short rt_irtt; /* Initial RTT */
  313. };
  315. static inline int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  316. {
  317. struct rtentry32 *ur = (struct rtentry32 *)arg;
  318. struct rtentry r;
  319. char devname[16];
  320. u32 rtdev;
  321. int ret;
  322. mm_segment_t old_fs = get_fs();
  324. ret = copy_from_user (&r.rt_dst, &(ur->rt_dst), 3 * sizeof(struct sockaddr));
  325. ret |= __get_user (r.rt_flags, &(ur->rt_flags));
  326. ret |= __get_user (r.rt_metric, &(ur->rt_metric));
  327. ret |= __get_user (r.rt_mtu, &(ur->rt_mtu));
  328. ret |= __get_user (r.rt_window, &(ur->rt_window));
  329. ret |= __get_user (r.rt_irtt, &(ur->rt_irtt));
  330. ret |= __get_user (rtdev, &(ur->rt_dev));
  331. if (rtdev) {
  332. ret |= copy_from_user (devname, (char *)A(rtdev), 15);
  333. r.rt_dev = devname; devname[15] = 0;
  334. } else
  335. r.rt_dev = 0;
  336. if (ret)
  337. return -EFAULT;
  338. set_fs (KERNEL_DS);
  339. ret = sys_ioctl (fd, cmd, (long)&r);
  340. set_fs (old_fs);
  341. return ret;
  342. }
  344. #endif /* CONFIG_NET */
  346. static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  347. {
  348. /* These are just misnamed, they actually get/put from/to user an int */
  349. switch (cmd) {
  350. case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;
  351. case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;
  352. case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;
  353. case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;
  354. }
  355. return sys_ioctl(fd, cmd, arg);
  356. }
  358. struct hd_geometry32 {
  359. unsigned char heads;
  360. unsigned char sectors;
  361. unsigned short cylinders;
  362. u32 start;
  363. };
  365. static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
  366. {
  367. mm_segment_t old_fs = get_fs();
  368. struct hd_geometry geo;
  369. int err;
  371. set_fs (KERNEL_DS);
  372. err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
  373. set_fs (old_fs);
  374. if (!err) {
  375. err = copy_to_user ((struct hd_geometry32 *)arg, &geo, 4);
  376. err |= __put_user (geo.start, &(((struct hd_geometry32 *)arg)->start));
  377. }
  379. return err ? -EFAULT : 0;
  380. }
  382. static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  383. {
  384. mm_segment_t old_fs = get_fs();
  385. unsigned long kval;
  386. unsigned int *uvp;
  387. int error;
  389. set_fs(KERNEL_DS);
  390. error = sys_ioctl(fd, cmd, (long)&kval);
  391. set_fs(old_fs);
  393. if (error == 0) {
  394. uvp = (unsigned int *)arg;
  395. if (put_user(kval, uvp))
  396. error = -EFAULT;
  397. }
  399. return error;
  400. }
  402. static int ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
  403. {
  404. return -EINVAL;
  405. }
  407. struct blkpg_ioctl_arg32 {
  408. int op;
  409. int flags;
  410. int datalen;
  411. u32 data;
  412. };
  414. static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd,
  415.                              struct blkpg_ioctl_arg32 *arg)
  416. {
  417. struct blkpg_ioctl_arg a;
  418. struct blkpg_partition p;
  419. int err;
  420. mm_segment_t old_fs = get_fs();
  422. err = get_user(a.op, &arg->op);
  423. err |= __get_user(a.flags, &arg->flags);
  424. err |= __get_user(a.datalen, &arg->datalen);
  425. err |= __get_user((long)a.data, &arg->data);
  426. if (err) return err;
  427. switch (a.op) {
  428. case BLKPG_ADD_PARTITION:
  429. case BLKPG_DEL_PARTITION:
  430. if (a.datalen < sizeof(struct blkpg_partition))
  431. return -EINVAL;
  432.                 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
  433. return -EFAULT;
  434. a.data = &p;
  435. set_fs (KERNEL_DS);
  436. err = sys_ioctl(fd, cmd, (unsigned long)&a);
  437. set_fs (old_fs);
  438. default:
  439. return -EINVAL;
  440. }
  441. return err;
  442. }
  444. struct mtget32 {
  445. __u32 mt_type;
  446. __u32 mt_resid;
  447. __u32 mt_dsreg;
  448. __u32 mt_gstat;
  449. __u32 mt_erreg;
  450. __kernel_daddr_t32 mt_fileno;
  451. __kernel_daddr_t32 mt_blkno;
  452. };
  453. #define MTIOCGET32 _IOR('m', 2, struct mtget32)
  455. struct mtpos32 {
  456. __u32 mt_blkno;
  457. };
  458. #define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
  460. struct mtconfiginfo32 {
  461. __u32 mt_type;
  462. __u32 ifc_type;
  463. __u16 irqnr;
  464. __u16 dmanr;
  465. __u16 port;
  466. __u32 debug;
  467. __u32 have_dens:1;
  468. __u32 have_bsf:1;
  469. __u32 have_fsr:1;
  470. __u32 have_bsr:1;
  471. __u32 have_eod:1;
  472. __u32 have_seek:1;
  473. __u32 have_tell:1;
  474. __u32 have_ras1:1;
  475. __u32 have_ras2:1;
  476. __u32 have_ras3:1;
  477. __u32 have_qfa:1;
  478. __u32 pad1:5;
  479. char reserved[10];
  480. };
  481. #define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
  482. #define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
  484. static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  485. {
  486. mm_segment_t old_fs = get_fs();
  487. struct mtconfiginfo info;
  488. struct mtget get;
  489. struct mtpos pos;
  490. unsigned long kcmd;
  491. void *karg;
  492. int err = 0;
  494. switch(cmd) {
  495. case MTIOCPOS32:
  496. kcmd = MTIOCPOS;
  497. karg = &pos;
  498. break;
  499. case MTIOCGET32:
  500. kcmd = MTIOCGET;
  501. karg = &get;
  502. break;
  503. case MTIOCGETCONFIG32:
  504. kcmd = MTIOCGETCONFIG;
  505. karg = &info;
  506. break;
  507. case MTIOCSETCONFIG32:
  508. kcmd = MTIOCSETCONFIG;
  509. karg = &info;
  510. err = __get_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
  511. err |= __get_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
  512. err |= __get_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
  513. err |= __get_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
  514. err |= __get_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
  515. err |= __get_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
  516. err |= __copy_from_user((char *)&info.debug + sizeof(info.debug),
  517.      (char *)&((struct mtconfiginfo32 *)arg)->debug
  518.      + sizeof(((struct mtconfiginfo32 *)arg)->debug), sizeof(__u32));
  519. if (err)
  520. return -EFAULT;
  521. break;
  522. default:
  523. do {
  524. static int count = 0;
  525. if (++count <= 20)
  526. printk("mt_ioctl: Unknown cmd fd(%d) "
  527.        "cmd(%08x) arg(%08x)n",
  528.        (int)fd, (unsigned int)cmd, (unsigned int)arg);
  529. } while(0);
  530. return -EINVAL;
  531. }
  532. set_fs (KERNEL_DS);
  533. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  534. set_fs (old_fs);
  535. if (err)
  536. return err;
  537. switch (cmd) {
  538. case MTIOCPOS32:
  539. err = __put_user(pos.mt_blkno, &((struct mtpos32 *)arg)->mt_blkno);
  540. break;
  541. case MTIOCGET32:
  542. err = __put_user(get.mt_type, &((struct mtget32 *)arg)->mt_type);
  543. err |= __put_user(get.mt_resid, &((struct mtget32 *)arg)->mt_resid);
  544. err |= __put_user(get.mt_dsreg, &((struct mtget32 *)arg)->mt_dsreg);
  545. err |= __put_user(get.mt_gstat, &((struct mtget32 *)arg)->mt_gstat);
  546. err |= __put_user(get.mt_erreg, &((struct mtget32 *)arg)->mt_erreg);
  547. err |= __put_user(get.mt_fileno, &((struct mtget32 *)arg)->mt_fileno);
  548. err |= __put_user(get.mt_blkno, &((struct mtget32 *)arg)->mt_blkno);
  549. break;
  550. case MTIOCGETCONFIG32:
  551. err = __put_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
  552. err |= __put_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
  553. err |= __put_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
  554. err |= __put_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
  555. err |= __put_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
  556. err |= __put_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
  557. err |= __copy_to_user((char *)&((struct mtconfiginfo32 *)arg)->debug
  558.         + sizeof(((struct mtconfiginfo32 *)arg)->debug),
  559.    (char *)&info.debug + sizeof(info.debug), sizeof(__u32));
  560. break;
  561. case MTIOCSETCONFIG32:
  562. break;
  563. }
  564. return err ? -EFAULT: 0;
  565. }
  567. #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
  569. static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
  570. {
  571. return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
  572. }
  574. struct ioctl32_handler {
  575. unsigned int cmd;
  576. int (*function)(unsigned int, unsigned int, unsigned long);
  577. };
  579. struct ioctl32_list {
  580. struct ioctl32_handler handler;
  581. struct ioctl32_list *next;
  582. };
  584. #define IOCTL32_DEFAULT(cmd) { { cmd, (void *) sys_ioctl }, 0 }
  585. #define IOCTL32_HANDLER(cmd, handler) { { cmd, (void *) handler }, 0 }
  587. static struct ioctl32_list ioctl32_handler_table[] = {
  588. IOCTL32_DEFAULT(TCGETA),
  589. IOCTL32_DEFAULT(TCSETA),
  590. IOCTL32_DEFAULT(TCSETAW),
  591. IOCTL32_DEFAULT(TCSETAF),
  592. IOCTL32_DEFAULT(TCSBRK),
  593. IOCTL32_DEFAULT(TCXONC),
  594. IOCTL32_DEFAULT(TCFLSH),
  595. IOCTL32_DEFAULT(TCGETS),
  596. IOCTL32_DEFAULT(TCSETS),
  597. IOCTL32_DEFAULT(TCSETSW),
  598. IOCTL32_DEFAULT(TCSETSF),
  599. IOCTL32_DEFAULT(TIOCLINUX),
  601. IOCTL32_DEFAULT(TIOCGETD),
  602. IOCTL32_DEFAULT(TIOCSETD),
  603. IOCTL32_DEFAULT(TIOCEXCL),
  604. IOCTL32_DEFAULT(TIOCNXCL),
  605. IOCTL32_DEFAULT(TIOCCONS),
  606. IOCTL32_DEFAULT(TIOCGSOFTCAR),
  607. IOCTL32_DEFAULT(TIOCSSOFTCAR),
  608. IOCTL32_DEFAULT(TIOCSWINSZ),
  609. IOCTL32_DEFAULT(TIOCGWINSZ),
  610. IOCTL32_DEFAULT(TIOCMGET),
  611. IOCTL32_DEFAULT(TIOCMBIC),
  612. IOCTL32_DEFAULT(TIOCMBIS),
  613. IOCTL32_DEFAULT(TIOCMSET),
  614. IOCTL32_DEFAULT(TIOCPKT),
  615. IOCTL32_DEFAULT(TIOCNOTTY),
  616. IOCTL32_DEFAULT(TIOCSTI),
  617. IOCTL32_DEFAULT(TIOCOUTQ),
  618. IOCTL32_DEFAULT(TIOCSPGRP),
  619. IOCTL32_DEFAULT(TIOCGPGRP),
  620. IOCTL32_DEFAULT(TIOCSCTTY),
  621. IOCTL32_DEFAULT(TIOCGPTN),
  622. IOCTL32_DEFAULT(TIOCSPTLCK),
  623. IOCTL32_DEFAULT(TIOCGSERIAL),
  624. IOCTL32_DEFAULT(TIOCSSERIAL),
  625. IOCTL32_DEFAULT(TIOCSERGETLSR),
  627. IOCTL32_DEFAULT(FIOCLEX),
  628. IOCTL32_DEFAULT(FIONCLEX),
  629. IOCTL32_DEFAULT(FIOASYNC),
  630. IOCTL32_DEFAULT(FIONBIO),
  631. IOCTL32_DEFAULT(FIONREAD),
  633. /* Big K */
  634. IOCTL32_DEFAULT(PIO_FONT),
  635. IOCTL32_DEFAULT(GIO_FONT),
  636. IOCTL32_DEFAULT(KDSIGACCEPT),
  637. IOCTL32_DEFAULT(KDGETKEYCODE),
  638. IOCTL32_DEFAULT(KDSETKEYCODE),
  639. IOCTL32_DEFAULT(KIOCSOUND),
  640. IOCTL32_DEFAULT(KDMKTONE),
  641. IOCTL32_DEFAULT(KDGKBTYPE),
  642. IOCTL32_DEFAULT(KDSETMODE),
  643. IOCTL32_DEFAULT(KDGETMODE),
  644. IOCTL32_DEFAULT(KDSKBMODE),
  645. IOCTL32_DEFAULT(KDGKBMODE),
  646. IOCTL32_DEFAULT(KDSKBMETA),
  647. IOCTL32_DEFAULT(KDGKBMETA),
  648. IOCTL32_DEFAULT(KDGKBENT),
  649. IOCTL32_DEFAULT(KDSKBENT),
  650. IOCTL32_DEFAULT(KDGKBSENT),
  651. IOCTL32_DEFAULT(KDSKBSENT),
  652. IOCTL32_DEFAULT(KDGKBDIACR),
  653. IOCTL32_DEFAULT(KDSKBDIACR),
  654. IOCTL32_DEFAULT(KDGKBLED),
  655. IOCTL32_DEFAULT(KDSKBLED),
  656. IOCTL32_DEFAULT(KDGETLED),
  657. IOCTL32_DEFAULT(KDSETLED),
  658. IOCTL32_DEFAULT(GIO_SCRNMAP),
  659. IOCTL32_DEFAULT(PIO_SCRNMAP),
  660. IOCTL32_DEFAULT(GIO_UNISCRNMAP),
  661. IOCTL32_DEFAULT(PIO_UNISCRNMAP),
  662. IOCTL32_DEFAULT(PIO_FONTRESET),
  663. IOCTL32_DEFAULT(PIO_UNIMAPCLR),
  665. /* Big S */
  666. IOCTL32_DEFAULT(SCSI_IOCTL_GET_IDLUN),
  667. IOCTL32_DEFAULT(SCSI_IOCTL_DOORLOCK),
  668. IOCTL32_DEFAULT(SCSI_IOCTL_DOORUNLOCK),
  669. IOCTL32_DEFAULT(SCSI_IOCTL_TEST_UNIT_READY),
  670. IOCTL32_DEFAULT(SCSI_IOCTL_TAGGED_ENABLE),
  671. IOCTL32_DEFAULT(SCSI_IOCTL_TAGGED_DISABLE),
  672. IOCTL32_DEFAULT(SCSI_IOCTL_GET_BUS_NUMBER),
  673. IOCTL32_DEFAULT(SCSI_IOCTL_SEND_COMMAND),
  675. /* Big V */
  676. IOCTL32_DEFAULT(VT_SETMODE),
  677. IOCTL32_DEFAULT(VT_GETMODE),
  678. IOCTL32_DEFAULT(VT_GETSTATE),
  679. IOCTL32_DEFAULT(VT_OPENQRY),
  680. IOCTL32_DEFAULT(VT_ACTIVATE),
  681. IOCTL32_DEFAULT(VT_WAITACTIVE),
  682. IOCTL32_DEFAULT(VT_RELDISP),
  683. IOCTL32_DEFAULT(VT_DISALLOCATE),
  684. IOCTL32_DEFAULT(VT_RESIZE),
  685. IOCTL32_DEFAULT(VT_RESIZEX),
  686. IOCTL32_DEFAULT(VT_LOCKSWITCH),
  687. IOCTL32_DEFAULT(VT_UNLOCKSWITCH),
  689. #ifdef CONFIG_NET
  690. /* Socket level stuff */
  691. IOCTL32_DEFAULT(FIOSETOWN),
  692. IOCTL32_DEFAULT(SIOCSPGRP),
  693. IOCTL32_DEFAULT(FIOGETOWN),
  694. IOCTL32_DEFAULT(SIOCGPGRP),
  695. IOCTL32_DEFAULT(SIOCATMARK),
  696. IOCTL32_DEFAULT(SIOCSIFLINK),
  697. IOCTL32_DEFAULT(SIOCSIFENCAP),
  698. IOCTL32_DEFAULT(SIOCGIFENCAP),
  699. IOCTL32_DEFAULT(SIOCSIFBR),
  700. IOCTL32_DEFAULT(SIOCGIFBR),
  701. IOCTL32_DEFAULT(SIOCSARP),
  702. IOCTL32_DEFAULT(SIOCGARP),
  703. IOCTL32_DEFAULT(SIOCDARP),
  704. IOCTL32_DEFAULT(SIOCSRARP),
  705. IOCTL32_DEFAULT(SIOCGRARP),
  706. IOCTL32_DEFAULT(SIOCDRARP),
  707. IOCTL32_DEFAULT(SIOCADDDLCI),
  708. IOCTL32_DEFAULT(SIOCDELDLCI),
  709. /* SG stuff */
  710. IOCTL32_DEFAULT(SG_SET_TIMEOUT),
  711. IOCTL32_DEFAULT(SG_GET_TIMEOUT),
  712. IOCTL32_DEFAULT(SG_EMULATED_HOST),
  713. IOCTL32_DEFAULT(SG_SET_TRANSFORM),
  714. IOCTL32_DEFAULT(SG_GET_TRANSFORM),
  715. IOCTL32_DEFAULT(SG_SET_RESERVED_SIZE),
  716. IOCTL32_DEFAULT(SG_GET_RESERVED_SIZE),
  717. IOCTL32_DEFAULT(SG_GET_SCSI_ID),
  718. IOCTL32_DEFAULT(SG_SET_FORCE_LOW_DMA),
  719. IOCTL32_DEFAULT(SG_GET_LOW_DMA),
  720. IOCTL32_DEFAULT(SG_SET_FORCE_PACK_ID),
  721. IOCTL32_DEFAULT(SG_GET_PACK_ID),
  722. IOCTL32_DEFAULT(SG_GET_NUM_WAITING),
  723. IOCTL32_DEFAULT(SG_SET_DEBUG),
  724. IOCTL32_DEFAULT(SG_GET_SG_TABLESIZE),
  725. IOCTL32_DEFAULT(SG_GET_COMMAND_Q),
  726. IOCTL32_DEFAULT(SG_SET_COMMAND_Q),
  727. IOCTL32_DEFAULT(SG_GET_VERSION_NUM),
  728. IOCTL32_DEFAULT(SG_NEXT_CMD_LEN),
  729. IOCTL32_DEFAULT(SG_SCSI_RESET),
  730. IOCTL32_DEFAULT(SG_IO),
  731. IOCTL32_DEFAULT(SG_GET_REQUEST_TABLE),
  732. IOCTL32_DEFAULT(SG_SET_KEEP_ORPHAN),
  733. IOCTL32_DEFAULT(SG_GET_KEEP_ORPHAN),
  734. /* PPP stuff */
  735. IOCTL32_DEFAULT(PPPIOCGFLAGS),
  736. IOCTL32_DEFAULT(PPPIOCSFLAGS),
  737. IOCTL32_DEFAULT(PPPIOCGASYNCMAP),
  738. IOCTL32_DEFAULT(PPPIOCSASYNCMAP),
  739. IOCTL32_DEFAULT(PPPIOCGUNIT),
  740. IOCTL32_DEFAULT(PPPIOCGRASYNCMAP),
  741. IOCTL32_DEFAULT(PPPIOCSRASYNCMAP),
  742. IOCTL32_DEFAULT(PPPIOCGMRU),
  743. IOCTL32_DEFAULT(PPPIOCSMRU),
  744. IOCTL32_DEFAULT(PPPIOCSMAXCID),
  745. IOCTL32_DEFAULT(PPPIOCGXASYNCMAP),
  746. IOCTL32_DEFAULT(PPPIOCSXASYNCMAP),
  747. IOCTL32_DEFAULT(PPPIOCXFERUNIT),
  748. IOCTL32_DEFAULT(PPPIOCGNPMODE),
  749. IOCTL32_DEFAULT(PPPIOCSNPMODE),
  750. IOCTL32_DEFAULT(PPPIOCGDEBUG),
  751. IOCTL32_DEFAULT(PPPIOCSDEBUG),
  752. IOCTL32_DEFAULT(PPPIOCNEWUNIT),
  753. IOCTL32_DEFAULT(PPPIOCATTACH),
  754. IOCTL32_DEFAULT(PPPIOCGCHAN),
  755. /* PPPOX */
  756. IOCTL32_DEFAULT(PPPOEIOCSFWD),
  757. IOCTL32_DEFAULT(PPPOEIOCDFWD),
  758. /* CDROM stuff */
  759. IOCTL32_DEFAULT(CDROMPAUSE),
  760. IOCTL32_DEFAULT(CDROMRESUME),
  761. IOCTL32_DEFAULT(CDROMPLAYMSF),
  762. IOCTL32_DEFAULT(CDROMPLAYTRKIND),
  763. IOCTL32_DEFAULT(CDROMREADTOCHDR),
  764. IOCTL32_DEFAULT(CDROMREADTOCENTRY),
  765. IOCTL32_DEFAULT(CDROMSTOP),
  766. IOCTL32_DEFAULT(CDROMSTART),
  767. IOCTL32_DEFAULT(CDROMEJECT),
  768. IOCTL32_DEFAULT(CDROMVOLCTRL),
  769. IOCTL32_DEFAULT(CDROMSUBCHNL),
  770. IOCTL32_DEFAULT(CDROMEJECT_SW),
  771. IOCTL32_DEFAULT(CDROMMULTISESSION),
  772. IOCTL32_DEFAULT(CDROM_GET_MCN),
  773. IOCTL32_DEFAULT(CDROMRESET),
  774. IOCTL32_DEFAULT(CDROMVOLREAD),
  775. IOCTL32_DEFAULT(CDROMSEEK),
  776. IOCTL32_DEFAULT(CDROMPLAYBLK),
  777. IOCTL32_DEFAULT(CDROMCLOSETRAY),
  778. IOCTL32_DEFAULT(CDROM_SET_OPTIONS),
  779. IOCTL32_DEFAULT(CDROM_CLEAR_OPTIONS),
  780. IOCTL32_DEFAULT(CDROM_SELECT_SPEED),
  781. IOCTL32_DEFAULT(CDROM_SELECT_DISC),
  782. IOCTL32_DEFAULT(CDROM_MEDIA_CHANGED),
  783. IOCTL32_DEFAULT(CDROM_DRIVE_STATUS),
  784. IOCTL32_DEFAULT(CDROM_DISC_STATUS),
  785. IOCTL32_DEFAULT(CDROM_CHANGER_NSLOTS),
  786. IOCTL32_DEFAULT(CDROM_LOCKDOOR),
  787. IOCTL32_DEFAULT(CDROM_DEBUG),
  788. IOCTL32_DEFAULT(CDROM_GET_CAPABILITY),
  789. /* DVD ioctls */
  790. IOCTL32_DEFAULT(DVD_READ_STRUCT),
  791. IOCTL32_DEFAULT(DVD_WRITE_STRUCT),
  792. IOCTL32_DEFAULT(DVD_AUTH),
  793. /* Big L */
  794. IOCTL32_DEFAULT(LOOP_SET_FD),
  795. IOCTL32_DEFAULT(LOOP_CLR_FD),
  797. /* And these ioctls need translation */
  798. IOCTL32_HANDLER(SIOCGIFNAME, dev_ifname32),
  799. IOCTL32_HANDLER(SIOCGIFCONF, dev_ifconf),
  800. IOCTL32_HANDLER(SIOCGIFFLAGS, dev_ifsioc),
  801. IOCTL32_HANDLER(SIOCSIFFLAGS, dev_ifsioc),
  802. IOCTL32_HANDLER(SIOCGIFMETRIC, dev_ifsioc),
  803. IOCTL32_HANDLER(SIOCSIFMETRIC, dev_ifsioc),
  804. IOCTL32_HANDLER(SIOCGIFMTU, dev_ifsioc),
  805. IOCTL32_HANDLER(SIOCSIFMTU, dev_ifsioc),
  806. IOCTL32_HANDLER(SIOCGIFMEM, dev_ifsioc),
  807. IOCTL32_HANDLER(SIOCSIFMEM, dev_ifsioc),
  808. IOCTL32_HANDLER(SIOCGIFHWADDR, dev_ifsioc),
  809. IOCTL32_HANDLER(SIOCSIFHWADDR, dev_ifsioc),
  810. IOCTL32_HANDLER(SIOCADDMULTI, dev_ifsioc),
  811. IOCTL32_HANDLER(SIOCDELMULTI, dev_ifsioc),
  812. IOCTL32_HANDLER(SIOCGIFINDEX, dev_ifsioc),
  813. IOCTL32_HANDLER(SIOCGIFMAP, dev_ifsioc),
  814. IOCTL32_HANDLER(SIOCSIFMAP, dev_ifsioc),
  815. IOCTL32_HANDLER(SIOCGIFADDR, dev_ifsioc),
  816. IOCTL32_HANDLER(SIOCSIFADDR, dev_ifsioc),
  817. IOCTL32_HANDLER(SIOCGIFBRDADDR, dev_ifsioc),
  818. IOCTL32_HANDLER(SIOCSIFBRDADDR, dev_ifsioc),
  819. IOCTL32_HANDLER(SIOCGIFDSTADDR, dev_ifsioc),
  820. IOCTL32_HANDLER(SIOCSIFDSTADDR, dev_ifsioc),
  821. IOCTL32_HANDLER(SIOCGIFNETMASK, dev_ifsioc),
  822. IOCTL32_HANDLER(SIOCSIFNETMASK, dev_ifsioc),
  823. IOCTL32_HANDLER(SIOCSIFPFLAGS, dev_ifsioc),
  824. IOCTL32_HANDLER(SIOCGIFPFLAGS, dev_ifsioc),
  825. IOCTL32_HANDLER(SIOCGPPPSTATS, dev_ifsioc),
  826. IOCTL32_HANDLER(SIOCGPPPCSTATS, dev_ifsioc),
  827. IOCTL32_HANDLER(SIOCGPPPVER, dev_ifsioc),
  828. IOCTL32_HANDLER(SIOCGIFTXQLEN, dev_ifsioc),
  829. IOCTL32_HANDLER(SIOCSIFTXQLEN, dev_ifsioc),
  830. IOCTL32_HANDLER(SIOCADDRT, routing_ioctl),
  831. IOCTL32_HANDLER(SIOCDELRT, routing_ioctl),
  832. /*
  833.  * Note SIOCRTMSG is no longer, so this is safe and * the user would
  834.  * have seen just an -EINVAL anyways.
  835.  */
  836. IOCTL32_HANDLER(SIOCRTMSG, ret_einval),
  837. IOCTL32_HANDLER(SIOCGSTAMP, do_siocgstamp),
  839. #endif /* CONFIG_NET */
  841. IOCTL32_HANDLER(EXT2_IOC32_GETFLAGS, do_ext2_ioctl),
  842. IOCTL32_HANDLER(EXT2_IOC32_SETFLAGS, do_ext2_ioctl),
  843. IOCTL32_HANDLER(EXT2_IOC32_GETVERSION, do_ext2_ioctl),
  844. IOCTL32_HANDLER(EXT2_IOC32_SETVERSION, do_ext2_ioctl),
  846. IOCTL32_HANDLER(HDIO_GETGEO, hdio_getgeo), /* hdreg.h ioctls  */
  847. IOCTL32_HANDLER(HDIO_GET_UNMASKINTR, hdio_ioctl_trans),
  848. IOCTL32_HANDLER(HDIO_GET_MULTCOUNT, hdio_ioctl_trans),
  849. // HDIO_OBSOLETE_IDENTITY
  850. IOCTL32_HANDLER(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans),
  851. IOCTL32_HANDLER(HDIO_GET_32BIT, hdio_ioctl_trans),
  852. IOCTL32_HANDLER(HDIO_GET_NOWERR, hdio_ioctl_trans),
  853. IOCTL32_HANDLER(HDIO_GET_DMA, hdio_ioctl_trans),
  854. IOCTL32_HANDLER(HDIO_GET_NICE, hdio_ioctl_trans),
  855. IOCTL32_DEFAULT(HDIO_GET_IDENTITY),
  856. IOCTL32_DEFAULT(HDIO_DRIVE_RESET),
  857. // HDIO_TRISTATE_HWIF /* not implemented */
  858. // HDIO_DRIVE_TASK /* To do, need specs */
  859. IOCTL32_DEFAULT(HDIO_DRIVE_CMD),
  860. IOCTL32_DEFAULT(HDIO_SET_MULTCOUNT),
  861. IOCTL32_DEFAULT(HDIO_SET_UNMASKINTR),
  862. IOCTL32_DEFAULT(HDIO_SET_KEEPSETTINGS),
  863. IOCTL32_DEFAULT(HDIO_SET_32BIT),
  864. IOCTL32_DEFAULT(HDIO_SET_NOWERR),
  865. IOCTL32_DEFAULT(HDIO_SET_DMA),
  866. IOCTL32_DEFAULT(HDIO_SET_PIO_MODE),
  867. IOCTL32_DEFAULT(HDIO_SCAN_HWIF),
  868. IOCTL32_DEFAULT(HDIO_SET_NICE),
  869. //HDIO_UNREGISTER_HWIF
  871. IOCTL32_DEFAULT(BLKROSET), /* fs.h ioctls  */
  872. IOCTL32_DEFAULT(BLKROGET),
  873. IOCTL32_DEFAULT(BLKRRPART),
  874. IOCTL32_HANDLER(BLKGETSIZE, w_long),
  876. IOCTL32_DEFAULT(BLKFLSBUF),
  877. IOCTL32_DEFAULT(BLKRASET),
  878. IOCTL32_HANDLER(BLKRAGET, w_long),
  879. IOCTL32_DEFAULT(BLKFRASET),
  880. IOCTL32_HANDLER(BLKFRAGET, w_long),
  881. IOCTL32_DEFAULT(BLKSECTSET),
  882. IOCTL32_HANDLER(BLKSECTGET, w_long),
  883. IOCTL32_DEFAULT(BLKSSZGET),
  884. IOCTL32_HANDLER(BLKPG, blkpg_ioctl_trans),
  885. IOCTL32_DEFAULT(BLKELVGET),
  886. IOCTL32_DEFAULT(BLKELVSET),
  887. IOCTL32_DEFAULT(BLKBSZGET),
  888. IOCTL32_DEFAULT(BLKBSZSET),
  890. #ifdef CONFIG_MD
  891. /* status */
  892. IOCTL32_DEFAULT(RAID_VERSION),
  893. IOCTL32_DEFAULT(GET_ARRAY_INFO),
  894. IOCTL32_DEFAULT(GET_DISK_INFO),
  895. IOCTL32_DEFAULT(PRINT_RAID_DEBUG),
  896. IOCTL32_DEFAULT(RAID_AUTORUN),
  898. /* configuration */
  899. IOCTL32_DEFAULT(CLEAR_ARRAY),
  900. IOCTL32_DEFAULT(ADD_NEW_DISK),
  901. IOCTL32_DEFAULT(HOT_REMOVE_DISK),
  902. IOCTL32_DEFAULT(SET_ARRAY_INFO),
  903. IOCTL32_DEFAULT(SET_DISK_INFO),
  904. IOCTL32_DEFAULT(WRITE_RAID_INFO),
  905. IOCTL32_DEFAULT(UNPROTECT_ARRAY),
  906. IOCTL32_DEFAULT(PROTECT_ARRAY),
  907. IOCTL32_DEFAULT(HOT_ADD_DISK),
  908. IOCTL32_DEFAULT(SET_DISK_FAULTY),
  910. /* usage */
  911. IOCTL32_DEFAULT(RUN_ARRAY),
  912. IOCTL32_DEFAULT(START_ARRAY),
  913. IOCTL32_DEFAULT(STOP_ARRAY),
  914. IOCTL32_DEFAULT(STOP_ARRAY_RO),
  915. IOCTL32_DEFAULT(RESTART_ARRAY_RW),
  916. #endif /* CONFIG_MD */
  918. IOCTL32_DEFAULT(MTIOCTOP), /* mtio.h ioctls  */
  919. IOCTL32_HANDLER(MTIOCGET32, mt_ioctl_trans),
  920. IOCTL32_HANDLER(MTIOCPOS32, mt_ioctl_trans),
  921. IOCTL32_HANDLER(MTIOCGETCONFIG32, mt_ioctl_trans),
  922. IOCTL32_HANDLER(MTIOCSETCONFIG32, mt_ioctl_trans),
  923. // MTIOCRDFTSEG
  924. // MTIOCWRFTSEG
  925. // MTIOCVOLINFO
  926. // MTIOCGETSIZE
  927. // MTIOCFTFORMAT
  928. // MTIOCFTCMD
  930. IOCTL32_DEFAULT(AUTOFS_IOC_READY), /* auto_fs.h ioctls */
  931. IOCTL32_DEFAULT(AUTOFS_IOC_FAIL),
  932. IOCTL32_DEFAULT(AUTOFS_IOC_CATATONIC),
  933. IOCTL32_DEFAULT(AUTOFS_IOC_PROTOVER),
  934. IOCTL32_HANDLER(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout),
  935. IOCTL32_DEFAULT(AUTOFS_IOC_EXPIRE),
  937. /* Little p (/dev/rtc, /dev/envctrl, etc.) */
  938. IOCTL32_DEFAULT(_IOR('p', 20, int[7])), /* RTCGET */
  939. IOCTL32_DEFAULT(_IOW('p', 21, int[7])), /* RTCSET */
  940. IOCTL32_DEFAULT(RTC_AIE_ON),
  941. IOCTL32_DEFAULT(RTC_AIE_OFF),
  942. IOCTL32_DEFAULT(RTC_UIE_ON),
  943. IOCTL32_DEFAULT(RTC_UIE_OFF),
  944. IOCTL32_DEFAULT(RTC_PIE_ON),
  945. IOCTL32_DEFAULT(RTC_PIE_OFF),
  946. IOCTL32_DEFAULT(RTC_WIE_ON),
  947. IOCTL32_DEFAULT(RTC_WIE_OFF),
  948. IOCTL32_DEFAULT(RTC_ALM_SET),
  949. IOCTL32_DEFAULT(RTC_ALM_READ),
  950. IOCTL32_DEFAULT(RTC_RD_TIME),
  951. IOCTL32_DEFAULT(RTC_SET_TIME),
  952. IOCTL32_DEFAULT(RTC_WKALM_SET),
  953. IOCTL32_DEFAULT(RTC_WKALM_RD)
  954. };
  956. #define NR_IOCTL32_HANDLERS (sizeof(ioctl32_handler_table) /
  957.  sizeof(ioctl32_handler_table[0]))
  959. static struct ioctl32_list *ioctl32_hash_table[1024];
  961. static inline int ioctl32_hash(unsigned int cmd)
  962. {
  963. return ((cmd >> 6) ^ (cmd >> 4) ^ cmd) & 0x3ff;
  964. }
  966. int sys32_ioctl(unsigned int fd, unsigned int cmd, unsigned int arg)
  967. {
  968. int (*handler)(unsigned int, unsigned int, unsigned long, struct file * filp);
  969. struct file *filp;
  970. struct ioctl32_list *l;
  971. int error;
  973. l = ioctl32_hash_table[ioctl32_hash(cmd)];
  975. error = -EBADF;
  977. filp = fget(fd);
  978. if (!filp)
  979. return error;
  981. if (!filp->f_op || !filp->f_op->ioctl) {
  982. error = sys_ioctl (fd, cmd, arg);
  983. goto out;
  984. }
  986. while (l && l->handler.cmd != cmd)
  987. l = l->next;
  989. if (l) {
  990. handler = (void *)l->handler.function;
  991. error = handler(fd, cmd, arg, filp);
  992. } else {
  993. error = -EINVAL;
  994. printk("unknown ioctl: %08xn", cmd);
  995. }
  996. out:
  997. fput(filp);
  998. return error;
  999. }
  1001. static void ioctl32_insert(struct ioctl32_list *entry)
  1002. {
  1003. int hash = ioctl32_hash(entry->handler.cmd);
  1004. if (!ioctl32_hash_table[hash])
  1005. ioctl32_hash_table[hash] = entry;
  1006. else {
  1007. struct ioctl32_list *l;
  1008. l = ioctl32_hash_table[hash];
  1009. while (l->next)
  1010. l = l->next;
  1011. l->next = entry;
  1012. entry->next = 0;
  1013. }
  1014. }
  1016. static int __init init_ioctl32(void)
  1017. {
  1018. int i;
  1019. for (i = 0; i < NR_IOCTL32_HANDLERS; i++)
  1020. ioctl32_insert(&ioctl32_handler_table[i]);
  1021. return 0;
  1022. }
  1024. __initcall(init_ioctl32);