arch/sparc64/solaris/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  */
  14
  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>
  26
  27 #include <asm/uaccess.h>
  28 #include <asm/termios.h>
  29 #include <asm/openpromio.h>
  30
  31 #include "conv.h"
  32 #include "socksys.h"
  33
  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);
  39
  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);
  44
  45 /* termio* stuff {{{ */
  46
  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 };
  54
  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 };
  63
  64 struct solaris_termiox {
  65         u16     x_hflag;
  66         u16     x_cflag;
  67         u16     x_rflag[5];
  68         u16     x_sflag;
  69 };
  70
  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 }
  90
  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 }
 115
 116 static inline int linux_to_solaris_termio(unsigned int fd, unsigned int cmd, u32 arg)
 117 {
 118         int ret;
 119
 120         ret = sys_ioctl(fd, cmd, A(arg));
 121         if (!ret) {
 122                 u32 cflag;
 123
 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 }
 132
 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();
 138
 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 }
 147
 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();
 153
 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 }
 168
 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();
 174
 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 }
 191
 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 }
 224
 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 }
 235
 236 /* }}} */
 237
 238 /* A pseudo STREAMS support {{{ */
 239
 240 struct strioctl {
 241         int cmd, timeout, len;
 242         u32 data;
 243 };
 244
 245 struct solaris_si_sockparams {
 246         int sp_family;
 247         int sp_type;
 248         int sp_protocol;
 249 };
 250
 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 };
 261
 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 };
 273
 274 #define SOLARIS_MODULE_TIMOD    0
 275 #define SOLARIS_MODULE_SOCKMOD  1
 276 #define SOLARIS_MODULE_MAX      2
 277
 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 };
 287
 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);
 301
 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;
 308
 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         }
 372         return TNOTSUPPORT;
 373 }
 374
 375 static inline int solaris_timod(unsigned int fd, unsigned int cmd, u32 arg,
 376                                     int len, int *len_p)
 377 {
 378         int ret;
 379
 380         switch (cmd & 0xff) {
 381         case 141: /* TI_OPTMGMT */
 382         {
 383                 int i;
 384                 u32 prim;
 385                 SOLD("TI_OPMGMT entry");
 386                 ret = timod_putmsg(fd, (char *)A(arg), len, NULL, -1, 0);
 387                 SOLD("timod_putmsg() returned");
 388                 if (ret)
 389                         return (-ret << 8) | TSYSERR;
 390                 i = MSG_HIPRI;
 391                 SOLD("calling timod_getmsg()");
 392                 ret = timod_getmsg(fd, (char *)A(arg), len, len_p, NULL, -1, NULL, &i);
 393                 SOLD("timod_getmsg() returned");
 394                 if (ret)
 395                         return (-ret << 8) | TSYSERR;
 396                 SOLD("ret ok");
 397                 if (get_user(prim, (u32 *)A(arg)))
 398                         return (EFAULT << 8) | TSYSERR;
 399                 SOLD("got prim");
 400                 if (prim == T_ERROR_ACK) {
 401                         u32 tmp, tmp2;
 402                         SOLD("prim is T_ERROR_ACK");
 403                         if (get_user(tmp, (u32 *)A(arg)+3) ||
 404                             get_user(tmp2, (u32 *)A(arg)+2))
 405                                 return (EFAULT << 8) | TSYSERR;
 406                         return (tmp2 << 8) | tmp;
 407                 }
 408                 SOLD("TI_OPMGMT return 0");
 409                 return 0;
 410         }
 411         case 142: /* TI_BIND */
 412         {
 413                 int i;
 414                 u32 prim;
 415                 SOLD("TI_BIND entry");
 416                 ret = timod_putmsg(fd, (char *)A(arg), len, NULL, -1, 0);
 417                 SOLD("timod_putmsg() returned");
 418                 if (ret)
 419                         return (-ret << 8) | TSYSERR;
 420                 len = 1024; /* Solaris allows arbitrary return size */
 421                 i = MSG_HIPRI;
 422                 SOLD("calling timod_getmsg()");
 423                 ret = timod_getmsg(fd, (char *)A(arg), len, len_p, NULL, -1, NULL, &i);
 424                 SOLD("timod_getmsg() returned");
 425                 if (ret)
 426                         return (-ret << 8) | TSYSERR;
 427                 SOLD("ret ok");
 428                 if (get_user(prim, (u32 *)A(arg)))
 429                         return (EFAULT << 8) | TSYSERR;
 430                 SOLD("got prim");
 431                 if (prim == T_ERROR_ACK) {
 432                         u32 tmp, tmp2;
 433                         SOLD("prim is T_ERROR_ACK");
 434                         if (get_user(tmp, (u32 *)A(arg)+3) ||
 435                             get_user(tmp2, (u32 *)A(arg)+2))
 436                                 return (EFAULT << 8) | TSYSERR;
 437                         return (tmp2 << 8) | tmp;
 438                 }
 439                 SOLD("no ERROR_ACK requested");
 440                 if (prim != T_OK_ACK)
 441                         return TBADSEQ;
 442                 SOLD("OK_ACK requested");
 443                 i = MSG_HIPRI;
 444                 SOLD("calling timod_getmsg()");
 445                 ret = timod_getmsg(fd, (char *)A(arg), len, len_p, NULL, -1, NULL, &i);
 446                 SOLD("timod_getmsg() returned");
 447                 if (ret)
 448                         return (-ret << 8) | TSYSERR;
 449                 SOLD("TI_BIND return ok");
 450                 return 0;
 451         }
 452         case 140: /* TI_GETINFO */
 453         case 143: /* TI_UNBIND */
 454         case 144: /* TI_GETMYNAME */
 455         case 145: /* TI_GETPEERNAME */
 456         case 146: /* TI_SETMYNAME */
 457         case 147: /* TI_SETPEERNAME */
 458                 ;
 459         }
 460         return TNOTSUPPORT;
 461 }
 462
 463 static inline int solaris_S(struct file *filp, unsigned int fd, unsigned int cmd, u32 arg)
 464 {
 465         char *p;
 466         int ret;
 467         mm_segment_t old_fs;
 468         struct strioctl si;
 469         struct inode *ino;
 470         struct sol_socket_struct *sock;
 471         struct module_info *mi;
 472
 473         ino = filp->f_dentry->d_inode;
 474         if (! ino->i_sock)
 475                 return -EBADF;
 476         sock = filp->private_data;
 477         if (! sock) {
 478                 printk("solaris_S: NULL private_data\n");
 479                 return -EBADF;
 480         }
 481         if (sock->magic != SOLARIS_SOCKET_MAGIC) {
 482                 printk("solaris_S: invalid magic\n");
 483                 return -EBADF;
 484         }
 485
 486
 487         switch (cmd & 0xff) {
 488         case 1: /* I_NREAD */
 489                 return -ENOSYS;
 490         case 2: /* I_PUSH */
 491         {
 492                 p = getname ((char *)A(arg));
 493                 if (IS_ERR (p))
 494                         return PTR_ERR(p);
 495                 ret = -EINVAL;
 496                 for (mi = module_table; mi->name; mi++) {
 497                         if (strcmp(mi->name, p) == 0) {
 498                                 sol_module m;
 499                                 if (sock->modcount >= MAX_NR_STREAM_MODULES) {
 500                                         ret = -ENXIO;
 501                                         break;
 502                                 }
 503                                 m = (sol_module) (mi - module_table);
 504                                 sock->module[sock->modcount++] = m;
 505                                 ret = 0;
 506                                 break;
 507                         }
 508                 }
 509                 putname (p);
 510                 return ret;
 511         }
 512         case 3: /* I_POP */
 513                 if (sock->modcount <= 0) return -EINVAL;
 514                 sock->modcount--;
 515                 return 0;
 516         case 4: /* I_LOOK */
 517         {
 518                 const char *p;
 519                 if (sock->modcount <= 0) return -EINVAL;
 520                 p = module_table[(unsigned)sock->module[sock->modcount]].name;
 521                 if (copy_to_user ((char *)A(arg), p, strlen(p)))
 522                         return -EFAULT;
 523                 return 0;
 524         }
 525         case 5: /* I_FLUSH */
 526                 return 0;
 527         case 8: /* I_STR */
 528                 if (copy_from_user(&si, (struct strioctl *)A(arg), sizeof(struct strioctl)))
 529                         return -EFAULT;
 530                 /* We ignore what module is actually at the top of stack. */
 531                 switch ((si.cmd >> 8) & 0xff) {
 532                 case 'I':
 533                         return solaris_sockmod(fd, si.cmd, si.data);
 534                 case 'T':
 535                         return solaris_timod(fd, si.cmd, si.data, si.len,
 536                                                 &((struct strioctl*)A(arg))->len);
 537                 default:
 538                         return solaris_ioctl(fd, si.cmd, si.data);
 539                 }
 540         case 9: /* I_SETSIG */
 541                 return sys_ioctl(fd, FIOSETOWN, current->pid);
 542         case 10: /* I_GETSIG */
 543                 old_fs = get_fs();
 544                 set_fs(KERNEL_DS);
 545                 sys_ioctl(fd, FIOGETOWN, (unsigned long)&ret);
 546                 set_fs(old_fs);
 547                 if (ret == current->pid) return 0x3ff;
 548                 else return -EINVAL;
 549         case 11: /* I_FIND */
 550         {
 551                 int i;
 552                 p = getname ((char *)A(arg));
 553                 if (IS_ERR (p))
 554                         return PTR_ERR(p);
 555                 ret = 0;
 556                 for (i = 0; i < sock->modcount; i++) {
 557                         unsigned m = sock->module[i];
 558                         if (strcmp(module_table[m].name, p) == 0) {
 559                                 ret = 1;
 560                                 break;
 561                         }
 562                 }
 563                 putname (p);
 564                 return ret;
 565         }
 566         case 19: /* I_SWROPT */
 567         case 32: /* I_SETCLTIME */
 568                 return 0;       /* Lie */
 569         }
 570         return -ENOSYS;
 571 }
 572
 573 static inline int solaris_s(unsigned int fd, unsigned int cmd, u32 arg)
 574 {
 575         switch (cmd & 0xff) {
 576         case 0: /* SIOCSHIWAT */
 577         case 2: /* SIOCSLOWAT */
 578                 return 0; /* We don't support them */
 579         case 1: /* SIOCGHIWAT */
 580         case 3: /* SIOCGLOWAT */
 581                 if (put_user (0, (u32 *)A(arg)))
 582                         return -EFAULT;
 583                 return 0; /* Lie */
 584         case 7: /* SIOCATMARK */
 585                 return sys_ioctl(fd, SIOCATMARK, arg);
 586         case 8: /* SIOCSPGRP */
 587                 return sys_ioctl(fd, SIOCSPGRP, arg);
 588         case 9: /* SIOCGPGRP */
 589                 return sys_ioctl(fd, SIOCGPGRP, arg);
 590         }
 591         return -ENOSYS;
 592 }
 593
 594 static inline int solaris_r(unsigned int fd, unsigned int cmd, u32 arg)
 595 {
 596         switch (cmd & 0xff) {
 597         case 10: /* SIOCADDRT */
 598                 return sys32_ioctl(fd, SIOCADDRT, arg);
 599         case 11: /* SIOCDELRT */
 600                 return sys32_ioctl(fd, SIOCDELRT, arg);
 601         }
 602         return -ENOSYS;
 603 }
 604
 605 static inline int solaris_i(unsigned int fd, unsigned int cmd, u32 arg)
 606 {
 607         switch (cmd & 0xff) {
 608         case 12: /* SIOCSIFADDR */
 609                 return sys32_ioctl(fd, SIOCSIFADDR, arg);
 610         case 13: /* SIOCGIFADDR */
 611                 return sys32_ioctl(fd, SIOCGIFADDR, arg);
 612         case 14: /* SIOCSIFDSTADDR */
 613                 return sys32_ioctl(fd, SIOCSIFDSTADDR, arg);
 614         case 15: /* SIOCGIFDSTADDR */
 615                 return sys32_ioctl(fd, SIOCGIFDSTADDR, arg);
 616         case 16: /* SIOCSIFFLAGS */
 617                 return sys32_ioctl(fd, SIOCSIFFLAGS, arg);
 618         case 17: /* SIOCGIFFLAGS */
 619                 return sys32_ioctl(fd, SIOCGIFFLAGS, arg);
 620         case 18: /* SIOCSIFMEM */
 621                 return sys32_ioctl(fd, SIOCSIFMEM, arg);
 622         case 19: /* SIOCGIFMEM */
 623                 return sys32_ioctl(fd, SIOCGIFMEM, arg);
 624         case 20: /* SIOCGIFCONF */
 625                 return sys32_ioctl(fd, SIOCGIFCONF, arg);
 626         case 21: /* SIOCSIFMTU */
 627                 return sys32_ioctl(fd, SIOCSIFMTU, arg);
 628         case 22: /* SIOCGIFMTU */
 629                 return sys32_ioctl(fd, SIOCGIFMTU, arg);
 630         case 23: /* SIOCGIFBRDADDR */
 631                 return sys32_ioctl(fd, SIOCGIFBRDADDR, arg);
 632         case 24: /* SIOCSIFBRDADDR */
 633                 return sys32_ioctl(fd, SIOCSIFBRDADDR, arg);
 634         case 25: /* SIOCGIFNETMASK */
 635                 return sys32_ioctl(fd, SIOCGIFNETMASK, arg);
 636         case 26: /* SIOCSIFNETMASK */
 637                 return sys32_ioctl(fd, SIOCSIFNETMASK, arg);
 638         case 27: /* SIOCGIFMETRIC */
 639                 return sys32_ioctl(fd, SIOCGIFMETRIC, arg);
 640         case 28: /* SIOCSIFMETRIC */
 641                 return sys32_ioctl(fd, SIOCSIFMETRIC, arg);
 642         case 30: /* SIOCSARP */
 643                 return sys32_ioctl(fd, SIOCSARP, arg);
 644         case 31: /* SIOCGARP */
 645                 return sys32_ioctl(fd, SIOCGARP, arg);
 646         case 32: /* SIOCDARP */
 647                 return sys32_ioctl(fd, SIOCDARP, arg);
 648         case 52: /* SIOCGETNAME */
 649         case 53: /* SIOCGETPEER */
 650                 {
 651                         struct sockaddr uaddr;
 652                         int uaddr_len = sizeof(struct sockaddr), ret;
 653                         long args[3];
 654                         mm_segment_t old_fs = get_fs();
 655                         int (*sys_socketcall)(int, unsigned long *) =
 656                                 (int (*)(int, unsigned long *))SYS(socketcall);
 657
 658                         args[0] = fd; args[1] = (long)&uaddr; args[2] = (long)&uaddr_len;
 659                         set_fs(KERNEL_DS);
 660                         ret = sys_socketcall(((cmd & 0xff) == 52) ? SYS_GETSOCKNAME : SYS_GETPEERNAME,
 661                                         args);
 662                         set_fs(old_fs);
 663                         if (ret >= 0) {
 664                                 if (copy_to_user((char *)A(arg), &uaddr, uaddr_len))
 665                                         return -EFAULT;
 666                         }
 667                         return ret;
 668                 }
 669 #if 0
 670         case 86: /* SIOCSOCKSYS */
 671                 return socksys_syscall(fd, arg);
 672 #endif
 673         case 87: /* SIOCGIFNUM */
 674                 {
 675                         struct net_device *d;
 676                         int i = 0;
 677
 678                         read_lock_bh(&dev_base_lock);
 679                         for (d = dev_base; d; d = d->next) i++;
 680                         read_unlock_bh(&dev_base_lock);
 681
 682                         if (put_user (i, (int *)A(arg)))
 683                                 return -EFAULT;
 684                         return 0;
 685                 }
 686         }
 687         return -ENOSYS;
 688 }
 689
 690 static int solaris_m(unsigned int fd, unsigned int cmd, u32 arg)
 691 {
 692         int ret;
 693
 694         switch (cmd & 0xff) {
 695         case 1: /* MTIOCTOP */
 696                 ret = sys_ioctl(fd, MTIOCTOP, (unsigned long)&arg);
 697                 break;
 698         case 2: /* MTIOCGET */
 699                 ret = sys_ioctl(fd, MTIOCGET, (unsigned long)&arg);
 700                 break;
 701         case 3: /* MTIOCGETDRIVETYPE */
 702         case 4: /* MTIOCPERSISTENT */
 703         case 5: /* MTIOCPERSISTENTSTATUS */
 704         case 6: /* MTIOCLRERR */
 705         case 7: /* MTIOCGUARANTEEDORDER */
 706         case 8: /* MTIOCRESERVE */
 707         case 9: /* MTIOCRELEASE */
 708         case 10: /* MTIOCFORCERESERVE */
 709         case 13: /* MTIOCSTATE */
 710         case 14: /* MTIOCREADIGNOREILI */
 711         case 15: /* MTIOCREADIGNOREEOFS */
 712         case 16: /* MTIOCSHORTFMK */
 713         default:
 714                 ret = -ENOSYS; /* linux doesn't support these */
 715                 break;
 716         };
 717
 718         return ret;
 719 }
 720
 721 static int solaris_O(unsigned int fd, unsigned int cmd, u32 arg)
 722 {
 723         int ret = -EINVAL;
 724
 725         switch (cmd & 0xff) {
 726         case 1: /* OPROMGETOPT */
 727                 ret = sys_ioctl(fd, OPROMGETOPT, arg);
 728                 break;
 729         case 2: /* OPROMSETOPT */
 730                 ret = sys_ioctl(fd, OPROMSETOPT, arg);
 731                 break;
 732         case 3: /* OPROMNXTOPT */
 733                 ret = sys_ioctl(fd, OPROMNXTOPT, arg);
 734                 break;
 735         case 4: /* OPROMSETOPT2 */
 736                 ret = sys_ioctl(fd, OPROMSETOPT2, arg);
 737                 break;
 738         case 5: /* OPROMNEXT */
 739                 ret = sys_ioctl(fd, OPROMNEXT, arg);
 740                 break;
 741         case 6: /* OPROMCHILD */
 742                 ret = sys_ioctl(fd, OPROMCHILD, arg);
 743                 break;
 744         case 7: /* OPROMGETPROP */
 745                 ret = sys_ioctl(fd, OPROMGETPROP, arg);
 746                 break;
 747         case 8: /* OPROMNXTPROP */
 748                 ret = sys_ioctl(fd, OPROMNXTPROP, arg);
 749                 break;
 750         case 9: /* OPROMU2P */
 751                 ret = sys_ioctl(fd, OPROMU2P, arg);
 752                 break;
 753         case 10: /* OPROMGETCONS */
 754                 ret = sys_ioctl(fd, OPROMGETCONS, arg);
 755                 break;
 756         case 11: /* OPROMGETFBNAME */
 757                 ret = sys_ioctl(fd, OPROMGETFBNAME, arg);
 758                 break;
 759         case 12: /* OPROMGETBOOTARGS */
 760                 ret = sys_ioctl(fd, OPROMGETBOOTARGS, arg);
 761                 break;
 762         case 13: /* OPROMGETVERSION */
 763         case 14: /* OPROMPATH2DRV */
 764         case 15: /* OPROMDEV2PROMNAME */
 765         case 16: /* OPROMPROM2DEVNAME */
 766         case 17: /* OPROMGETPROPLEN */
 767         default:
 768                 ret = -EINVAL;
 769                 break;
 770         };
 771         return ret;
 772 }
 773
 774 /* }}} */
 775
 776 asmlinkage int solaris_ioctl(unsigned int fd, unsigned int cmd, u32 arg)
 777 {
 778         struct file *filp;
 779         int error = -EBADF;
 780
 781         filp = fget(fd);
 782         if (!filp)
 783                 goto out;
 784
 785         lock_kernel();
 786         error = -EFAULT;
 787         switch ((cmd >> 8) & 0xff) {
 788         case 'S': error = solaris_S(filp, fd, cmd, arg); break;
 789         case 'T': error = solaris_T(fd, cmd, arg); break;
 790         case 'i': error = solaris_i(fd, cmd, arg); break;
 791         case 'r': error = solaris_r(fd, cmd, arg); break;
 792         case 's': error = solaris_s(fd, cmd, arg); break;
 793         case 't': error = solaris_t(fd, cmd, arg); break;
 794         case 'f': error = sys_ioctl(fd, cmd, arg); break;
 795         case 'm': error = solaris_m(fd, cmd, arg); break;
 796         case 'O': error = solaris_O(fd, cmd, arg); break;
 797         default:
 798                 error = -ENOSYS;
 799                 break;
 800         }
 801         unlock_kernel();
 802         fput(filp);
 803 out:
 804         if (error == -ENOSYS) {
 805                 unsigned char c = cmd>>8;
 806
 807                 if (c < ' ' || c > 126) c = '.';
 808                 printk("solaris_ioctl: Unknown cmd fd(%d) cmd(%08x '%c') arg(%08x)\n",
 809                        (int)fd, (unsigned int)cmd, c, (unsigned int)arg);
 810                 error = -EINVAL;
 811         }
 812         return error;
 813 }