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

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

Linux/Unix编程

开发平台：

Unix_Linux

ioctl.c：源码内容
  1. /* $Id: ioctl.c,v 1.16.2.1 2002/03/03 23:41:26 davem Exp $
  2.  * ioctl.c: Solaris ioctl emulation.
  3.  *
  4.  * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  5.  * Copyright (C) 1997,1998 Patrik Rak (prak3264@ss1000.ms.mff.cuni.cz)
  6.  *
  7.  * Streams & timod emulation based on code
  8.  * Copyright (C) 1995, 1996 Mike Jagdis (jaggy@purplet.demon.co.uk)
  9.  *
  10.  * 1999-08-19 Implemented solaris 'm' (mag tape) and
  11.  *            'O' (openprom) ioctls, by Jason Rappleye
  12.  *             (rappleye@ccr.buffalo.edu)
  13.  */
  15. #include <linux/types.h>
  16. #include <linux/kernel.h>
  17. #include <linux/sched.h>
  18. #include <linux/smp.h>
  19. #include <linux/smp_lock.h>
  20. #include <linux/ioctl.h>
  21. #include <linux/fs.h>
  22. #include <linux/file.h>
  23. #include <linux/netdevice.h>
  24. #include <linux/mtio.h>
  25. #include <linux/time.h>
  27. #include <asm/uaccess.h>
  28. #include <asm/termios.h>
  29. #include <asm/openpromio.h>
  31. #include "conv.h"
  32. #include "socksys.h"
  34. extern asmlinkage int sys_ioctl(unsigned int fd, unsigned int cmd, 
  35. unsigned long arg);
  36. extern asmlinkage int sys32_ioctl(unsigned int fd, unsigned int cmd,
  37. u32 arg);
  38. asmlinkage int solaris_ioctl(unsigned int fd, unsigned int cmd, u32 arg);
  40. extern int timod_putmsg(unsigned int fd, char *ctl_buf, int ctl_len,
  41. char *data_buf, int data_len, int flags);
  42. extern int timod_getmsg(unsigned int fd, char *ctl_buf, int ctl_maxlen, int *ctl_len,
  43. char *data_buf, int data_maxlen, int *data_len, int *flags);
  45. /* termio* stuff {{{ */
  47. struct solaris_termios {
  48. u32 c_iflag;
  49. u32 c_oflag;
  50. u32 c_cflag;
  51. u32 c_lflag;
  52. u8 c_cc[19];
  53. };
  55. struct solaris_termio {
  56. u16 c_iflag;
  57. u16 c_oflag;
  58. u16 c_cflag;
  59. u16 c_lflag;
  60. s8 c_line;
  61. u8 c_cc[8];
  62. };
  64. struct solaris_termiox {
  65. u16 x_hflag;
  66. u16 x_cflag;
  67. u16 x_rflag[5];
  68. u16 x_sflag;
  69. };
  71. static u32 solaris_to_linux_cflag(u32 cflag)
  72. {
  73. cflag &= 0x7fdff000;
  74. if (cflag & 0x200000) {
  75. int baud = cflag & 0xf;
  76. cflag &= ~0x20000f;
  77. switch (baud) {
  78. case 0: baud = B57600; break;
  79. case 1: baud = B76800; break;
  80. case 2: baud = B115200; break;
  81. case 3: baud = B153600; break;
  82. case 4: baud = B230400; break;
  83. case 5: baud = B307200; break;
  84. case 6: baud = B460800; break;
  85. }
  86. cflag |= CBAUDEX | baud;
  87. }
  88. return cflag;
  89. }
  91. static u32 linux_to_solaris_cflag(u32 cflag)
  92. {
  93. cflag &= ~(CMSPAR | CIBAUD);
  94. if (cflag & CBAUDEX) {
  95. int baud = cflag & CBAUD;
  96. cflag &= ~CBAUD;
  97. switch (baud) {
  98. case B57600: baud = 0; break;
  99. case B76800: baud = 1; break;
  100. case B115200: baud = 2; break;
  101. case B153600: baud = 3; break;
  102. case B230400: baud = 4; break;
  103. case B307200: baud = 5; break;
  104. case B460800: baud = 6; break;
  105. case B614400: baud = 7; break;
  106. case B921600: baud = 8; break;
  107. #if 0
  108. case B1843200: baud = 9; break;
  109. #endif
  110. }
  111. cflag |= 0x200000 | baud;
  112. }
  113. return cflag;
  114. }
  116. static inline int linux_to_solaris_termio(unsigned int fd, unsigned int cmd, u32 arg)
  117. {
  118. int ret;
  120. ret = sys_ioctl(fd, cmd, A(arg));
  121. if (!ret) {
  122. u32 cflag;
  124. if (__get_user (cflag, &((struct solaris_termio *)A(arg))->c_cflag))
  125. return -EFAULT;
  126. cflag = linux_to_solaris_cflag(cflag);
  127. if (__put_user (cflag, &((struct solaris_termio *)A(arg))->c_cflag))
  128. return -EFAULT;
  129. }
  130. return ret;
  131. }
  133. static int solaris_to_linux_termio(unsigned int fd, unsigned int cmd, u32 arg)
  134. {
  135. int ret;
  136. struct solaris_termio s;
  137. mm_segment_t old_fs = get_fs();
  139. if (copy_from_user (&s, (struct solaris_termio *)A(arg), sizeof(struct solaris_termio)))
  140. return -EFAULT;
  141. s.c_cflag = solaris_to_linux_cflag(s.c_cflag);
  142. set_fs(KERNEL_DS);
  143. ret = sys_ioctl(fd, cmd, (unsigned long)&s);
  144. set_fs(old_fs);
  145. return ret;
  146. }
  148. static inline int linux_to_solaris_termios(unsigned int fd, unsigned int cmd, u32 arg)
  149. {
  150. int ret;
  151. struct solaris_termios s;
  152. mm_segment_t old_fs = get_fs();
  154. set_fs(KERNEL_DS);
  155. ret = sys_ioctl(fd, cmd, (unsigned long)&s);
  156. set_fs(old_fs);
  157. if (!ret) {
  158. if (put_user (s.c_iflag, &((struct solaris_termios *)A(arg))->c_iflag) ||
  159.     __put_user (s.c_oflag, &((struct solaris_termios *)A(arg))->c_oflag) ||
  160.     __put_user (linux_to_solaris_cflag(s.c_cflag), &((struct solaris_termios *)A(arg))->c_cflag) ||
  161.     __put_user (s.c_lflag, &((struct solaris_termios *)A(arg))->c_lflag) ||
  162.     __copy_to_user (((struct solaris_termios *)A(arg))->c_cc, s.c_cc, 16) ||
  163.     __clear_user (((struct solaris_termios *)A(arg))->c_cc + 16, 2))
  164. return -EFAULT;
  165. }
  166. return ret;
  167. }
  169. static int solaris_to_linux_termios(unsigned int fd, unsigned int cmd, u32 arg)
  170. {
  171. int ret;
  172. struct solaris_termios s;
  173. mm_segment_t old_fs = get_fs();
  175. set_fs(KERNEL_DS);
  176. ret = sys_ioctl(fd, TCGETS, (unsigned long)&s);
  177. set_fs(old_fs);
  178. if (ret) return ret;
  179. if (put_user (s.c_iflag, &((struct solaris_termios *)A(arg))->c_iflag) ||
  180.     __put_user (s.c_oflag, &((struct solaris_termios *)A(arg))->c_oflag) ||
  181.     __put_user (s.c_cflag, &((struct solaris_termios *)A(arg))->c_cflag) ||
  182.     __put_user (s.c_lflag, &((struct solaris_termios *)A(arg))->c_lflag) ||
  183.     __copy_from_user (s.c_cc, ((struct solaris_termios *)A(arg))->c_cc, 16))
  184. return -EFAULT;
  185. s.c_cflag = solaris_to_linux_cflag(s.c_cflag);
  186. set_fs(KERNEL_DS);
  187. ret = sys_ioctl(fd, cmd, (unsigned long)&s);
  188. set_fs(old_fs);
  189. return ret;
  190. }
  192. static inline int solaris_T(unsigned int fd, unsigned int cmd, u32 arg)
  193. {
  194. switch (cmd & 0xff) {
  195. case 1: /* TCGETA */
  196. return linux_to_solaris_termio(fd, TCGETA, arg);
  197. case 2: /* TCSETA */
  198. return solaris_to_linux_termio(fd, TCSETA, arg);
  199. case 3: /* TCSETAW */
  200. return solaris_to_linux_termio(fd, TCSETAW, arg);
  201. case 4: /* TCSETAF */
  202. return solaris_to_linux_termio(fd, TCSETAF, arg);
  203. case 5: /* TCSBRK */
  204. return sys_ioctl(fd, TCSBRK, arg);
  205. case 6: /* TCXONC */
  206. return sys_ioctl(fd, TCXONC, arg);
  207. case 7: /* TCFLSH */
  208. return sys_ioctl(fd, TCFLSH, arg);
  209. case 13: /* TCGETS */
  210. return linux_to_solaris_termios(fd, TCGETS, arg);
  211. case 14: /* TCSETS */
  212. return solaris_to_linux_termios(fd, TCSETS, arg);
  213. case 15: /* TCSETSW */
  214. return solaris_to_linux_termios(fd, TCSETSW, arg);
  215. case 16: /* TCSETSF */
  216. return solaris_to_linux_termios(fd, TCSETSF, arg);
  217. case 103: /* TIOCSWINSZ */
  218. return sys_ioctl(fd, TIOCSWINSZ, arg);
  219. case 104: /* TIOCGWINSZ */
  220. return sys_ioctl(fd, TIOCGWINSZ, arg);
  221. }
  222. return -ENOSYS;
  223. }
  225. static inline int solaris_t(unsigned int fd, unsigned int cmd, u32 arg)
  226. {
  227. switch (cmd & 0xff) {
  228. case 20: /* TIOCGPGRP */
  229. return sys_ioctl(fd, TIOCGPGRP, arg);
  230. case 21: /* TIOCSPGRP */
  231. return sys_ioctl(fd, TIOCSPGRP, arg);
  232. }
  233. return -ENOSYS;
  234. }
  236. /* }}} */
  238. /* A pseudo STREAMS support {{{ */
  240. struct strioctl {
  241. int cmd, timeout, len;
  242. u32 data;
  243. };
  245. struct solaris_si_sockparams {
  246. int sp_family;
  247. int sp_type;
  248. int sp_protocol;
  249. };
  251. struct solaris_o_si_udata {
  252. int tidusize;
  253. int addrsize;
  254. int optsize;
  255. int etsdusize;
  256. int servtype;
  257. int so_state;
  258. int so_options;
  259. int tsdusize;
  260. };
  262. struct solaris_si_udata {
  263. int tidusize;
  264. int addrsize;
  265. int optsize;
  266. int etsdusize;
  267. int servtype;
  268. int so_state;
  269. int so_options;
  270. int tsdusize;
  271. struct solaris_si_sockparams sockparams;
  272. };
  274. #define SOLARIS_MODULE_TIMOD    0
  275. #define SOLARIS_MODULE_SOCKMOD  1
  276. #define SOLARIS_MODULE_MAX      2
  278. static struct module_info {
  279.         const char *name;
  280.         /* can be expanded further if needed */
  281. } module_table[ SOLARIS_MODULE_MAX + 1 ] = {
  282.         /* the ordering here must match the module numbers above! */
  283.         { "timod" },
  284.         { "sockmod" },
  285.         { NULL }
  286. };
  288. static inline int solaris_sockmod(unsigned int fd, unsigned int cmd, u32 arg)
  289. {
  290. struct inode *ino;
  291. /* I wonder which of these tests are superfluous... --patrik */
  292. read_lock(&current->files->file_lock);
  293. if (! current->files->fd[fd] ||
  294.     ! current->files->fd[fd]->f_dentry ||
  295.     ! (ino = current->files->fd[fd]->f_dentry->d_inode) ||
  296.     ! ino->i_sock) {
  297. read_unlock(&current->files->file_lock);
  298. return TBADF;
  299. }
  300. read_unlock(&current->files->file_lock);
  302. switch (cmd & 0xff) {
  303. case 109: /* SI_SOCKPARAMS */
  304. {
  305. struct solaris_si_sockparams si;
  306. if (copy_from_user (&si, (struct solaris_si_sockparams *) A(arg), sizeof(si)))
  307. return (EFAULT << 8) | TSYSERR;
  309. /* Should we modify socket ino->socket_i.ops and type? */
  310. return 0;
  311. }
  312. case 110: /* SI_GETUDATA */
  313. {
  314. int etsdusize, servtype;
  315. switch (ino->u.socket_i.type) {
  316. case SOCK_STREAM:
  317. etsdusize = 1;
  318. servtype = 2;
  319. break;
  320. default:
  321. etsdusize = -2;
  322. servtype = 3;
  323. break;
  324. }
  325. if (put_user(16384, &((struct solaris_si_udata *)A(arg))->tidusize) ||
  326.     __put_user(sizeof(struct sockaddr), &((struct solaris_si_udata *)A(arg))->addrsize) ||
  327.     __put_user(-1, &((struct solaris_si_udata *)A(arg))->optsize) ||
  328.     __put_user(etsdusize, &((struct solaris_si_udata *)A(arg))->etsdusize) ||
  329.     __put_user(servtype, &((struct solaris_si_udata *)A(arg))->servtype) ||
  330.     __put_user(0, &((struct solaris_si_udata *)A(arg))->so_state) ||
  331.     __put_user(0, &((struct solaris_si_udata *)A(arg))->so_options) ||
  332.     __put_user(16384, &((struct solaris_si_udata *)A(arg))->tsdusize) ||
  333.     __put_user(ino->u.socket_i.ops->family, &((struct solaris_si_udata *)A(arg))->sockparams.sp_family) ||
  334.     __put_user(ino->u.socket_i.type, &((struct solaris_si_udata *)A(arg))->sockparams.sp_type) ||
  335.     __put_user(ino->u.socket_i.ops->family, &((struct solaris_si_udata *)A(arg))->sockparams.sp_protocol))
  336. return (EFAULT << 8) | TSYSERR;
  337. return 0;
  338. }
  339. case 101: /* O_SI_GETUDATA */
  340. {
  341. int etsdusize, servtype;
  342. switch (ino->u.socket_i.type) {
  343. case SOCK_STREAM:
  344. etsdusize = 1;
  345. servtype = 2;
  346. break;
  347. default:
  348. etsdusize = -2;
  349. servtype = 3;
  350. break;
  351. }
  352. if (put_user(16384, &((struct solaris_o_si_udata *)A(arg))->tidusize) ||
  353.     __put_user(sizeof(struct sockaddr), &((struct solaris_o_si_udata *)A(arg))->addrsize) ||
  354.     __put_user(-1, &((struct solaris_o_si_udata *)A(arg))->optsize) ||
  355.     __put_user(etsdusize, &((struct solaris_o_si_udata *)A(arg))->etsdusize) ||
  356.     __put_user(servtype, &((struct solaris_o_si_udata *)A(arg))->servtype) ||
  357.     __put_user(0, &((struct solaris_o_si_udata *)A(arg))->so_state) ||
  358.     __put_user(0, &((struct solaris_o_si_udata *)A(arg))->so_options) ||
  359.     __put_user(16384, &((struct solaris_o_si_udata *)A(arg))->tsdusize))
  360. return (EFAULT << 8) | TSYSERR;
  361. return 0;
  362. }
  363. case 102: /* SI_SHUTDOWN */
  364. case 103: /* SI_LISTEN */
  365. case 104: /* SI_SETMYNAME */
  366. case 105: /* SI_SETPEERNAME */
  367. case 106: /* SI_GETINTRANSIT */
  368. case 107: /* SI_TCL_LINK */
  369. case 108: /* SI_TCL_UNLINK */
  370. }
  371. return TNOTSUPPORT;
  372. }
  374. static inline int solaris_timod(unsigned int fd, unsigned int cmd, u32 arg,
  375.                                     int len, int *len_p)
  376. {
  377. int ret;
  379. switch (cmd & 0xff) {
  380. case 141: /* TI_OPTMGMT */
  381. {
  382. int i;
  383. u32 prim;
  384. SOLD("TI_OPMGMT entry");
  385. ret = timod_putmsg(fd, (char *)A(arg), len, NULL, -1, 0);
  386. SOLD("timod_putmsg() returned");
  387. if (ret)
  388. return (-ret << 8) | TSYSERR;
  389. i = MSG_HIPRI;
  390. SOLD("calling timod_getmsg()");
  391. ret = timod_getmsg(fd, (char *)A(arg), len, len_p, NULL, -1, NULL, &i);
  392. SOLD("timod_getmsg() returned");
  393. if (ret)
  394. return (-ret << 8) | TSYSERR;
  395. SOLD("ret ok");
  396. if (get_user(prim, (u32 *)A(arg)))
  397. return (EFAULT << 8) | TSYSERR;
  398. SOLD("got prim");
  399. if (prim == T_ERROR_ACK) {
  400. u32 tmp, tmp2;
  401. SOLD("prim is T_ERROR_ACK");
  402. if (get_user(tmp, (u32 *)A(arg)+3) ||
  403.     get_user(tmp2, (u32 *)A(arg)+2))
  404. return (EFAULT << 8) | TSYSERR;
  405. return (tmp2 << 8) | tmp;
  406. }
  407. SOLD("TI_OPMGMT return 0");
  408. return 0;
  409. }
  410. case 142: /* TI_BIND */
  411. {
  412. int i;
  413. u32 prim;
  414. SOLD("TI_BIND entry");
  415. ret = timod_putmsg(fd, (char *)A(arg), len, NULL, -1, 0);
  416. SOLD("timod_putmsg() returned");
  417. if (ret)
  418. return (-ret << 8) | TSYSERR;
  419. len = 1024; /* Solaris allows arbitrary return size */
  420. i = MSG_HIPRI;
  421. SOLD("calling timod_getmsg()");
  422. ret = timod_getmsg(fd, (char *)A(arg), len, len_p, NULL, -1, NULL, &i);
  423. SOLD("timod_getmsg() returned");
  424. if (ret)
  425. return (-ret << 8) | TSYSERR;
  426. SOLD("ret ok");
  427. if (get_user(prim, (u32 *)A(arg)))
  428. return (EFAULT << 8) | TSYSERR;
  429. SOLD("got prim");
  430. if (prim == T_ERROR_ACK) {
  431. u32 tmp, tmp2;
  432. SOLD("prim is T_ERROR_ACK");
  433. if (get_user(tmp, (u32 *)A(arg)+3) ||
  434.     get_user(tmp2, (u32 *)A(arg)+2))
  435. return (EFAULT << 8) | TSYSERR;
  436. return (tmp2 << 8) | tmp;
  437. }
  438. SOLD("no ERROR_ACK requested");
  439. if (prim != T_OK_ACK)
  440. return TBADSEQ;
  441. SOLD("OK_ACK requested");
  442. i = MSG_HIPRI;
  443. SOLD("calling timod_getmsg()");
  444. ret = timod_getmsg(fd, (char *)A(arg), len, len_p, NULL, -1, NULL, &i);
  445. SOLD("timod_getmsg() returned");
  446. if (ret)
  447. return (-ret << 8) | TSYSERR;
  448. SOLD("TI_BIND return ok");
  449. return 0;
  450. }
  451. case 140: /* TI_GETINFO */
  452. case 143: /* TI_UNBIND */
  453. case 144: /* TI_GETMYNAME */
  454. case 145: /* TI_GETPEERNAME */
  455. case 146: /* TI_SETMYNAME */
  456. case 147: /* TI_SETPEERNAME */
  457. }
  458. return TNOTSUPPORT;
  459. }
  461. static inline int solaris_S(struct file *filp, unsigned int fd, unsigned int cmd, u32 arg)
  462. {
  463. char *p;
  464. int ret;
  465. mm_segment_t old_fs;
  466. struct strioctl si;
  467. struct inode *ino;
  468.         struct sol_socket_struct *sock;
  469.         struct module_info *mi;
  471.         ino = filp->f_dentry->d_inode;
  472.         if (! ino->i_sock)
  473. return -EBADF;
  474.         sock = filp->private_data;
  475.         if (! sock) {
  476.                 printk("solaris_S: NULL private_datan");
  477.                 return -EBADF;
  478.         }
  479.         if (sock->magic != SOLARIS_SOCKET_MAGIC) {
  480.                 printk("solaris_S: invalid magicn");
  481.                 return -EBADF;
  482.         }
  483.         
  485. switch (cmd & 0xff) {
  486. case 1: /* I_NREAD */
  487. return -ENOSYS;
  488. case 2: /* I_PUSH */
  489.         {
  490. p = getname ((char *)A(arg));
  491. if (IS_ERR (p))
  492. return PTR_ERR(p);
  493.                 ret = -EINVAL;
  494.                 for (mi = module_table; mi->name; mi++) {
  495.                         if (strcmp(mi->name, p) == 0) {
  496.                                 sol_module m;
  497.                                 if (sock->modcount >= MAX_NR_STREAM_MODULES) {
  498.                                         ret = -ENXIO;
  499.                                         break;
  500.                                 }
  501.                                 m = (sol_module) (mi - module_table);
  502.                                 sock->module[sock->modcount++] = m;
  503.                                 ret = 0;
  504.                                 break;
  505.                         }
  506.                 }
  507. putname (p);
  508. return ret;
  509.         }
  510. case 3: /* I_POP */
  511.                 if (sock->modcount <= 0) return -EINVAL;
  512.                 sock->modcount--;
  513. return 0;
  514.         case 4: /* I_LOOK */
  515.         {
  516.          const char *p;
  517.                 if (sock->modcount <= 0) return -EINVAL;
  518.                 p = module_table[(unsigned)sock->module[sock->modcount]].name;
  519.                 if (copy_to_user ((char *)A(arg), p, strlen(p)))
  520.                  return -EFAULT;
  521.                 return 0;
  522.         }
  523. case 5: /* I_FLUSH */
  524. return 0;
  525. case 8: /* I_STR */
  526. if (copy_from_user(&si, (struct strioctl *)A(arg), sizeof(struct strioctl)))
  527. return -EFAULT;
  528.                 /* We ignore what module is actually at the top of stack. */
  529. switch ((si.cmd >> 8) & 0xff) {
  530. case 'I':
  531.                         return solaris_sockmod(fd, si.cmd, si.data);
  532. case 'T':
  533.                         return solaris_timod(fd, si.cmd, si.data, si.len,
  534.                                                 &((struct strioctl*)A(arg))->len);
  535. default:
  536. return solaris_ioctl(fd, si.cmd, si.data);
  537. }
  538. case 9: /* I_SETSIG */
  539. return sys_ioctl(fd, FIOSETOWN, current->pid);
  540. case 10: /* I_GETSIG */
  541. old_fs = get_fs();
  542. set_fs(KERNEL_DS);
  543. sys_ioctl(fd, FIOGETOWN, (unsigned long)&ret);
  544. set_fs(old_fs);
  545. if (ret == current->pid) return 0x3ff;
  546. else return -EINVAL;
  547. case 11: /* I_FIND */
  548.         {
  549.                 int i;
  550. p = getname ((char *)A(arg));
  551. if (IS_ERR (p))
  552. return PTR_ERR(p);
  553.                 ret = 0;
  554.                 for (i = 0; i < sock->modcount; i++) {
  555.                         unsigned m = sock->module[i];
  556.                         if (strcmp(module_table[m].name, p) == 0) {
  557.                                 ret = 1;
  558.                                 break;
  559.                         } 
  560.                 }
  561. putname (p);
  562. return ret;
  563.         }
  564. case 19: /* I_SWROPT */
  565. case 32: /* I_SETCLTIME */
  566. return 0; /* Lie */
  567. }
  568. return -ENOSYS;
  569. }
  571. static inline int solaris_s(unsigned int fd, unsigned int cmd, u32 arg)
  572. {
  573. switch (cmd & 0xff) {
  574. case 0: /* SIOCSHIWAT */
  575. case 2: /* SIOCSLOWAT */
  576. return 0; /* We don't support them */
  577. case 1: /* SIOCGHIWAT */
  578. case 3: /* SIOCGLOWAT */
  579. if (put_user (0, (u32 *)A(arg)))
  580. return -EFAULT;
  581. return 0; /* Lie */
  582. case 7: /* SIOCATMARK */
  583. return sys_ioctl(fd, SIOCATMARK, arg);
  584. case 8: /* SIOCSPGRP */
  585. return sys_ioctl(fd, SIOCSPGRP, arg);
  586. case 9: /* SIOCGPGRP */
  587. return sys_ioctl(fd, SIOCGPGRP, arg);
  588. }
  589. return -ENOSYS;
  590. }
  592. static inline int solaris_r(unsigned int fd, unsigned int cmd, u32 arg)
  593. {
  594. switch (cmd & 0xff) {
  595. case 10: /* SIOCADDRT */
  596. return sys32_ioctl(fd, SIOCADDRT, arg);
  597. case 11: /* SIOCDELRT */
  598. return sys32_ioctl(fd, SIOCDELRT, arg);
  599. }
  600. return -ENOSYS;
  601. }
  603. static inline int solaris_i(unsigned int fd, unsigned int cmd, u32 arg)
  604. {
  605. switch (cmd & 0xff) {
  606. case 12: /* SIOCSIFADDR */
  607. return sys32_ioctl(fd, SIOCSIFADDR, arg);
  608. case 13: /* SIOCGIFADDR */
  609. return sys32_ioctl(fd, SIOCGIFADDR, arg);
  610. case 14: /* SIOCSIFDSTADDR */
  611. return sys32_ioctl(fd, SIOCSIFDSTADDR, arg);
  612. case 15: /* SIOCGIFDSTADDR */
  613. return sys32_ioctl(fd, SIOCGIFDSTADDR, arg);
  614. case 16: /* SIOCSIFFLAGS */
  615. return sys32_ioctl(fd, SIOCSIFFLAGS, arg);
  616. case 17: /* SIOCGIFFLAGS */
  617. return sys32_ioctl(fd, SIOCGIFFLAGS, arg);
  618. case 18: /* SIOCSIFMEM */
  619. return sys32_ioctl(fd, SIOCSIFMEM, arg);
  620. case 19: /* SIOCGIFMEM */
  621. return sys32_ioctl(fd, SIOCGIFMEM, arg);
  622. case 20: /* SIOCGIFCONF */
  623. return sys32_ioctl(fd, SIOCGIFCONF, arg);
  624. case 21: /* SIOCSIFMTU */
  625. return sys32_ioctl(fd, SIOCSIFMTU, arg);
  626. case 22: /* SIOCGIFMTU */
  627. return sys32_ioctl(fd, SIOCGIFMTU, arg);
  628. case 23: /* SIOCGIFBRDADDR */
  629. return sys32_ioctl(fd, SIOCGIFBRDADDR, arg);
  630. case 24: /* SIOCSIFBRDADDR */
  631. return sys32_ioctl(fd, SIOCSIFBRDADDR, arg);
  632. case 25: /* SIOCGIFNETMASK */
  633. return sys32_ioctl(fd, SIOCGIFNETMASK, arg);
  634. case 26: /* SIOCSIFNETMASK */
  635. return sys32_ioctl(fd, SIOCSIFNETMASK, arg);
  636. case 27: /* SIOCGIFMETRIC */
  637. return sys32_ioctl(fd, SIOCGIFMETRIC, arg);
  638. case 28: /* SIOCSIFMETRIC */
  639. return sys32_ioctl(fd, SIOCSIFMETRIC, arg);
  640. case 30: /* SIOCSARP */
  641. return sys32_ioctl(fd, SIOCSARP, arg);
  642. case 31: /* SIOCGARP */
  643. return sys32_ioctl(fd, SIOCGARP, arg);
  644. case 32: /* SIOCDARP */
  645. return sys32_ioctl(fd, SIOCDARP, arg);
  646. case 52: /* SIOCGETNAME */
  647. case 53: /* SIOCGETPEER */
  648. {
  649. struct sockaddr uaddr;
  650. int uaddr_len = sizeof(struct sockaddr), ret;
  651. long args[3];
  652. mm_segment_t old_fs = get_fs();
  653. int (*sys_socketcall)(int, unsigned long *) =
  654. (int (*)(int, unsigned long *))SYS(socketcall);
  656. args[0] = fd; args[1] = (long)&uaddr; args[2] = (long)&uaddr_len;
  657. set_fs(KERNEL_DS);
  658. ret = sys_socketcall(((cmd & 0xff) == 52) ? SYS_GETSOCKNAME : SYS_GETPEERNAME,
  659. args);
  660. set_fs(old_fs);
  661. if (ret >= 0) {
  662. if (copy_to_user((char *)A(arg), &uaddr, uaddr_len))
  663. return -EFAULT;
  664. }
  665. return ret;
  666. }
  667. #if 0
  668. case 86: /* SIOCSOCKSYS */
  669. return socksys_syscall(fd, arg);
  670. #endif
  671. case 87: /* SIOCGIFNUM */
  672. {
  673. struct net_device *d;
  674. int i = 0;
  676. read_lock_bh(&dev_base_lock);
  677. for (d = dev_base; d; d = d->next) i++;
  678. read_unlock_bh(&dev_base_lock);
  680. if (put_user (i, (int *)A(arg)))
  681. return -EFAULT;
  682. return 0;
  683. }
  684. }
  685. return -ENOSYS;
  686. }
  688. static int solaris_m(unsigned int fd, unsigned int cmd, u32 arg)
  689. {
  690. int ret;
  692. switch (cmd & 0xff) {
  693. case 1: /* MTIOCTOP */
  694. ret = sys_ioctl(fd, MTIOCTOP, (unsigned long)&arg);
  695. break;
  696. case 2: /* MTIOCGET */
  697. ret = sys_ioctl(fd, MTIOCGET, (unsigned long)&arg);
  698. break;
  699. case 3: /* MTIOCGETDRIVETYPE */
  700. case 4: /* MTIOCPERSISTENT */
  701. case 5: /* MTIOCPERSISTENTSTATUS */
  702. case 6: /* MTIOCLRERR */
  703. case 7: /* MTIOCGUARANTEEDORDER */
  704. case 8: /* MTIOCRESERVE */
  705. case 9: /* MTIOCRELEASE */
  706. case 10: /* MTIOCFORCERESERVE */
  707. case 13: /* MTIOCSTATE */
  708. case 14: /* MTIOCREADIGNOREILI */
  709. case 15: /* MTIOCREADIGNOREEOFS */
  710. case 16: /* MTIOCSHORTFMK */
  711. default:
  712. ret = -ENOSYS; /* linux doesn't support these */
  713. break;
  714. };
  716. return ret;
  717. }
  719. static int solaris_O(unsigned int fd, unsigned int cmd, u32 arg)
  720. {
  721. int ret = -EINVAL;
  723. switch (cmd & 0xff) {
  724. case 1: /* OPROMGETOPT */
  725. ret = sys_ioctl(fd, OPROMGETOPT, arg);
  726. break;
  727. case 2: /* OPROMSETOPT */
  728. ret = sys_ioctl(fd, OPROMSETOPT, arg);
  729. break;
  730. case 3: /* OPROMNXTOPT */
  731. ret = sys_ioctl(fd, OPROMNXTOPT, arg);
  732. break;
  733. case 4: /* OPROMSETOPT2 */
  734. ret = sys_ioctl(fd, OPROMSETOPT2, arg);
  735. break;
  736. case 5: /* OPROMNEXT */
  737. ret = sys_ioctl(fd, OPROMNEXT, arg);
  738. break;
  739. case 6: /* OPROMCHILD */
  740. ret = sys_ioctl(fd, OPROMCHILD, arg);
  741. break;
  742. case 7: /* OPROMGETPROP */
  743. ret = sys_ioctl(fd, OPROMGETPROP, arg);
  744. break;
  745. case 8: /* OPROMNXTPROP */
  746. ret = sys_ioctl(fd, OPROMNXTPROP, arg);
  747. break;
  748. case 9: /* OPROMU2P */
  749. ret = sys_ioctl(fd, OPROMU2P, arg);
  750. break;
  751. case 10: /* OPROMGETCONS */
  752. ret = sys_ioctl(fd, OPROMGETCONS, arg);
  753. break;
  754. case 11: /* OPROMGETFBNAME */
  755. ret = sys_ioctl(fd, OPROMGETFBNAME, arg);
  756. break;
  757. case 12: /* OPROMGETBOOTARGS */
  758. ret = sys_ioctl(fd, OPROMGETBOOTARGS, arg);
  759. break;
  760. case 13: /* OPROMGETVERSION */
  761. case 14: /* OPROMPATH2DRV */
  762. case 15: /* OPROMDEV2PROMNAME */
  763. case 16: /* OPROMPROM2DEVNAME */
  764. case 17: /* OPROMGETPROPLEN */
  765. default:
  766. ret = -EINVAL;
  767. break;
  768. };
  769. return ret;
  770. }
  772. /* }}} */
  774. asmlinkage int solaris_ioctl(unsigned int fd, unsigned int cmd, u32 arg)
  775. {
  776. struct file *filp;
  777. int error = -EBADF;
  779. filp = fget(fd);
  780. if (!filp)
  781. goto out;
  783. lock_kernel();
  784. error = -EFAULT;
  785. switch ((cmd >> 8) & 0xff) {
  786. case 'S': error = solaris_S(filp, fd, cmd, arg); break;
  787. case 'T': error = solaris_T(fd, cmd, arg); break;
  788. case 'i': error = solaris_i(fd, cmd, arg); break;
  789. case 'r': error = solaris_r(fd, cmd, arg); break;
  790. case 's': error = solaris_s(fd, cmd, arg); break;
  791. case 't': error = solaris_t(fd, cmd, arg); break;
  792. case 'f': error = sys_ioctl(fd, cmd, arg); break;
  793. case 'm': error = solaris_m(fd, cmd, arg); break;
  794. case 'O': error = solaris_O(fd, cmd, arg); break;
  795. default:
  796. error = -ENOSYS;
  797. break;
  798. }
  799. unlock_kernel();
  800. fput(filp);
  801. out:
  802. if (error == -ENOSYS) {
  803. unsigned char c = cmd>>8;
  805. if (c < ' ' || c > 126) c = '.';
  806. printk("solaris_ioctl: Unknown cmd fd(%d) cmd(%08x '%c') arg(%08x)n",
  807.        (int)fd, (unsigned int)cmd, c, (unsigned int)arg);
  808. error = -EINVAL;
  809. }
  810. return error;
  811. }