sys/compat/linux/linux_ioctl.c

   1 /*-
   2  * Copyright (c) 1994-1995 Søren Schmidt
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "opt_route.h"
  30 #include "opt_compat.h"
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/sysproto.h>
  38 #include <sys/cdio.h>
  39 #include <sys/dvdio.h>
  40 #include <sys/conf.h>
  41 #include <sys/disk.h>
  42 #include <sys/consio.h>
  43 #include <sys/ctype.h>
  44 #include <sys/fcntl.h>
  45 #include <sys/file.h>
  46 #include <sys/filedesc.h>
  47 #include <sys/filio.h>
  48 #include <sys/kbio.h>
  49 #include <sys/kernel.h>
  50 #include <sys/linker_set.h>
  51 #include <sys/lock.h>
  52 #include <sys/malloc.h>
  53 #include <sys/proc.h>
  54 #include <sys/sbuf.h>
  55 #include <sys/socket.h>
  56 #include <sys/sockio.h>
  57 #include <sys/soundcard.h>
  58 #include <sys/stdint.h>
  59 #include <sys/sx.h>
  60 #include <sys/tty.h>
  61 #include <sys/uio.h>
  62 #include <sys/vimage.h>
  63
  64 #include <net/if.h>
  65 #include <net/if_dl.h>
  66 #include <net/if_types.h>
  67 #include <net/route.h>
  68 #include <net/vnet.h>
  69
  70 #ifdef COMPAT_LINUX32
  71 #include <machine/../linux32/linux.h>
  72 #include <machine/../linux32/linux32_proto.h>
  73 #else
  74 #include <machine/../linux/linux.h>
  75 #include <machine/../linux/linux_proto.h>
  76 #endif
  77
  78 #include <compat/linux/linux_ioctl.h>
  79 #include <compat/linux/linux_mib.h>
  80 #include <compat/linux/linux_socket.h>
  81 #include <compat/linux/linux_util.h>
  82
  83 CTASSERT(LINUX_IFNAMSIZ == IFNAMSIZ);
  84
  85 static linux_ioctl_function_t linux_ioctl_cdrom;
  86 static linux_ioctl_function_t linux_ioctl_vfat;
  87 static linux_ioctl_function_t linux_ioctl_console;
  88 static linux_ioctl_function_t linux_ioctl_hdio;
  89 static linux_ioctl_function_t linux_ioctl_disk;
  90 static linux_ioctl_function_t linux_ioctl_socket;
  91 static linux_ioctl_function_t linux_ioctl_sound;
  92 static linux_ioctl_function_t linux_ioctl_termio;
  93 static linux_ioctl_function_t linux_ioctl_private;
  94 static linux_ioctl_function_t linux_ioctl_drm;
  95 static linux_ioctl_function_t linux_ioctl_sg;
  96 static linux_ioctl_function_t linux_ioctl_special;
  97
  98 static struct linux_ioctl_handler cdrom_handler =
  99 { linux_ioctl_cdrom, LINUX_IOCTL_CDROM_MIN, LINUX_IOCTL_CDROM_MAX };
 100 static struct linux_ioctl_handler vfat_handler =
 101 { linux_ioctl_vfat, LINUX_IOCTL_VFAT_MIN, LINUX_IOCTL_VFAT_MAX };
 102 static struct linux_ioctl_handler console_handler =
 103 { linux_ioctl_console, LINUX_IOCTL_CONSOLE_MIN, LINUX_IOCTL_CONSOLE_MAX };
 104 static struct linux_ioctl_handler hdio_handler =
 105 { linux_ioctl_hdio, LINUX_IOCTL_HDIO_MIN, LINUX_IOCTL_HDIO_MAX };
 106 static struct linux_ioctl_handler disk_handler =
 107 { linux_ioctl_disk, LINUX_IOCTL_DISK_MIN, LINUX_IOCTL_DISK_MAX };
 108 static struct linux_ioctl_handler socket_handler =
 109 { linux_ioctl_socket, LINUX_IOCTL_SOCKET_MIN, LINUX_IOCTL_SOCKET_MAX };
 110 static struct linux_ioctl_handler sound_handler =
 111 { linux_ioctl_sound, LINUX_IOCTL_SOUND_MIN, LINUX_IOCTL_SOUND_MAX };
 112 static struct linux_ioctl_handler termio_handler =
 113 { linux_ioctl_termio, LINUX_IOCTL_TERMIO_MIN, LINUX_IOCTL_TERMIO_MAX };
 114 static struct linux_ioctl_handler private_handler =
 115 { linux_ioctl_private, LINUX_IOCTL_PRIVATE_MIN, LINUX_IOCTL_PRIVATE_MAX };
 116 static struct linux_ioctl_handler drm_handler =
 117 { linux_ioctl_drm, LINUX_IOCTL_DRM_MIN, LINUX_IOCTL_DRM_MAX };
 118 static struct linux_ioctl_handler sg_handler =
 119 { linux_ioctl_sg, LINUX_IOCTL_SG_MIN, LINUX_IOCTL_SG_MAX };
 120
 121 DATA_SET(linux_ioctl_handler_set, cdrom_handler);
 122 DATA_SET(linux_ioctl_handler_set, vfat_handler);
 123 DATA_SET(linux_ioctl_handler_set, console_handler);
 124 DATA_SET(linux_ioctl_handler_set, hdio_handler);
 125 DATA_SET(linux_ioctl_handler_set, disk_handler);
 126 DATA_SET(linux_ioctl_handler_set, socket_handler);
 127 DATA_SET(linux_ioctl_handler_set, sound_handler);
 128 DATA_SET(linux_ioctl_handler_set, termio_handler);
 129 DATA_SET(linux_ioctl_handler_set, private_handler);
 130 DATA_SET(linux_ioctl_handler_set, drm_handler);
 131 DATA_SET(linux_ioctl_handler_set, sg_handler);
 132
 133 struct handler_element
 134 {
 135         TAILQ_ENTRY(handler_element) list;
 136         int     (*func)(struct thread *, struct linux_ioctl_args *);
 137         int     low, high, span;
 138 };
 139
 140 static TAILQ_HEAD(, handler_element) handlers =
 141         TAILQ_HEAD_INITIALIZER(handlers);
 142 static struct sx linux_ioctl_sx;
 143 SX_SYSINIT(linux_ioctl, &linux_ioctl_sx, "linux ioctl handlers");
 144
 145 /*
 146  * hdio related ioctls for VMWare support
 147  */
 148
 149 struct linux_hd_geometry {
 150         u_int8_t        heads;
 151         u_int8_t        sectors;
 152         u_int16_t       cylinders;
 153         u_int32_t       start;
 154 };
 155
 156 struct linux_hd_big_geometry {
 157         u_int8_t        heads;
 158         u_int8_t        sectors;
 159         u_int32_t       cylinders;
 160         u_int32_t       start;
 161 };
 162
 163 static int
 164 linux_ioctl_hdio(struct thread *td, struct linux_ioctl_args *args)
 165 {
 166         struct file *fp;
 167         int error;
 168         u_int sectorsize, fwcylinders, fwheads, fwsectors;
 169         off_t mediasize, bytespercyl;
 170
 171         if ((error = fget(td, args->fd, &fp)) != 0)
 172                 return (error);
 173         switch (args->cmd & 0xffff) {
 174         case LINUX_HDIO_GET_GEO:
 175         case LINUX_HDIO_GET_GEO_BIG:
 176                 error = fo_ioctl(fp, DIOCGMEDIASIZE,
 177                         (caddr_t)&mediasize, td->td_ucred, td);
 178                 if (!error)
 179                         error = fo_ioctl(fp, DIOCGSECTORSIZE,
 180                                 (caddr_t)&sectorsize, td->td_ucred, td);
 181                 if (!error)
 182                         error = fo_ioctl(fp, DIOCGFWHEADS,
 183                                 (caddr_t)&fwheads, td->td_ucred, td);
 184                 if (!error)
 185                         error = fo_ioctl(fp, DIOCGFWSECTORS,
 186                                 (caddr_t)&fwsectors, td->td_ucred, td);
 187                 /*
 188                  * XXX: DIOCGFIRSTOFFSET is not yet implemented, so
 189                  * so pretend that GEOM always says 0. This is NOT VALID
 190                  * for slices or partitions, only the per-disk raw devices.
 191                  */
 192
 193                 fdrop(fp, td);
 194                 if (error)
 195                         return (error);
 196                 /*
 197                  * 1. Calculate the number of bytes in a cylinder,
 198                  *    given the firmware's notion of heads and sectors
 199                  *    per cylinder.
 200                  * 2. Calculate the number of cylinders, given the total
 201                  *    size of the media.
 202                  * All internal calculations should have 64-bit precision.
 203                  */
 204                 bytespercyl = (off_t) sectorsize * fwheads * fwsectors;
 205                 fwcylinders = mediasize / bytespercyl;
 206 #if defined(DEBUG)
 207                 linux_msg(td, "HDIO_GET_GEO: mediasize %jd, c/h/s %d/%d/%d, "
 208                           "bpc %jd",
 209                           (intmax_t)mediasize, fwcylinders, fwheads, fwsectors,
 210                           (intmax_t)bytespercyl);
 211 #endif
 212                 if ((args->cmd & 0xffff) == LINUX_HDIO_GET_GEO) {
 213                         struct linux_hd_geometry hdg;
 214
 215                         hdg.cylinders = fwcylinders;
 216                         hdg.heads = fwheads;
 217                         hdg.sectors = fwsectors;
 218                         hdg.start = 0;
 219                         error = copyout(&hdg, (void *)args->arg, sizeof(hdg));
 220                 } else if ((args->cmd & 0xffff) == LINUX_HDIO_GET_GEO_BIG) {
 221                         struct linux_hd_big_geometry hdbg;
 222
 223                         hdbg.cylinders = fwcylinders;
 224                         hdbg.heads = fwheads;
 225                         hdbg.sectors = fwsectors;
 226                         hdbg.start = 0;
 227                         error = copyout(&hdbg, (void *)args->arg, sizeof(hdbg));
 228                 }
 229                 return (error);
 230                 break;
 231         default:
 232                 /* XXX */
 233                 linux_msg(td,
 234                         "ioctl fd=%d, cmd=0x%x ('%c',%d) is not implemented",
 235                         args->fd, (int)(args->cmd & 0xffff),
 236                         (int)(args->cmd & 0xff00) >> 8,
 237                         (int)(args->cmd & 0xff));
 238                 break;
 239         }
 240         fdrop(fp, td);
 241         return (ENOIOCTL);
 242 }
 243
 244 static int
 245 linux_ioctl_disk(struct thread *td, struct linux_ioctl_args *args)
 246 {
 247         struct file *fp;
 248         int error;
 249         u_int sectorsize;
 250         off_t mediasize;
 251
 252         if ((error = fget(td, args->fd, &fp)) != 0)
 253                 return (error);
 254         switch (args->cmd & 0xffff) {
 255         case LINUX_BLKGETSIZE:
 256                 error = fo_ioctl(fp, DIOCGSECTORSIZE,
 257                     (caddr_t)&sectorsize, td->td_ucred, td);
 258                 if (!error)
 259                         error = fo_ioctl(fp, DIOCGMEDIASIZE,
 260                             (caddr_t)&mediasize, td->td_ucred, td);
 261                 fdrop(fp, td);
 262                 if (error)
 263                         return (error);
 264                 sectorsize = mediasize / sectorsize;
 265                 /*
 266                  * XXX: How do we know we return the right size of integer ?
 267                  */
 268                 return (copyout(&sectorsize, (void *)args->arg,
 269                     sizeof(sectorsize)));
 270                 break;
 271         }
 272         fdrop(fp, td);
 273         return (ENOIOCTL);
 274 }
 275
 276 /*
 277  * termio related ioctls
 278  */
 279
 280 struct linux_termio {
 281         unsigned short c_iflag;
 282         unsigned short c_oflag;
 283         unsigned short c_cflag;
 284         unsigned short c_lflag;
 285         unsigned char c_line;
 286         unsigned char c_cc[LINUX_NCC];
 287 };
 288
 289 struct linux_termios {
 290         unsigned int c_iflag;
 291         unsigned int c_oflag;
 292         unsigned int c_cflag;
 293         unsigned int c_lflag;
 294         unsigned char c_line;
 295         unsigned char c_cc[LINUX_NCCS];
 296 };
 297
 298 struct linux_winsize {
 299         unsigned short ws_row, ws_col;
 300         unsigned short ws_xpixel, ws_ypixel;
 301 };
 302
 303 struct speedtab {
 304         int sp_speed;                   /* Speed. */
 305         int sp_code;                    /* Code. */
 306 };
 307
 308 static struct speedtab sptab[] = {
 309         { B0, LINUX_B0 }, { B50, LINUX_B50 },
 310         { B75, LINUX_B75 }, { B110, LINUX_B110 },
 311         { B134, LINUX_B134 }, { B150, LINUX_B150 },
 312         { B200, LINUX_B200 }, { B300, LINUX_B300 },
 313         { B600, LINUX_B600 }, { B1200, LINUX_B1200 },
 314         { B1800, LINUX_B1800 }, { B2400, LINUX_B2400 },
 315         { B4800, LINUX_B4800 }, { B9600, LINUX_B9600 },
 316         { B19200, LINUX_B19200 }, { B38400, LINUX_B38400 },
 317         { B57600, LINUX_B57600 }, { B115200, LINUX_B115200 },
 318         {-1, -1 }
 319 };
 320
 321 struct linux_serial_struct {
 322         int     type;
 323         int     line;
 324         int     port;
 325         int     irq;
 326         int     flags;
 327         int     xmit_fifo_size;
 328         int     custom_divisor;
 329         int     baud_base;
 330         unsigned short close_delay;
 331         char    reserved_char[2];
 332         int     hub6;
 333         unsigned short closing_wait;
 334         unsigned short closing_wait2;
 335         int     reserved[4];
 336 };
 337
 338 static int
 339 linux_to_bsd_speed(int code, struct speedtab *table)
 340 {
 341         for ( ; table->sp_code != -1; table++)
 342                 if (table->sp_code == code)
 343                         return (table->sp_speed);
 344         return -1;
 345 }
 346
 347 static int
 348 bsd_to_linux_speed(int speed, struct speedtab *table)
 349 {
 350         for ( ; table->sp_speed != -1; table++)
 351                 if (table->sp_speed == speed)
 352                         return (table->sp_code);
 353         return -1;
 354 }
 355
 356 static void
 357 bsd_to_linux_termios(struct termios *bios, struct linux_termios *lios)
 358 {
 359         int i;
 360
 361 #ifdef DEBUG
 362         if (ldebug(ioctl)) {
 363                 printf("LINUX: BSD termios structure (input):\n");
 364                 printf("i=%08x o=%08x c=%08x l=%08x ispeed=%d ospeed=%d\n",
 365                     bios->c_iflag, bios->c_oflag, bios->c_cflag, bios->c_lflag,
 366                     bios->c_ispeed, bios->c_ospeed);
 367                 printf("c_cc ");
 368                 for (i=0; i<NCCS; i++)
 369                         printf("%02x ", bios->c_cc[i]);
 370                 printf("\n");
 371         }
 372 #endif
 373
 374         lios->c_iflag = 0;
 375         if (bios->c_iflag & IGNBRK)
 376                 lios->c_iflag |= LINUX_IGNBRK;
 377         if (bios->c_iflag & BRKINT)
 378                 lios->c_iflag |= LINUX_BRKINT;
 379         if (bios->c_iflag & IGNPAR)
 380                 lios->c_iflag |= LINUX_IGNPAR;
 381         if (bios->c_iflag & PARMRK)
 382                 lios->c_iflag |= LINUX_PARMRK;
 383         if (bios->c_iflag & INPCK)
 384                 lios->c_iflag |= LINUX_INPCK;
 385         if (bios->c_iflag & ISTRIP)
 386                 lios->c_iflag |= LINUX_ISTRIP;
 387         if (bios->c_iflag & INLCR)
 388                 lios->c_iflag |= LINUX_INLCR;
 389         if (bios->c_iflag & IGNCR)
 390                 lios->c_iflag |= LINUX_IGNCR;
 391         if (bios->c_iflag & ICRNL)
 392                 lios->c_iflag |= LINUX_ICRNL;
 393         if (bios->c_iflag & IXON)
 394                 lios->c_iflag |= LINUX_IXON;
 395         if (bios->c_iflag & IXANY)
 396                 lios->c_iflag |= LINUX_IXANY;
 397         if (bios->c_iflag & IXOFF)
 398                 lios->c_iflag |= LINUX_IXOFF;
 399         if (bios->c_iflag & IMAXBEL)
 400                 lios->c_iflag |= LINUX_IMAXBEL;
 401
 402         lios->c_oflag = 0;
 403         if (bios->c_oflag & OPOST)
 404                 lios->c_oflag |= LINUX_OPOST;
 405         if (bios->c_oflag & ONLCR)
 406                 lios->c_oflag |= LINUX_ONLCR;
 407         if (bios->c_oflag & TAB3)
 408                 lios->c_oflag |= LINUX_XTABS;
 409
 410         lios->c_cflag = bsd_to_linux_speed(bios->c_ispeed, sptab);
 411         lios->c_cflag |= (bios->c_cflag & CSIZE) >> 4;
 412         if (bios->c_cflag & CSTOPB)
 413                 lios->c_cflag |= LINUX_CSTOPB;
 414         if (bios->c_cflag & CREAD)
 415                 lios->c_cflag |= LINUX_CREAD;
 416         if (bios->c_cflag & PARENB)
 417                 lios->c_cflag |= LINUX_PARENB;
 418         if (bios->c_cflag & PARODD)
 419                 lios->c_cflag |= LINUX_PARODD;
 420         if (bios->c_cflag & HUPCL)
 421                 lios->c_cflag |= LINUX_HUPCL;
 422         if (bios->c_cflag & CLOCAL)
 423                 lios->c_cflag |= LINUX_CLOCAL;
 424         if (bios->c_cflag & CRTSCTS)
 425                 lios->c_cflag |= LINUX_CRTSCTS;
 426
 427         lios->c_lflag = 0;
 428         if (bios->c_lflag & ISIG)
 429                 lios->c_lflag |= LINUX_ISIG;
 430         if (bios->c_lflag & ICANON)
 431                 lios->c_lflag |= LINUX_ICANON;
 432         if (bios->c_lflag & ECHO)
 433                 lios->c_lflag |= LINUX_ECHO;
 434         if (bios->c_lflag & ECHOE)
 435                 lios->c_lflag |= LINUX_ECHOE;
 436         if (bios->c_lflag & ECHOK)
 437                 lios->c_lflag |= LINUX_ECHOK;
 438         if (bios->c_lflag & ECHONL)
 439                 lios->c_lflag |= LINUX_ECHONL;
 440         if (bios->c_lflag & NOFLSH)
 441                 lios->c_lflag |= LINUX_NOFLSH;
 442         if (bios->c_lflag & TOSTOP)
 443                 lios->c_lflag |= LINUX_TOSTOP;
 444         if (bios->c_lflag & ECHOCTL)
 445                 lios->c_lflag |= LINUX_ECHOCTL;
 446         if (bios->c_lflag & ECHOPRT)
 447                 lios->c_lflag |= LINUX_ECHOPRT;
 448         if (bios->c_lflag & ECHOKE)
 449                 lios->c_lflag |= LINUX_ECHOKE;
 450         if (bios->c_lflag & FLUSHO)
 451                 lios->c_lflag |= LINUX_FLUSHO;
 452         if (bios->c_lflag & PENDIN)
 453                 lios->c_lflag |= LINUX_PENDIN;
 454         if (bios->c_lflag & IEXTEN)
 455                 lios->c_lflag |= LINUX_IEXTEN;
 456
 457         for (i=0; i<LINUX_NCCS; i++)
 458                 lios->c_cc[i] = LINUX_POSIX_VDISABLE;
 459         lios->c_cc[LINUX_VINTR] = bios->c_cc[VINTR];
 460         lios->c_cc[LINUX_VQUIT] = bios->c_cc[VQUIT];
 461         lios->c_cc[LINUX_VERASE] = bios->c_cc[VERASE];
 462         lios->c_cc[LINUX_VKILL] = bios->c_cc[VKILL];
 463         lios->c_cc[LINUX_VEOF] = bios->c_cc[VEOF];
 464         lios->c_cc[LINUX_VEOL] = bios->c_cc[VEOL];
 465         lios->c_cc[LINUX_VMIN] = bios->c_cc[VMIN];
 466         lios->c_cc[LINUX_VTIME] = bios->c_cc[VTIME];
 467         lios->c_cc[LINUX_VEOL2] = bios->c_cc[VEOL2];
 468         lios->c_cc[LINUX_VSUSP] = bios->c_cc[VSUSP];
 469         lios->c_cc[LINUX_VSTART] = bios->c_cc[VSTART];
 470         lios->c_cc[LINUX_VSTOP] = bios->c_cc[VSTOP];
 471         lios->c_cc[LINUX_VREPRINT] = bios->c_cc[VREPRINT];
 472         lios->c_cc[LINUX_VDISCARD] = bios->c_cc[VDISCARD];
 473         lios->c_cc[LINUX_VWERASE] = bios->c_cc[VWERASE];
 474         lios->c_cc[LINUX_VLNEXT] = bios->c_cc[VLNEXT];
 475
 476         for (i=0; i<LINUX_NCCS; i++) {
 477                 if (i != LINUX_VMIN && i != LINUX_VTIME &&
 478                     lios->c_cc[i] == _POSIX_VDISABLE)
 479                         lios->c_cc[i] = LINUX_POSIX_VDISABLE;
 480         }
 481         lios->c_line = 0;
 482
 483 #ifdef DEBUG
 484         if (ldebug(ioctl)) {
 485                 printf("LINUX: LINUX termios structure (output):\n");
 486                 printf("i=%08x o=%08x c=%08x l=%08x line=%d\n",
 487                     lios->c_iflag, lios->c_oflag, lios->c_cflag,
 488                     lios->c_lflag, (int)lios->c_line);
 489                 printf("c_cc ");
 490                 for (i=0; i<LINUX_NCCS; i++)
 491                         printf("%02x ", lios->c_cc[i]);
 492                 printf("\n");
 493         }
 494 #endif
 495 }
 496
 497 static void
 498 linux_to_bsd_termios(struct linux_termios *lios, struct termios *bios)
 499 {
 500         int i;
 501
 502 #ifdef DEBUG
 503         if (ldebug(ioctl)) {
 504                 printf("LINUX: LINUX termios structure (input):\n");
 505                 printf("i=%08x o=%08x c=%08x l=%08x line=%d\n",
 506                     lios->c_iflag, lios->c_oflag, lios->c_cflag,
 507                     lios->c_lflag, (int)lios->c_line);
 508                 printf("c_cc ");
 509                 for (i=0; i<LINUX_NCCS; i++)
 510                         printf("%02x ", lios->c_cc[i]);
 511                 printf("\n");
 512         }
 513 #endif
 514
 515         bios->c_iflag = 0;
 516         if (lios->c_iflag & LINUX_IGNBRK)
 517                 bios->c_iflag |= IGNBRK;
 518         if (lios->c_iflag & LINUX_BRKINT)
 519                 bios->c_iflag |= BRKINT;
 520         if (lios->c_iflag & LINUX_IGNPAR)
 521                 bios->c_iflag |= IGNPAR;
 522         if (lios->c_iflag & LINUX_PARMRK)
 523                 bios->c_iflag |= PARMRK;
 524         if (lios->c_iflag & LINUX_INPCK)
 525                 bios->c_iflag |= INPCK;
 526         if (lios->c_iflag & LINUX_ISTRIP)
 527                 bios->c_iflag |= ISTRIP;
 528         if (lios->c_iflag & LINUX_INLCR)
 529                 bios->c_iflag |= INLCR;
 530         if (lios->c_iflag & LINUX_IGNCR)
 531                 bios->c_iflag |= IGNCR;
 532         if (lios->c_iflag & LINUX_ICRNL)
 533                 bios->c_iflag |= ICRNL;
 534         if (lios->c_iflag & LINUX_IXON)
 535                 bios->c_iflag |= IXON;
 536         if (lios->c_iflag & LINUX_IXANY)
 537                 bios->c_iflag |= IXANY;
 538         if (lios->c_iflag & LINUX_IXOFF)
 539                 bios->c_iflag |= IXOFF;
 540         if (lios->c_iflag & LINUX_IMAXBEL)
 541                 bios->c_iflag |= IMAXBEL;
 542
 543         bios->c_oflag = 0;
 544         if (lios->c_oflag & LINUX_OPOST)
 545                 bios->c_oflag |= OPOST;
 546         if (lios->c_oflag & LINUX_ONLCR)
 547                 bios->c_oflag |= ONLCR;
 548         if (lios->c_oflag & LINUX_XTABS)
 549                 bios->c_oflag |= TAB3;
 550
 551         bios->c_cflag = (lios->c_cflag & LINUX_CSIZE) << 4;
 552         if (lios->c_cflag & LINUX_CSTOPB)
 553                 bios->c_cflag |= CSTOPB;
 554         if (lios->c_cflag & LINUX_CREAD)
 555                 bios->c_cflag |= CREAD;
 556         if (lios->c_cflag & LINUX_PARENB)
 557                 bios->c_cflag |= PARENB;
 558         if (lios->c_cflag & LINUX_PARODD)
 559                 bios->c_cflag |= PARODD;
 560         if (lios->c_cflag & LINUX_HUPCL)
 561                 bios->c_cflag |= HUPCL;
 562         if (lios->c_cflag & LINUX_CLOCAL)
 563                 bios->c_cflag |= CLOCAL;
 564         if (lios->c_cflag & LINUX_CRTSCTS)
 565                 bios->c_cflag |= CRTSCTS;
 566
 567         bios->c_lflag = 0;
 568         if (lios->c_lflag & LINUX_ISIG)
 569                 bios->c_lflag |= ISIG;
 570         if (lios->c_lflag & LINUX_ICANON)
 571                 bios->c_lflag |= ICANON;
 572         if (lios->c_lflag & LINUX_ECHO)
 573                 bios->c_lflag |= ECHO;
 574         if (lios->c_lflag & LINUX_ECHOE)
 575                 bios->c_lflag |= ECHOE;
 576         if (lios->c_lflag & LINUX_ECHOK)
 577                 bios->c_lflag |= ECHOK;
 578         if (lios->c_lflag & LINUX_ECHONL)
 579                 bios->c_lflag |= ECHONL;
 580         if (lios->c_lflag & LINUX_NOFLSH)
 581                 bios->c_lflag |= NOFLSH;
 582         if (lios->c_lflag & LINUX_TOSTOP)
 583                 bios->c_lflag |= TOSTOP;
 584         if (lios->c_lflag & LINUX_ECHOCTL)
 585                 bios->c_lflag |= ECHOCTL;
 586         if (lios->c_lflag & LINUX_ECHOPRT)
 587                 bios->c_lflag |= ECHOPRT;
 588         if (lios->c_lflag & LINUX_ECHOKE)
 589                 bios->c_lflag |= ECHOKE;
 590         if (lios->c_lflag & LINUX_FLUSHO)
 591                 bios->c_lflag |= FLUSHO;
 592         if (lios->c_lflag & LINUX_PENDIN)
 593                 bios->c_lflag |= PENDIN;
 594         if (lios->c_lflag & LINUX_IEXTEN)
 595                 bios->c_lflag |= IEXTEN;
 596
 597         for (i=0; i<NCCS; i++)
 598                 bios->c_cc[i] = _POSIX_VDISABLE;
 599         bios->c_cc[VINTR] = lios->c_cc[LINUX_VINTR];
 600         bios->c_cc[VQUIT] = lios->c_cc[LINUX_VQUIT];
 601         bios->c_cc[VERASE] = lios->c_cc[LINUX_VERASE];
 602         bios->c_cc[VKILL] = lios->c_cc[LINUX_VKILL];
 603         bios->c_cc[VEOF] = lios->c_cc[LINUX_VEOF];
 604         bios->c_cc[VEOL] = lios->c_cc[LINUX_VEOL];
 605         bios->c_cc[VMIN] = lios->c_cc[LINUX_VMIN];
 606         bios->c_cc[VTIME] = lios->c_cc[LINUX_VTIME];
 607         bios->c_cc[VEOL2] = lios->c_cc[LINUX_VEOL2];
 608         bios->c_cc[VSUSP] = lios->c_cc[LINUX_VSUSP];
 609         bios->c_cc[VSTART] = lios->c_cc[LINUX_VSTART];
 610         bios->c_cc[VSTOP] = lios->c_cc[LINUX_VSTOP];
 611         bios->c_cc[VREPRINT] = lios->c_cc[LINUX_VREPRINT];
 612         bios->c_cc[VDISCARD] = lios->c_cc[LINUX_VDISCARD];
 613         bios->c_cc[VWERASE] = lios->c_cc[LINUX_VWERASE];
 614         bios->c_cc[VLNEXT] = lios->c_cc[LINUX_VLNEXT];
 615
 616         for (i=0; i<NCCS; i++) {
 617                 if (i != VMIN && i != VTIME &&
 618                     bios->c_cc[i] == LINUX_POSIX_VDISABLE)
 619                         bios->c_cc[i] = _POSIX_VDISABLE;
 620         }
 621
 622         bios->c_ispeed = bios->c_ospeed =
 623             linux_to_bsd_speed(lios->c_cflag & LINUX_CBAUD, sptab);
 624
 625 #ifdef DEBUG
 626         if (ldebug(ioctl)) {
 627                 printf("LINUX: BSD termios structure (output):\n");
 628                 printf("i=%08x o=%08x c=%08x l=%08x ispeed=%d ospeed=%d\n",
 629                     bios->c_iflag, bios->c_oflag, bios->c_cflag, bios->c_lflag,
 630                     bios->c_ispeed, bios->c_ospeed);
 631                 printf("c_cc ");
 632                 for (i=0; i<NCCS; i++)
 633                         printf("%02x ", bios->c_cc[i]);
 634                 printf("\n");
 635         }
 636 #endif
 637 }
 638
 639 static void
 640 bsd_to_linux_termio(struct termios *bios, struct linux_termio *lio)
 641 {
 642         struct linux_termios lios;
 643
 644         bsd_to_linux_termios(bios, &lios);
 645         lio->c_iflag = lios.c_iflag;
 646         lio->c_oflag = lios.c_oflag;
 647         lio->c_cflag = lios.c_cflag;
 648         lio->c_lflag = lios.c_lflag;
 649         lio->c_line  = lios.c_line;
 650         memcpy(lio->c_cc, lios.c_cc, LINUX_NCC);
 651 }
 652
 653 static void
 654 linux_to_bsd_termio(struct linux_termio *lio, struct termios *bios)
 655 {
 656         struct linux_termios lios;
 657         int i;
 658
 659         lios.c_iflag = lio->c_iflag;
 660         lios.c_oflag = lio->c_oflag;
 661         lios.c_cflag = lio->c_cflag;
 662         lios.c_lflag = lio->c_lflag;
 663         for (i=LINUX_NCC; i<LINUX_NCCS; i++)
 664                 lios.c_cc[i] = LINUX_POSIX_VDISABLE;
 665         memcpy(lios.c_cc, lio->c_cc, LINUX_NCC);
 666         linux_to_bsd_termios(&lios, bios);
 667 }
 668
 669 static int
 670 linux_ioctl_termio(struct thread *td, struct linux_ioctl_args *args)
 671 {
 672         struct termios bios;
 673         struct linux_termios lios;
 674         struct linux_termio lio;
 675         struct file *fp;
 676         int error;
 677
 678         if ((error = fget(td, args->fd, &fp)) != 0)
 679                 return (error);
 680
 681         switch (args->cmd & 0xffff) {
 682
 683         case LINUX_TCGETS:
 684                 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td->td_ucred,
 685                     td);
 686                 if (error)
 687                         break;
 688                 bsd_to_linux_termios(&bios, &lios);
 689                 error = copyout(&lios, (void *)args->arg, sizeof(lios));
 690                 break;
 691
 692         case LINUX_TCSETS:
 693                 error = copyin((void *)args->arg, &lios, sizeof(lios));
 694                 if (error)
 695                         break;
 696                 linux_to_bsd_termios(&lios, &bios);
 697                 error = (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td->td_ucred,
 698                     td));
 699                 break;
 700
 701         case LINUX_TCSETSW:
 702                 error = copyin((void *)args->arg, &lios, sizeof(lios));
 703                 if (error)
 704                         break;
 705                 linux_to_bsd_termios(&lios, &bios);
 706                 error = (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td->td_ucred,
 707                     td));
 708                 break;
 709
 710         case LINUX_TCSETSF:
 711                 error = copyin((void *)args->arg, &lios, sizeof(lios));
 712                 if (error)
 713                         break;
 714                 linux_to_bsd_termios(&lios, &bios);
 715                 error = (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td->td_ucred,
 716                     td));
 717                 break;
 718
 719         case LINUX_TCGETA:
 720                 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td->td_ucred,
 721                     td);
 722                 if (error)
 723                         break;
 724                 bsd_to_linux_termio(&bios, &lio);
 725                 error = (copyout(&lio, (void *)args->arg, sizeof(lio)));
 726                 break;
 727
 728         case LINUX_TCSETA:
 729                 error = copyin((void *)args->arg, &lio, sizeof(lio));
 730                 if (error)
 731                         break;
 732                 linux_to_bsd_termio(&lio, &bios);
 733                 error = (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td->td_ucred,
 734                     td));
 735                 break;
 736
 737         case LINUX_TCSETAW:
 738                 error = copyin((void *)args->arg, &lio, sizeof(lio));
 739                 if (error)
 740                         break;
 741                 linux_to_bsd_termio(&lio, &bios);
 742                 error = (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td->td_ucred,
 743                     td));
 744                 break;
 745
 746         case LINUX_TCSETAF:
 747                 error = copyin((void *)args->arg, &lio, sizeof(lio));
 748                 if (error)
 749                         break;
 750                 linux_to_bsd_termio(&lio, &bios);
 751                 error = (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td->td_ucred,
 752                     td));
 753                 break;
 754
 755         /* LINUX_TCSBRK */
 756
 757         case LINUX_TCXONC: {
 758                 switch (args->arg) {
 759                 case LINUX_TCOOFF:
 760                         args->cmd = TIOCSTOP;
 761                         break;
 762                 case LINUX_TCOON:
 763                         args->cmd = TIOCSTART;
 764                         break;
 765                 case LINUX_TCIOFF:
 766                 case LINUX_TCION: {
 767                         int c;
 768                         struct write_args wr;
 769                         error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios,
 770                             td->td_ucred, td);
 771                         if (error)
 772                                 break;
 773                         fdrop(fp, td);
 774                         c = (args->arg == LINUX_TCIOFF) ? VSTOP : VSTART;
 775                         c = bios.c_cc[c];
 776                         if (c != _POSIX_VDISABLE) {
 777                                 wr.fd = args->fd;
 778                                 wr.buf = &c;
 779                                 wr.nbyte = sizeof(c);
 780                                 return (write(td, &wr));
 781                         } else
 782                                 return (0);
 783                 }
 784                 default:
 785                         fdrop(fp, td);
 786                         return (EINVAL);
 787                 }
 788                 args->arg = 0;
 789                 error = (ioctl(td, (struct ioctl_args *)args));
 790                 break;
 791         }
 792
 793         case LINUX_TCFLSH: {
 794                 int val;
 795                 switch (args->arg) {
 796                 case LINUX_TCIFLUSH:
 797                         val = FREAD;
 798                         break;
 799                 case LINUX_TCOFLUSH:
 800                         val = FWRITE;
 801                         break;
 802                 case LINUX_TCIOFLUSH:
 803                         val = FREAD | FWRITE;
 804                         break;
 805                 default:
 806                         fdrop(fp, td);
 807                         return (EINVAL);
 808                 }
 809                 error = (fo_ioctl(fp,TIOCFLUSH,(caddr_t)&val,td->td_ucred,td));
 810                 break;
 811         }
 812
 813         case LINUX_TIOCEXCL:
 814                 args->cmd = TIOCEXCL;
 815                 error = (ioctl(td, (struct ioctl_args *)args));
 816                 break;
 817
 818         case LINUX_TIOCNXCL:
 819                 args->cmd = TIOCNXCL;
 820                 error = (ioctl(td, (struct ioctl_args *)args));
 821                 break;
 822
 823         case LINUX_TIOCSCTTY:
 824                 args->cmd = TIOCSCTTY;
 825                 error = (ioctl(td, (struct ioctl_args *)args));
 826                 break;
 827
 828         case LINUX_TIOCGPGRP:
 829                 args->cmd = TIOCGPGRP;
 830                 error = (ioctl(td, (struct ioctl_args *)args));
 831                 break;
 832
 833         case LINUX_TIOCSPGRP:
 834                 args->cmd = TIOCSPGRP;
 835                 error = (ioctl(td, (struct ioctl_args *)args));
 836                 break;
 837
 838         /* LINUX_TIOCOUTQ */
 839         /* LINUX_TIOCSTI */
 840
 841         case LINUX_TIOCGWINSZ:
 842                 args->cmd = TIOCGWINSZ;
 843                 error = (ioctl(td, (struct ioctl_args *)args));
 844                 break;
 845
 846         case LINUX_TIOCSWINSZ:
 847                 args->cmd = TIOCSWINSZ;
 848                 error = (ioctl(td, (struct ioctl_args *)args));
 849                 break;
 850
 851         case LINUX_TIOCMGET:
 852                 args->cmd = TIOCMGET;
 853                 error = (ioctl(td, (struct ioctl_args *)args));
 854                 break;
 855
 856         case LINUX_TIOCMBIS:
 857                 args->cmd = TIOCMBIS;
 858                 error = (ioctl(td, (struct ioctl_args *)args));
 859                 break;
 860
 861         case LINUX_TIOCMBIC:
 862                 args->cmd = TIOCMBIC;
 863                 error = (ioctl(td, (struct ioctl_args *)args));
 864                 break;
 865
 866         case LINUX_TIOCMSET:
 867                 args->cmd = TIOCMSET;
 868                 error = (ioctl(td, (struct ioctl_args *)args));
 869                 break;
 870
 871         /* TIOCGSOFTCAR */
 872         /* TIOCSSOFTCAR */
 873
 874         case LINUX_FIONREAD: /* LINUX_TIOCINQ */
 875                 args->cmd = FIONREAD;
 876                 error = (ioctl(td, (struct ioctl_args *)args));
 877                 break;
 878
 879         /* LINUX_TIOCLINUX */
 880
 881         case LINUX_TIOCCONS:
 882                 args->cmd = TIOCCONS;
 883                 error = (ioctl(td, (struct ioctl_args *)args));
 884                 break;
 885
 886         case LINUX_TIOCGSERIAL: {
 887                 struct linux_serial_struct lss;
 888                 lss.type = LINUX_PORT_16550A;
 889                 lss.flags = 0;
 890                 lss.close_delay = 0;
 891                 error = copyout(&lss, (void *)args->arg, sizeof(lss));
 892                 break;
 893         }
 894
 895         case LINUX_TIOCSSERIAL: {
 896                 struct linux_serial_struct lss;
 897                 error = copyin((void *)args->arg, &lss, sizeof(lss));
 898                 if (error)
 899                         break;
 900                 /* XXX - It really helps to have an implementation that
 901                  * does nothing. NOT!
 902                  */
 903                 error = 0;
 904                 break;
 905         }
 906
 907         case LINUX_TIOCPKT:
 908                 args->cmd = TIOCPKT;
 909                 error = (ioctl(td, (struct ioctl_args *)args));
 910                 break;
 911
 912         case LINUX_FIONBIO:
 913                 args->cmd = FIONBIO;
 914                 error = (ioctl(td, (struct ioctl_args *)args));
 915                 break;
 916
 917         case LINUX_TIOCNOTTY:
 918                 args->cmd = TIOCNOTTY;
 919                 error = (ioctl(td, (struct ioctl_args *)args));
 920                 break;
 921
 922         case LINUX_TIOCSETD: {
 923                 int line;
 924                 switch (args->arg) {
 925                 case LINUX_N_TTY:
 926                         line = TTYDISC;
 927                         break;
 928                 case LINUX_N_SLIP:
 929                         line = SLIPDISC;
 930                         break;
 931                 case LINUX_N_PPP:
 932                         line = PPPDISC;
 933                         break;
 934                 default:
 935                         fdrop(fp, td);
 936                         return (EINVAL);
 937                 }
 938                 error = (fo_ioctl(fp, TIOCSETD, (caddr_t)&line, td->td_ucred,
 939                     td));
 940                 break;
 941         }
 942
 943         case LINUX_TIOCGETD: {
 944                 int linux_line;
 945                 int bsd_line = TTYDISC;
 946                 error = fo_ioctl(fp, TIOCGETD, (caddr_t)&bsd_line,
 947                     td->td_ucred, td);
 948                 if (error)
 949                         return (error);
 950                 switch (bsd_line) {
 951                 case TTYDISC:
 952                         linux_line = LINUX_N_TTY;
 953                         break;
 954                 case SLIPDISC:
 955                         linux_line = LINUX_N_SLIP;
 956                         break;
 957                 case PPPDISC:
 958                         linux_line = LINUX_N_PPP;
 959                         break;
 960                 default:
 961                         fdrop(fp, td);
 962                         return (EINVAL);
 963                 }
 964                 error = (copyout(&linux_line, (void *)args->arg, sizeof(int)));
 965                 break;
 966         }
 967
 968         /* LINUX_TCSBRKP */
 969         /* LINUX_TIOCTTYGSTRUCT */
 970
 971         case LINUX_FIONCLEX:
 972                 args->cmd = FIONCLEX;
 973                 error = (ioctl(td, (struct ioctl_args *)args));
 974                 break;
 975
 976         case LINUX_FIOCLEX:
 977                 args->cmd = FIOCLEX;
 978                 error = (ioctl(td, (struct ioctl_args *)args));
 979                 break;
 980
 981         case LINUX_FIOASYNC:
 982                 args->cmd = FIOASYNC;
 983                 error = (ioctl(td, (struct ioctl_args *)args));
 984                 break;
 985
 986         /* LINUX_TIOCSERCONFIG */
 987         /* LINUX_TIOCSERGWILD */
 988         /* LINUX_TIOCSERSWILD */
 989         /* LINUX_TIOCGLCKTRMIOS */
 990         /* LINUX_TIOCSLCKTRMIOS */
 991
 992         case LINUX_TIOCSBRK:
 993                 args->cmd = TIOCSBRK;
 994                 error = (ioctl(td, (struct ioctl_args *)args));
 995                 break;
 996
 997         case LINUX_TIOCCBRK:
 998                 args->cmd = TIOCCBRK;
 999                 error = (ioctl(td, (struct ioctl_args *)args));
1000                 break;
1001         case LINUX_TIOCGPTN: {
1002                 int nb;
1003
1004                 error = fo_ioctl(fp, TIOCGPTN, (caddr_t)&nb, td->td_ucred, td);
1005                 if (!error)
1006                         error = copyout(&nb, (void *)args->arg,
1007                             sizeof(int));
1008                 break;
1009         }
1010         case LINUX_TIOCSPTLCK:
1011                 /* Our unlockpt() does nothing. */
1012                 error = 0;
1013                 break;
1014         default:
1015                 error = ENOIOCTL;
1016                 break;
1017         }
1018
1019         fdrop(fp, td);
1020         return (error);
1021 }
1022
1023 /*
1024  * CDROM related ioctls
1025  */
1026
1027 struct linux_cdrom_msf
1028 {
1029         u_char  cdmsf_min0;
1030         u_char  cdmsf_sec0;
1031         u_char  cdmsf_frame0;
1032         u_char  cdmsf_min1;
1033         u_char  cdmsf_sec1;
1034         u_char  cdmsf_frame1;
1035 };
1036
1037 struct linux_cdrom_tochdr
1038 {
1039         u_char  cdth_trk0;
1040         u_char  cdth_trk1;
1041 };
1042
1043 union linux_cdrom_addr
1044 {
1045         struct {
1046                 u_char  minute;
1047                 u_char  second;
1048                 u_char  frame;
1049         } msf;
1050         int     lba;
1051 };
1052
1053 struct linux_cdrom_tocentry
1054 {
1055         u_char  cdte_track;
1056         u_char  cdte_adr:4;
1057         u_char  cdte_ctrl:4;
1058         u_char  cdte_format;
1059         union linux_cdrom_addr cdte_addr;
1060         u_char  cdte_datamode;
1061 };
1062
1063 struct linux_cdrom_subchnl
1064 {
1065         u_char  cdsc_format;
1066         u_char  cdsc_audiostatus;
1067         u_char  cdsc_adr:4;
1068         u_char  cdsc_ctrl:4;
1069         u_char  cdsc_trk;
1070         u_char  cdsc_ind;
1071         union linux_cdrom_addr cdsc_absaddr;
1072         union linux_cdrom_addr cdsc_reladdr;
1073 };
1074
1075 struct l_cdrom_read_audio {
1076         union linux_cdrom_addr addr;
1077         u_char          addr_format;
1078         l_int           nframes;
1079         u_char          *buf;
1080 };
1081
1082 struct l_dvd_layer {
1083         u_char          book_version:4;
1084         u_char          book_type:4;
1085         u_char          min_rate:4;
1086         u_char          disc_size:4;
1087         u_char          layer_type:4;
1088         u_char          track_path:1;
1089         u_char          nlayers:2;
1090         u_char          track_density:4;
1091         u_char          linear_density:4;
1092         u_char          bca:1;
1093         u_int32_t       start_sector;
1094         u_int32_t       end_sector;
1095         u_int32_t       end_sector_l0;
1096 };
1097
1098 struct l_dvd_physical {
1099         u_char          type;
1100         u_char          layer_num;
1101         struct l_dvd_layer layer[4];
1102 };
1103
1104 struct l_dvd_copyright {
1105         u_char          type;
1106         u_char          layer_num;
1107         u_char          cpst;
1108         u_char          rmi;
1109 };
1110
1111 struct l_dvd_disckey {
1112         u_char          type;
1113         l_uint          agid:2;
1114         u_char          value[2048];
1115 };
1116
1117 struct l_dvd_bca {
1118         u_char          type;
1119         l_int           len;
1120         u_char          value[188];
1121 };
1122
1123 struct l_dvd_manufact {
1124         u_char          type;
1125         u_char          layer_num;
1126         l_int           len;
1127         u_char          value[2048];
1128 };
1129
1130 typedef union {
1131         u_char                  type;
1132         struct l_dvd_physical   physical;
1133         struct l_dvd_copyright  copyright;
1134         struct l_dvd_disckey    disckey;
1135         struct l_dvd_bca        bca;
1136         struct l_dvd_manufact   manufact;
1137 } l_dvd_struct;
1138
1139 typedef u_char l_dvd_key[5];
1140 typedef u_char l_dvd_challenge[10];
1141
1142 struct l_dvd_lu_send_agid {
1143         u_char          type;
1144         l_uint          agid:2;
1145 };
1146
1147 struct l_dvd_host_send_challenge {
1148         u_char          type;
1149         l_uint          agid:2;
1150         l_dvd_challenge chal;
1151 };
1152
1153 struct l_dvd_send_key {
1154         u_char          type;
1155         l_uint          agid:2;
1156         l_dvd_key       key;
1157 };
1158
1159 struct l_dvd_lu_send_challenge {
1160         u_char          type;
1161         l_uint          agid:2;
1162         l_dvd_challenge chal;
1163 };
1164
1165 struct l_dvd_lu_send_title_key {
1166         u_char          type;
1167         l_uint          agid:2;
1168         l_dvd_key       title_key;
1169         l_int           lba;
1170         l_uint          cpm:1;
1171         l_uint          cp_sec:1;
1172         l_uint          cgms:2;
1173 };
1174
1175 struct l_dvd_lu_send_asf {
1176         u_char          type;
1177         l_uint          agid:2;
1178         l_uint          asf:1;
1179 };
1180
1181 struct l_dvd_host_send_rpcstate {
1182         u_char          type;
1183         u_char          pdrc;
1184 };
1185
1186 struct l_dvd_lu_send_rpcstate {
1187         u_char          type:2;
1188         u_char          vra:3;
1189         u_char          ucca:3;
1190         u_char          region_mask;
1191         u_char          rpc_scheme;
1192 };
1193
1194 typedef union {
1195         u_char                          type;
1196         struct l_dvd_lu_send_agid       lsa;
1197         struct l_dvd_host_send_challenge hsc;
1198         struct l_dvd_send_key           lsk;
1199         struct l_dvd_lu_send_challenge  lsc;
1200         struct l_dvd_send_key           hsk;
1201         struct l_dvd_lu_send_title_key  lstk;
1202         struct l_dvd_lu_send_asf        lsasf;
1203         struct l_dvd_host_send_rpcstate hrpcs;
1204         struct l_dvd_lu_send_rpcstate   lrpcs;
1205 } l_dvd_authinfo;
1206
1207 static void
1208 bsd_to_linux_msf_lba(u_char af, union msf_lba *bp, union linux_cdrom_addr *lp)
1209 {
1210         if (af == CD_LBA_FORMAT)
1211                 lp->lba = bp->lba;
1212         else {
1213                 lp->msf.minute = bp->msf.minute;
1214                 lp->msf.second = bp->msf.second;
1215                 lp->msf.frame = bp->msf.frame;
1216         }
1217 }
1218
1219 static void
1220 set_linux_cdrom_addr(union linux_cdrom_addr *addr, int format, int lba)
1221 {
1222         if (format == LINUX_CDROM_MSF) {
1223                 addr->msf.frame = lba % 75;
1224                 lba /= 75;
1225                 lba += 2;
1226                 addr->msf.second = lba % 60;
1227                 addr->msf.minute = lba / 60;
1228         } else
1229                 addr->lba = lba;
1230 }
1231
1232 static int
1233 linux_to_bsd_dvd_struct(l_dvd_struct *lp, struct dvd_struct *bp)
1234 {
1235         bp->format = lp->type;
1236         switch (bp->format) {
1237         case DVD_STRUCT_PHYSICAL:
1238                 if (bp->layer_num >= 4)
1239                         return (EINVAL);
1240                 bp->layer_num = lp->physical.layer_num;
1241                 break;
1242         case DVD_STRUCT_COPYRIGHT:
1243                 bp->layer_num = lp->copyright.layer_num;
1244                 break;
1245         case DVD_STRUCT_DISCKEY:
1246                 bp->agid = lp->disckey.agid;
1247                 break;
1248         case DVD_STRUCT_BCA:
1249         case DVD_STRUCT_MANUFACT:
1250                 break;
1251         default:
1252                 return (EINVAL);
1253         }
1254         return (0);
1255 }
1256
1257 static int
1258 bsd_to_linux_dvd_struct(struct dvd_struct *bp, l_dvd_struct *lp)
1259 {
1260         switch (bp->format) {
1261         case DVD_STRUCT_PHYSICAL: {
1262                 struct dvd_layer *blp = (struct dvd_layer *)bp->data;
1263                 struct l_dvd_layer *llp = &lp->physical.layer[bp->layer_num];
1264                 memset(llp, 0, sizeof(*llp));
1265                 llp->book_version = blp->book_version;
1266                 llp->book_type = blp->book_type;
1267                 llp->min_rate = blp->max_rate;
1268                 llp->disc_size = blp->disc_size;
1269                 llp->layer_type = blp->layer_type;
1270                 llp->track_path = blp->track_path;
1271                 llp->nlayers = blp->nlayers;
1272                 llp->track_density = blp->track_density;
1273                 llp->linear_density = blp->linear_density;
1274                 llp->bca = blp->bca;
1275                 llp->start_sector = blp->start_sector;
1276                 llp->end_sector = blp->end_sector;
1277                 llp->end_sector_l0 = blp->end_sector_l0;
1278                 break;
1279         }
1280         case DVD_STRUCT_COPYRIGHT:
1281                 lp->copyright.cpst = bp->cpst;
1282                 lp->copyright.rmi = bp->rmi;
1283                 break;
1284         case DVD_STRUCT_DISCKEY:
1285                 memcpy(lp->disckey.value, bp->data, sizeof(lp->disckey.value));
1286                 break;
1287         case DVD_STRUCT_BCA:
1288                 lp->bca.len = bp->length;
1289                 memcpy(lp->bca.value, bp->data, sizeof(lp->bca.value));
1290                 break;
1291         case DVD_STRUCT_MANUFACT:
1292                 lp->manufact.len = bp->length;
1293                 memcpy(lp->manufact.value, bp->data,
1294                     sizeof(lp->manufact.value));
1295                 /* lp->manufact.layer_num is unused in linux (redhat 7.0) */
1296                 break;
1297         default:
1298                 return (EINVAL);
1299         }
1300         return (0);
1301 }
1302
1303 static int
1304 linux_to_bsd_dvd_authinfo(l_dvd_authinfo *lp, int *bcode,
1305     struct dvd_authinfo *bp)
1306 {
1307         switch (lp->type) {
1308         case LINUX_DVD_LU_SEND_AGID:
1309                 *bcode = DVDIOCREPORTKEY;
1310                 bp->format = DVD_REPORT_AGID;
1311                 bp->agid = lp->lsa.agid;
1312                 break;
1313         case LINUX_DVD_HOST_SEND_CHALLENGE:
1314                 *bcode = DVDIOCSENDKEY;
1315                 bp->format = DVD_SEND_CHALLENGE;
1316                 bp->agid = lp->hsc.agid;
1317                 memcpy(bp->keychal, lp->hsc.chal, 10);
1318                 break;
1319         case LINUX_DVD_LU_SEND_KEY1:
1320                 *bcode = DVDIOCREPORTKEY;
1321                 bp->format = DVD_REPORT_KEY1;
1322                 bp->agid = lp->lsk.agid;
1323                 break;
1324         case LINUX_DVD_LU_SEND_CHALLENGE:
1325                 *bcode = DVDIOCREPORTKEY;
1326                 bp->format = DVD_REPORT_CHALLENGE;
1327                 bp->agid = lp->lsc.agid;
1328                 break;
1329         case LINUX_DVD_HOST_SEND_KEY2:
1330                 *bcode = DVDIOCSENDKEY;
1331                 bp->format = DVD_SEND_KEY2;
1332                 bp->agid = lp->hsk.agid;
1333                 memcpy(bp->keychal, lp->hsk.key, 5);
1334                 break;
1335         case LINUX_DVD_LU_SEND_TITLE_KEY:
1336                 *bcode = DVDIOCREPORTKEY;
1337                 bp->format = DVD_REPORT_TITLE_KEY;
1338                 bp->agid = lp->lstk.agid;
1339                 bp->lba = lp->lstk.lba;
1340                 break;
1341         case LINUX_DVD_LU_SEND_ASF:
1342                 *bcode = DVDIOCREPORTKEY;
1343                 bp->format = DVD_REPORT_ASF;
1344                 bp->agid = lp->lsasf.agid;
1345                 break;
1346         case LINUX_DVD_INVALIDATE_AGID:
1347                 *bcode = DVDIOCREPORTKEY;
1348                 bp->format = DVD_INVALIDATE_AGID;
1349                 bp->agid = lp->lsa.agid;
1350                 break;
1351         case LINUX_DVD_LU_SEND_RPC_STATE:
1352                 *bcode = DVDIOCREPORTKEY;
1353                 bp->format = DVD_REPORT_RPC;
1354                 break;
1355         case LINUX_DVD_HOST_SEND_RPC_STATE:
1356                 *bcode = DVDIOCSENDKEY;
1357                 bp->format = DVD_SEND_RPC;
1358                 bp->region = lp->hrpcs.pdrc;
1359                 break;
1360         default:
1361                 return (EINVAL);
1362         }
1363         return (0);
1364 }
1365
1366 static int
1367 bsd_to_linux_dvd_authinfo(struct dvd_authinfo *bp, l_dvd_authinfo *lp)
1368 {
1369         switch (lp->type) {
1370         case LINUX_DVD_LU_SEND_AGID:
1371                 lp->lsa.agid = bp->agid;
1372                 break;
1373         case LINUX_DVD_HOST_SEND_CHALLENGE:
1374                 lp->type = LINUX_DVD_LU_SEND_KEY1;
1375                 break;
1376         case LINUX_DVD_LU_SEND_KEY1:
1377                 memcpy(lp->lsk.key, bp->keychal, sizeof(lp->lsk.key));
1378                 break;
1379         case LINUX_DVD_LU_SEND_CHALLENGE:
1380                 memcpy(lp->lsc.chal, bp->keychal, sizeof(lp->lsc.chal));
1381                 break;
1382         case LINUX_DVD_HOST_SEND_KEY2:
1383                 lp->type = LINUX_DVD_AUTH_ESTABLISHED;
1384                 break;
1385         case LINUX_DVD_LU_SEND_TITLE_KEY:
1386                 memcpy(lp->lstk.title_key, bp->keychal,
1387                     sizeof(lp->lstk.title_key));
1388                 lp->lstk.cpm = bp->cpm;
1389                 lp->lstk.cp_sec = bp->cp_sec;
1390                 lp->lstk.cgms = bp->cgms;
1391                 break;
1392         case LINUX_DVD_LU_SEND_ASF:
1393                 lp->lsasf.asf = bp->asf;
1394                 break;
1395         case LINUX_DVD_INVALIDATE_AGID:
1396                 break;
1397         case LINUX_DVD_LU_SEND_RPC_STATE:
1398                 lp->lrpcs.type = bp->reg_type;
1399                 lp->lrpcs.vra = bp->vend_rsts;
1400                 lp->lrpcs.ucca = bp->user_rsts;
1401                 lp->lrpcs.region_mask = bp->region;
1402                 lp->lrpcs.rpc_scheme = bp->rpc_scheme;
1403                 break;
1404         case LINUX_DVD_HOST_SEND_RPC_STATE:
1405                 break;
1406         default:
1407                 return (EINVAL);
1408         }
1409         return (0);
1410 }
1411
1412 static int
1413 linux_ioctl_cdrom(struct thread *td, struct linux_ioctl_args *args)
1414 {
1415         struct file *fp;
1416         int error;
1417
1418         if ((error = fget(td, args->fd, &fp)) != 0)
1419                 return (error);
1420         switch (args->cmd & 0xffff) {
1421
1422         case LINUX_CDROMPAUSE:
1423                 args->cmd = CDIOCPAUSE;
1424                 error = (ioctl(td, (struct ioctl_args *)args));
1425                 break;
1426
1427         case LINUX_CDROMRESUME:
1428                 args->cmd = CDIOCRESUME;
1429                 error = (ioctl(td, (struct ioctl_args *)args));
1430                 break;
1431
1432         case LINUX_CDROMPLAYMSF:
1433                 args->cmd = CDIOCPLAYMSF;
1434                 error = (ioctl(td, (struct ioctl_args *)args));
1435                 break;
1436
1437         case LINUX_CDROMPLAYTRKIND:
1438                 args->cmd = CDIOCPLAYTRACKS;
1439                 error = (ioctl(td, (struct ioctl_args *)args));
1440                 break;
1441
1442         case LINUX_CDROMREADTOCHDR: {
1443                 struct ioc_toc_header th;
1444                 struct linux_cdrom_tochdr lth;
1445                 error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&th,
1446                     td->td_ucred, td);
1447                 if (!error) {
1448                         lth.cdth_trk0 = th.starting_track;
1449                         lth.cdth_trk1 = th.ending_track;
1450                         copyout(&lth, (void *)args->arg, sizeof(lth));
1451                 }
1452                 break;
1453         }
1454
1455         case LINUX_CDROMREADTOCENTRY: {
1456                 struct linux_cdrom_tocentry lte;
1457                 struct ioc_read_toc_single_entry irtse;
1458
1459                 error = copyin((void *)args->arg, &lte, sizeof(lte));
1460                 if (error)
1461                         break;
1462                 irtse.address_format = lte.cdte_format;
1463                 irtse.track = lte.cdte_track;
1464                 error = fo_ioctl(fp, CDIOREADTOCENTRY, (caddr_t)&irtse,
1465                     td->td_ucred, td);
1466                 if (!error) {
1467                         lte.cdte_ctrl = irtse.entry.control;
1468                         lte.cdte_adr = irtse.entry.addr_type;
1469                         bsd_to_linux_msf_lba(irtse.address_format,
1470                             &irtse.entry.addr, &lte.cdte_addr);
1471                         error = copyout(&lte, (void *)args->arg, sizeof(lte));
1472                 }
1473                 break;
1474         }
1475
1476         case LINUX_CDROMSTOP:
1477                 args->cmd = CDIOCSTOP;
1478                 error = (ioctl(td, (struct ioctl_args *)args));
1479                 break;
1480
1481         case LINUX_CDROMSTART:
1482                 args->cmd = CDIOCSTART;
1483                 error = (ioctl(td, (struct ioctl_args *)args));
1484                 break;
1485
1486         case LINUX_CDROMEJECT:
1487                 args->cmd = CDIOCEJECT;
1488                 error = (ioctl(td, (struct ioctl_args *)args));
1489                 break;
1490
1491         /* LINUX_CDROMVOLCTRL */
1492
1493         case LINUX_CDROMSUBCHNL: {
1494                 struct linux_cdrom_subchnl sc;
1495                 struct ioc_read_subchannel bsdsc;
1496                 struct cd_sub_channel_info bsdinfo;
1497
1498                 bsdsc.address_format = CD_LBA_FORMAT;
1499                 bsdsc.data_format = CD_CURRENT_POSITION;
1500                 bsdsc.track = 0;
1501                 bsdsc.data_len = sizeof(bsdinfo);
1502                 bsdsc.data = &bsdinfo;
1503                 error = fo_ioctl(fp, CDIOCREADSUBCHANNEL_SYSSPACE,
1504                     (caddr_t)&bsdsc, td->td_ucred, td);
1505                 if (error)
1506                         break;
1507                 error = copyin((void *)args->arg, &sc, sizeof(sc));
1508                 if (error)
1509                         break;
1510                 sc.cdsc_audiostatus = bsdinfo.header.audio_status;
1511                 sc.cdsc_adr = bsdinfo.what.position.addr_type;
1512                 sc.cdsc_ctrl = bsdinfo.what.position.control;
1513                 sc.cdsc_trk = bsdinfo.what.position.track_number;
1514                 sc.cdsc_ind = bsdinfo.what.position.index_number;
1515                 set_linux_cdrom_addr(&sc.cdsc_absaddr, sc.cdsc_format,
1516                     bsdinfo.what.position.absaddr.lba);
1517                 set_linux_cdrom_addr(&sc.cdsc_reladdr, sc.cdsc_format,
1518                     bsdinfo.what.position.reladdr.lba);
1519                 error = copyout(&sc, (void *)args->arg, sizeof(sc));
1520                 break;
1521         }
1522
1523         /* LINUX_CDROMREADMODE2 */
1524         /* LINUX_CDROMREADMODE1 */
1525         /* LINUX_CDROMREADAUDIO */
1526         /* LINUX_CDROMEJECT_SW */
1527         /* LINUX_CDROMMULTISESSION */
1528         /* LINUX_CDROM_GET_UPC */
1529
1530         case LINUX_CDROMRESET:
1531                 args->cmd = CDIOCRESET;
1532                 error = (ioctl(td, (struct ioctl_args *)args));
1533                 break;
1534
1535         /* LINUX_CDROMVOLREAD */
1536         /* LINUX_CDROMREADRAW */
1537         /* LINUX_CDROMREADCOOKED */
1538         /* LINUX_CDROMSEEK */
1539         /* LINUX_CDROMPLAYBLK */
1540         /* LINUX_CDROMREADALL */
1541         /* LINUX_CDROMCLOSETRAY */
1542         /* LINUX_CDROMLOADFROMSLOT */
1543         /* LINUX_CDROMGETSPINDOWN */
1544         /* LINUX_CDROMSETSPINDOWN */
1545         /* LINUX_CDROM_SET_OPTIONS */
1546         /* LINUX_CDROM_CLEAR_OPTIONS */
1547         /* LINUX_CDROM_SELECT_SPEED */
1548         /* LINUX_CDROM_SELECT_DISC */
1549         /* LINUX_CDROM_MEDIA_CHANGED */
1550         /* LINUX_CDROM_DRIVE_STATUS */
1551         /* LINUX_CDROM_DISC_STATUS */
1552         /* LINUX_CDROM_CHANGER_NSLOTS */
1553         /* LINUX_CDROM_LOCKDOOR */
1554         /* LINUX_CDROM_DEBUG */
1555         /* LINUX_CDROM_GET_CAPABILITY */
1556         /* LINUX_CDROMAUDIOBUFSIZ */
1557
1558         case LINUX_DVD_READ_STRUCT: {
1559                 l_dvd_struct *lds;
1560                 struct dvd_struct *bds;
1561
1562                 lds = malloc(sizeof(*lds), M_LINUX, M_WAITOK);
1563                 bds = malloc(sizeof(*bds), M_LINUX, M_WAITOK);
1564                 error = copyin((void *)args->arg, lds, sizeof(*lds));
1565                 if (error)
1566                         goto out;
1567                 error = linux_to_bsd_dvd_struct(lds, bds);
1568                 if (error)
1569                         goto out;
1570                 error = fo_ioctl(fp, DVDIOCREADSTRUCTURE, (caddr_t)bds,
1571                     td->td_ucred, td);
1572                 if (error)
1573                         goto out;
1574                 error = bsd_to_linux_dvd_struct(bds, lds);
1575                 if (error)
1576                         goto out;
1577                 error = copyout(lds, (void *)args->arg, sizeof(*lds));
1578         out:
1579                 free(bds, M_LINUX);
1580                 free(lds, M_LINUX);
1581                 break;
1582         }
1583
1584         /* LINUX_DVD_WRITE_STRUCT */
1585
1586         case LINUX_DVD_AUTH: {
1587                 l_dvd_authinfo lda;
1588                 struct dvd_authinfo bda;
1589                 int bcode;
1590
1591                 error = copyin((void *)args->arg, &lda, sizeof(lda));
1592                 if (error)
1593                         break;
1594                 error = linux_to_bsd_dvd_authinfo(&lda, &bcode, &bda);
1595                 if (error)
1596                         break;
1597                 error = fo_ioctl(fp, bcode, (caddr_t)&bda, td->td_ucred,
1598                     td);
1599                 if (error) {
1600                         if (lda.type == LINUX_DVD_HOST_SEND_KEY2) {
1601                                 lda.type = LINUX_DVD_AUTH_FAILURE;
1602                                 copyout(&lda, (void *)args->arg, sizeof(lda));
1603                         }
1604                         break;
1605                 }
1606                 error = bsd_to_linux_dvd_authinfo(&bda, &lda);
1607                 if (error)
1608                         break;
1609                 error = copyout(&lda, (void *)args->arg, sizeof(lda));
1610                 break;
1611         }
1612
1613         case LINUX_SCSI_GET_BUS_NUMBER:
1614         case LINUX_SCSI_GET_IDLUN:
1615                 error = linux_ioctl_sg(td, args);
1616                 break;
1617
1618         /* LINUX_CDROM_SEND_PACKET */
1619         /* LINUX_CDROM_NEXT_WRITABLE */
1620         /* LINUX_CDROM_LAST_WRITTEN */
1621
1622         default:
1623                 error = ENOIOCTL;
1624                 break;
1625         }
1626
1627         fdrop(fp, td);
1628         return (error);
1629 }
1630
1631 static int
1632 linux_ioctl_vfat(struct thread *td, struct linux_ioctl_args *args)
1633 {
1634
1635         return (ENOTTY);
1636 }
1637
1638 /*
1639  * Sound related ioctls
1640  */
1641
1642 struct linux_mixer_info {
1643         char    id[16];
1644         char    name[32];
1645         int     modify_counter;
1646         int     fillers[10];
1647 };
1648
1649 struct linux_old_mixer_info {
1650         char    id[16];
1651         char    name[32];
1652 };
1653
1654 static u_int32_t dirbits[4] = { IOC_VOID, IOC_IN, IOC_OUT, IOC_INOUT };
1655
1656 #define SETDIR(c)       (((c) & ~IOC_DIRMASK) | dirbits[args->cmd >> 30])
1657
1658 static int
1659 linux_ioctl_sound(struct thread *td, struct linux_ioctl_args *args)
1660 {
1661
1662         switch (args->cmd & 0xffff) {
1663
1664         case LINUX_SOUND_MIXER_WRITE_VOLUME:
1665                 args->cmd = SETDIR(SOUND_MIXER_WRITE_VOLUME);
1666                 return (ioctl(td, (struct ioctl_args *)args));
1667
1668         case LINUX_SOUND_MIXER_WRITE_BASS:
1669                 args->cmd = SETDIR(SOUND_MIXER_WRITE_BASS);
1670                 return (ioctl(td, (struct ioctl_args *)args));
1671
1672         case LINUX_SOUND_MIXER_WRITE_TREBLE:
1673                 args->cmd = SETDIR(SOUND_MIXER_WRITE_TREBLE);
1674                 return (ioctl(td, (struct ioctl_args *)args));
1675
1676         case LINUX_SOUND_MIXER_WRITE_SYNTH:
1677                 args->cmd = SETDIR(SOUND_MIXER_WRITE_SYNTH);
1678                 return (ioctl(td, (struct ioctl_args *)args));
1679
1680         case LINUX_SOUND_MIXER_WRITE_PCM:
1681                 args->cmd = SETDIR(SOUND_MIXER_WRITE_PCM);
1682                 return (ioctl(td, (struct ioctl_args *)args));
1683
1684         case LINUX_SOUND_MIXER_WRITE_SPEAKER:
1685                 args->cmd = SETDIR(SOUND_MIXER_WRITE_SPEAKER);
1686                 return (ioctl(td, (struct ioctl_args *)args));
1687
1688         case LINUX_SOUND_MIXER_WRITE_LINE:
1689                 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE);
1690                 return (ioctl(td, (struct ioctl_args *)args));
1691
1692         case LINUX_SOUND_MIXER_WRITE_MIC:
1693                 args->cmd = SETDIR(SOUND_MIXER_WRITE_MIC);
1694                 return (ioctl(td, (struct ioctl_args *)args));
1695
1696         case LINUX_SOUND_MIXER_WRITE_CD:
1697                 args->cmd = SETDIR(SOUND_MIXER_WRITE_CD);
1698                 return (ioctl(td, (struct ioctl_args *)args));
1699
1700         case LINUX_SOUND_MIXER_WRITE_IMIX:
1701                 args->cmd = SETDIR(SOUND_MIXER_WRITE_IMIX);
1702                 return (ioctl(td, (struct ioctl_args *)args));
1703
1704         case LINUX_SOUND_MIXER_WRITE_ALTPCM:
1705                 args->cmd = SETDIR(SOUND_MIXER_WRITE_ALTPCM);
1706                 return (ioctl(td, (struct ioctl_args *)args));
1707
1708         case LINUX_SOUND_MIXER_WRITE_RECLEV:
1709                 args->cmd = SETDIR(SOUND_MIXER_WRITE_RECLEV);
1710                 return (ioctl(td, (struct ioctl_args *)args));
1711
1712         case LINUX_SOUND_MIXER_WRITE_IGAIN:
1713                 args->cmd = SETDIR(SOUND_MIXER_WRITE_IGAIN);
1714                 return (ioctl(td, (struct ioctl_args *)args));
1715
1716         case LINUX_SOUND_MIXER_WRITE_OGAIN:
1717                 args->cmd = SETDIR(SOUND_MIXER_WRITE_OGAIN);
1718                 return (ioctl(td, (struct ioctl_args *)args));
1719
1720         case LINUX_SOUND_MIXER_WRITE_LINE1:
1721                 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE1);
1722                 return (ioctl(td, (struct ioctl_args *)args));
1723
1724         case LINUX_SOUND_MIXER_WRITE_LINE2:
1725                 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE2);
1726                 return (ioctl(td, (struct ioctl_args *)args));
1727
1728         case LINUX_SOUND_MIXER_WRITE_LINE3:
1729                 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE3);
1730                 return (ioctl(td, (struct ioctl_args *)args));
1731
1732         case LINUX_SOUND_MIXER_INFO: {
1733                 /* Key on encoded length */
1734                 switch ((args->cmd >> 16) & 0x1fff) {
1735                 case 0x005c: {  /* SOUND_MIXER_INFO */
1736                         struct linux_mixer_info info;
1737                         bzero(&info, sizeof(info));
1738                         strncpy(info.id, "OSS", sizeof(info.id) - 1);
1739                         strncpy(info.name, "FreeBSD OSS Mixer", sizeof(info.name) - 1);
1740                         copyout(&info, (void *)args->arg, sizeof(info));
1741                         break;
1742                 }
1743                 case 0x0030: {  /* SOUND_OLD_MIXER_INFO */
1744                         struct linux_old_mixer_info info;
1745                         bzero(&info, sizeof(info));
1746                         strncpy(info.id, "OSS", sizeof(info.id) - 1);
1747                         strncpy(info.name, "FreeBSD OSS Mixer", sizeof(info.name) - 1);
1748                         copyout(&info, (void *)args->arg, sizeof(info));
1749                         break;
1750                 }
1751                 default:
1752                         return (ENOIOCTL);
1753                 }
1754                 break;
1755         }
1756
1757         case LINUX_OSS_GETVERSION: {
1758                 int version = linux_get_oss_version(td);
1759                 return (copyout(&version, (void *)args->arg, sizeof(int)));
1760         }
1761
1762         case LINUX_SOUND_MIXER_READ_STEREODEVS:
1763                 args->cmd = SOUND_MIXER_READ_STEREODEVS;
1764                 return (ioctl(td, (struct ioctl_args *)args));
1765
1766         case LINUX_SOUND_MIXER_READ_RECMASK:
1767                 args->cmd = SOUND_MIXER_READ_RECMASK;
1768                 return (ioctl(td, (struct ioctl_args *)args));
1769
1770         case LINUX_SOUND_MIXER_READ_DEVMASK:
1771                 args->cmd = SOUND_MIXER_READ_DEVMASK;
1772                 return (ioctl(td, (struct ioctl_args *)args));
1773
1774         case LINUX_SOUND_MIXER_WRITE_RECSRC:
1775                 args->cmd = SETDIR(SOUND_MIXER_WRITE_RECSRC);
1776                 return (ioctl(td, (struct ioctl_args *)args));
1777
1778         case LINUX_SNDCTL_DSP_RESET:
1779                 args->cmd = SNDCTL_DSP_RESET;
1780                 return (ioctl(td, (struct ioctl_args *)args));
1781
1782         case LINUX_SNDCTL_DSP_SYNC:
1783                 args->cmd = SNDCTL_DSP_SYNC;
1784                 return (ioctl(td, (struct ioctl_args *)args));
1785
1786         case LINUX_SNDCTL_DSP_SPEED:
1787                 args->cmd = SNDCTL_DSP_SPEED;
1788                 return (ioctl(td, (struct ioctl_args *)args));
1789
1790         case LINUX_SNDCTL_DSP_STEREO:
1791                 args->cmd = SNDCTL_DSP_STEREO;
1792                 return (ioctl(td, (struct ioctl_args *)args));
1793
1794         case LINUX_SNDCTL_DSP_GETBLKSIZE: /* LINUX_SNDCTL_DSP_SETBLKSIZE */
1795                 args->cmd = SNDCTL_DSP_GETBLKSIZE;
1796                 return (ioctl(td, (struct ioctl_args *)args));
1797
1798         case LINUX_SNDCTL_DSP_SETFMT:
1799                 args->cmd = SNDCTL_DSP_SETFMT;
1800                 return (ioctl(td, (struct ioctl_args *)args));
1801
1802         case LINUX_SOUND_PCM_WRITE_CHANNELS:
1803                 args->cmd = SOUND_PCM_WRITE_CHANNELS;
1804                 return (ioctl(td, (struct ioctl_args *)args));
1805
1806         case LINUX_SOUND_PCM_WRITE_FILTER:
1807                 args->cmd = SOUND_PCM_WRITE_FILTER;
1808                 return (ioctl(td, (struct ioctl_args *)args));
1809
1810         case LINUX_SNDCTL_DSP_POST:
1811                 args->cmd = SNDCTL_DSP_POST;
1812                 return (ioctl(td, (struct ioctl_args *)args));
1813
1814         case LINUX_SNDCTL_DSP_SUBDIVIDE:
1815                 args->cmd = SNDCTL_DSP_SUBDIVIDE;
1816                 return (ioctl(td, (struct ioctl_args *)args));
1817
1818         case LINUX_SNDCTL_DSP_SETFRAGMENT:
1819                 args->cmd = SNDCTL_DSP_SETFRAGMENT;
1820                 return (ioctl(td, (struct ioctl_args *)args));
1821
1822         case LINUX_SNDCTL_DSP_GETFMTS:
1823                 args->cmd = SNDCTL_DSP_GETFMTS;
1824                 return (ioctl(td, (struct ioctl_args *)args));
1825
1826         case LINUX_SNDCTL_DSP_GETOSPACE:
1827                 args->cmd = SNDCTL_DSP_GETOSPACE;
1828                 return (ioctl(td, (struct ioctl_args *)args));
1829
1830         case LINUX_SNDCTL_DSP_GETISPACE:
1831                 args->cmd = SNDCTL_DSP_GETISPACE;
1832                 return (ioctl(td, (struct ioctl_args *)args));
1833
1834         case LINUX_SNDCTL_DSP_NONBLOCK:
1835                 args->cmd = SNDCTL_DSP_NONBLOCK;
1836                 return (ioctl(td, (struct ioctl_args *)args));
1837
1838         case LINUX_SNDCTL_DSP_GETCAPS:
1839                 args->cmd = SNDCTL_DSP_GETCAPS;
1840                 return (ioctl(td, (struct ioctl_args *)args));
1841
1842         case LINUX_SNDCTL_DSP_SETTRIGGER: /* LINUX_SNDCTL_GETTRIGGER */
1843                 args->cmd = SNDCTL_DSP_SETTRIGGER;
1844                 return (ioctl(td, (struct ioctl_args *)args));
1845
1846         case LINUX_SNDCTL_DSP_GETIPTR:
1847                 args->cmd = SNDCTL_DSP_GETIPTR;
1848                 return (ioctl(td, (struct ioctl_args *)args));
1849
1850         case LINUX_SNDCTL_DSP_GETOPTR:
1851                 args->cmd = SNDCTL_DSP_GETOPTR;
1852                 return (ioctl(td, (struct ioctl_args *)args));
1853
1854         case LINUX_SNDCTL_DSP_SETDUPLEX:
1855                 args->cmd = SNDCTL_DSP_SETDUPLEX;
1856                 return (ioctl(td, (struct ioctl_args *)args));
1857
1858         case LINUX_SNDCTL_DSP_GETODELAY:
1859                 args->cmd = SNDCTL_DSP_GETODELAY;
1860                 return (ioctl(td, (struct ioctl_args *)args));
1861
1862         case LINUX_SNDCTL_SEQ_RESET:
1863                 args->cmd = SNDCTL_SEQ_RESET;
1864                 return (ioctl(td, (struct ioctl_args *)args));
1865
1866         case LINUX_SNDCTL_SEQ_SYNC:
1867                 args->cmd = SNDCTL_SEQ_SYNC;
1868                 return (ioctl(td, (struct ioctl_args *)args));
1869
1870         case LINUX_SNDCTL_SYNTH_INFO:
1871                 args->cmd = SNDCTL_SYNTH_INFO;
1872                 return (ioctl(td, (struct ioctl_args *)args));
1873
1874         case LINUX_SNDCTL_SEQ_CTRLRATE:
1875                 args->cmd = SNDCTL_SEQ_CTRLRATE;
1876                 return (ioctl(td, (struct ioctl_args *)args));
1877
1878         case LINUX_SNDCTL_SEQ_GETOUTCOUNT:
1879                 args->cmd = SNDCTL_SEQ_GETOUTCOUNT;
1880                 return (ioctl(td, (struct ioctl_args *)args));
1881
1882         case LINUX_SNDCTL_SEQ_GETINCOUNT:
1883                 args->cmd = SNDCTL_SEQ_GETINCOUNT;
1884                 return (ioctl(td, (struct ioctl_args *)args));
1885
1886         case LINUX_SNDCTL_SEQ_PERCMODE:
1887                 args->cmd = SNDCTL_SEQ_PERCMODE;
1888                 return (ioctl(td, (struct ioctl_args *)args));
1889
1890         case LINUX_SNDCTL_FM_LOAD_INSTR:
1891                 args->cmd = SNDCTL_FM_LOAD_INSTR;
1892                 return (ioctl(td, (struct ioctl_args *)args));
1893
1894         case LINUX_SNDCTL_SEQ_TESTMIDI:
1895                 args->cmd = SNDCTL_SEQ_TESTMIDI;
1896                 return (ioctl(td, (struct ioctl_args *)args));
1897
1898         case LINUX_SNDCTL_SEQ_RESETSAMPLES:
1899                 args->cmd = SNDCTL_SEQ_RESETSAMPLES;
1900                 return (ioctl(td, (struct ioctl_args *)args));
1901
1902         case LINUX_SNDCTL_SEQ_NRSYNTHS:
1903                 args->cmd = SNDCTL_SEQ_NRSYNTHS;
1904                 return (ioctl(td, (struct ioctl_args *)args));
1905
1906         case LINUX_SNDCTL_SEQ_NRMIDIS:
1907                 args->cmd = SNDCTL_SEQ_NRMIDIS;
1908                 return (ioctl(td, (struct ioctl_args *)args));
1909
1910         case LINUX_SNDCTL_MIDI_INFO:
1911                 args->cmd = SNDCTL_MIDI_INFO;
1912                 return (ioctl(td, (struct ioctl_args *)args));
1913
1914         case LINUX_SNDCTL_SEQ_TRESHOLD:
1915                 args->cmd = SNDCTL_SEQ_TRESHOLD;
1916                 return (ioctl(td, (struct ioctl_args *)args));
1917
1918         case LINUX_SNDCTL_SYNTH_MEMAVL:
1919                 args->cmd = SNDCTL_SYNTH_MEMAVL;
1920                 return (ioctl(td, (struct ioctl_args *)args));
1921
1922         }
1923
1924         return (ENOIOCTL);
1925 }
1926
1927 /*
1928  * Console related ioctls
1929  */
1930
1931 #define ISSIGVALID(sig)         ((sig) > 0 && (sig) < NSIG)
1932
1933 static int
1934 linux_ioctl_console(struct thread *td, struct linux_ioctl_args *args)
1935 {
1936         struct file *fp;
1937         int error;
1938
1939         if ((error = fget(td, args->fd, &fp)) != 0)
1940                 return (error);
1941         switch (args->cmd & 0xffff) {
1942
1943         case LINUX_KIOCSOUND:
1944                 args->cmd = KIOCSOUND;
1945                 error = (ioctl(td, (struct ioctl_args *)args));
1946                 break;
1947
1948         case LINUX_KDMKTONE:
1949                 args->cmd = KDMKTONE;
1950                 error = (ioctl(td, (struct ioctl_args *)args));
1951                 break;
1952
1953         case LINUX_KDGETLED:
1954                 args->cmd = KDGETLED;
1955                 error = (ioctl(td, (struct ioctl_args *)args));
1956                 break;
1957
1958         case LINUX_KDSETLED:
1959                 args->cmd = KDSETLED;
1960                 error = (ioctl(td, (struct ioctl_args *)args));
1961                 break;
1962
1963         case LINUX_KDSETMODE:
1964                 args->cmd = KDSETMODE;
1965                 error = (ioctl(td, (struct ioctl_args *)args));
1966                 break;
1967
1968         case LINUX_KDGETMODE:
1969                 args->cmd = KDGETMODE;
1970                 error = (ioctl(td, (struct ioctl_args *)args));
1971                 break;
1972
1973         case LINUX_KDGKBMODE:
1974                 args->cmd = KDGKBMODE;
1975                 error = (ioctl(td, (struct ioctl_args *)args));
1976                 break;
1977
1978         case LINUX_KDSKBMODE: {
1979                 int kbdmode;
1980                 switch (args->arg) {
1981                 case LINUX_KBD_RAW:
1982                         kbdmode = K_RAW;
1983                         break;
1984                 case LINUX_KBD_XLATE:
1985                         kbdmode = K_XLATE;
1986                         break;
1987                 case LINUX_KBD_MEDIUMRAW:
1988                         kbdmode = K_RAW;
1989                         break;
1990                 default:
1991                         fdrop(fp, td);
1992                         return (EINVAL);
1993                 }
1994                 error = (fo_ioctl(fp, KDSKBMODE, (caddr_t)&kbdmode,
1995                     td->td_ucred, td));
1996                 break;
1997         }
1998
1999         case LINUX_VT_OPENQRY:
2000                 args->cmd = VT_OPENQRY;
2001                 error = (ioctl(td, (struct ioctl_args *)args));
2002                 break;
2003
2004         case LINUX_VT_GETMODE:
2005                 args->cmd = VT_GETMODE;
2006                 error = (ioctl(td, (struct ioctl_args *)args));
2007                 break;
2008
2009         case LINUX_VT_SETMODE: {
2010                 struct vt_mode mode;
2011                 if ((error = copyin((void *)args->arg, &mode, sizeof(mode))))
2012                         break;
2013                 if (!ISSIGVALID(mode.frsig) && ISSIGVALID(mode.acqsig))
2014                         mode.frsig = mode.acqsig;
2015                 if ((error = copyout(&mode, (void *)args->arg, sizeof(mode))))
2016                         break;
2017                 args->cmd = VT_SETMODE;
2018                 error = (ioctl(td, (struct ioctl_args *)args));
2019                 break;
2020         }
2021
2022         case LINUX_VT_GETSTATE:
2023                 args->cmd = VT_GETACTIVE;
2024                 error = (ioctl(td, (struct ioctl_args *)args));
2025                 break;
2026
2027         case LINUX_VT_RELDISP:
2028                 args->cmd = VT_RELDISP;
2029                 error = (ioctl(td, (struct ioctl_args *)args));
2030                 break;
2031
2032         case LINUX_VT_ACTIVATE:
2033                 args->cmd = VT_ACTIVATE;
2034                 error = (ioctl(td, (struct ioctl_args *)args));
2035                 break;
2036
2037         case LINUX_VT_WAITACTIVE:
2038                 args->cmd = VT_WAITACTIVE;
2039                 error = (ioctl(td, (struct ioctl_args *)args));
2040                 break;
2041
2042         default:
2043                 error = ENOIOCTL;
2044                 break;
2045         }
2046
2047         fdrop(fp, td);
2048         return (error);
2049 }
2050
2051 /*
2052  * Criteria for interface name translation
2053  */
2054 #define IFP_IS_ETH(ifp) (ifp->if_type == IFT_ETHER)
2055
2056 /*
2057  * Interface function used by linprocfs (at the time of writing). It's not
2058  * used by the Linuxulator itself.
2059  */
2060 int
2061 linux_ifname(struct ifnet *ifp, char *buffer, size_t buflen)
2062 {
2063         INIT_VNET_NET(ifp->if_vnet);
2064         struct ifnet *ifscan;
2065         int ethno;
2066
2067         /* Short-circuit non ethernet interfaces */
2068         if (!IFP_IS_ETH(ifp))
2069                 return (strlcpy(buffer, ifp->if_xname, buflen));
2070
2071         /* Determine the (relative) unit number for ethernet interfaces */
2072         ethno = 0;
2073         IFNET_RLOCK();
2074         TAILQ_FOREACH(ifscan, &V_ifnet, if_link) {
2075                 if (ifscan == ifp) {
2076                         IFNET_RUNLOCK();
2077                         return (snprintf(buffer, buflen, "eth%d", ethno));
2078                 }
2079                 if (IFP_IS_ETH(ifscan))
2080                         ethno++;
2081         }
2082         IFNET_RUNLOCK();
2083
2084         return (0);
2085 }
2086
2087 /*
2088  * Translate a Linux interface name to a FreeBSD interface name,
2089  * and return the associated ifnet structure
2090  * bsdname and lxname need to be least IFNAMSIZ bytes long, but
2091  * can point to the same buffer.
2092  */
2093
2094 static struct ifnet *
2095 ifname_linux_to_bsd(const char *lxname, char *bsdname)
2096 {
2097         INIT_VNET_NET(TD_TO_VNET(curthread));
2098         struct ifnet *ifp;
2099         int len, unit;
2100         char *ep;
2101         int is_eth, index;
2102
2103         for (len = 0; len < LINUX_IFNAMSIZ; ++len)
2104                 if (!isalpha(lxname[len]))
2105                         break;
2106         if (len == 0 || len == LINUX_IFNAMSIZ)
2107                 return (NULL);
2108         unit = (int)strtoul(lxname + len, &ep, 10);
2109         if (ep == NULL || ep == lxname + len || ep >= lxname + LINUX_IFNAMSIZ)
2110                 return (NULL);
2111         index = 0;
2112         is_eth = (len == 3 && !strncmp(lxname, "eth", len)) ? 1 : 0;
2113         IFNET_RLOCK();
2114         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2115                 /*
2116                  * Allow Linux programs to use FreeBSD names. Don't presume
2117                  * we never have an interface named "eth", so don't make
2118                  * the test optional based on is_eth.
2119                  */
2120                 if (strncmp(ifp->if_xname, lxname, LINUX_IFNAMSIZ) == 0)
2121                         break;
2122                 if (is_eth && IFP_IS_ETH(ifp) && unit == index++)
2123                         break;
2124         }
2125         IFNET_RUNLOCK();
2126         if (ifp != NULL)
2127                 strlcpy(bsdname, ifp->if_xname, IFNAMSIZ);
2128         return (ifp);
2129 }
2130
2131 /*
2132  * Implement the SIOCGIFCONF ioctl
2133  */
2134
2135 static int
2136 linux_ifconf(struct thread *td, struct ifconf *uifc)
2137 {
2138         INIT_VNET_NET(TD_TO_VNET(td));
2139 #ifdef COMPAT_LINUX32
2140         struct l_ifconf ifc;
2141 #else
2142         struct ifconf ifc;
2143 #endif
2144         struct l_ifreq ifr;
2145         struct ifnet *ifp;
2146         struct ifaddr *ifa;
2147         struct sbuf *sb;
2148         int error, ethno, full = 0, valid_len, max_len;
2149
2150         error = copyin(uifc, &ifc, sizeof(ifc));
2151         if (error != 0)
2152                 return (error);
2153
2154         max_len = MAXPHYS - 1;
2155
2156         /* handle the 'request buffer size' case */
2157         if (ifc.ifc_buf == PTROUT(NULL)) {
2158                 ifc.ifc_len = 0;
2159                 TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2160                         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2161                                 struct sockaddr *sa = ifa->ifa_addr;
2162                                 if (sa->sa_family == AF_INET)
2163                                         ifc.ifc_len += sizeof(ifr);
2164                         }
2165                 }
2166                 error = copyout(&ifc, uifc, sizeof(ifc));
2167                 return (error);
2168         }
2169
2170         if (ifc.ifc_len <= 0)
2171                 return (EINVAL);
2172
2173 again:
2174         /* Keep track of eth interfaces */
2175         ethno = 0;
2176         if (ifc.ifc_len <= max_len) {
2177                 max_len = ifc.ifc_len;
2178                 full = 1;
2179         }
2180         sb = sbuf_new(NULL, NULL, max_len + 1, SBUF_FIXEDLEN);
2181         max_len = 0;
2182         valid_len = 0;
2183
2184         /* Return all AF_INET addresses of all interfaces */
2185         IFNET_RLOCK();          /* could sleep XXX */
2186         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2187                 int addrs = 0;
2188
2189                 bzero(&ifr, sizeof(ifr));
2190                 if (IFP_IS_ETH(ifp))
2191                         snprintf(ifr.ifr_name, LINUX_IFNAMSIZ, "eth%d",
2192                             ethno++);
2193                 else
2194                         strlcpy(ifr.ifr_name, ifp->if_xname, LINUX_IFNAMSIZ);
2195
2196                 /* Walk the address list */
2197                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2198                         struct sockaddr *sa = ifa->ifa_addr;
2199
2200                         if (sa->sa_family == AF_INET) {
2201                                 ifr.ifr_addr.sa_family = LINUX_AF_INET;
2202                                 memcpy(ifr.ifr_addr.sa_data, sa->sa_data,
2203                                     sizeof(ifr.ifr_addr.sa_data));
2204                                 sbuf_bcat(sb, &ifr, sizeof(ifr));
2205                                 max_len += sizeof(ifr);
2206                                 addrs++;
2207                         }
2208
2209                         if (!sbuf_overflowed(sb))
2210                                 valid_len = sbuf_len(sb);
2211                 }
2212                 if (addrs == 0) {
2213                         bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
2214                         sbuf_bcat(sb, &ifr, sizeof(ifr));
2215                         max_len += sizeof(ifr);
2216
2217                         if (!sbuf_overflowed(sb))
2218                                 valid_len = sbuf_len(sb);
2219                 }
2220         }
2221         IFNET_RUNLOCK();
2222
2223         if (valid_len != max_len && !full) {
2224                 sbuf_delete(sb);
2225                 goto again;
2226         }
2227
2228         ifc.ifc_len = valid_len;
2229         sbuf_finish(sb);
2230         memcpy(PTRIN(ifc.ifc_buf), sbuf_data(sb), ifc.ifc_len);
2231         error = copyout(&ifc, uifc, sizeof(ifc));
2232         sbuf_delete(sb);
2233
2234         return (error);
2235 }
2236
2237 static int
2238 linux_gifflags(struct thread *td, struct ifnet *ifp, struct l_ifreq *ifr)
2239 {
2240         l_short flags;
2241
2242         flags = (ifp->if_flags | ifp->if_drv_flags) & 0xffff;
2243         /* these flags have no Linux equivalent */
2244         flags &= ~(IFF_SMART|IFF_DRV_OACTIVE|IFF_SIMPLEX|
2245             IFF_LINK0|IFF_LINK1|IFF_LINK2);
2246         /* Linux' multicast flag is in a different bit */
2247         if (flags & IFF_MULTICAST) {
2248                 flags &= ~IFF_MULTICAST;
2249                 flags |= 0x1000;
2250         }
2251
2252         return (copyout(&flags, &ifr->ifr_flags, sizeof(flags)));
2253 }
2254
2255 #define ARPHRD_ETHER    1
2256 #define ARPHRD_LOOPBACK 772
2257
2258 static int
2259 linux_gifhwaddr(struct ifnet *ifp, struct l_ifreq *ifr)
2260 {
2261         struct ifaddr *ifa;
2262         struct sockaddr_dl *sdl;
2263         struct l_sockaddr lsa;
2264
2265         if (ifp->if_type == IFT_LOOP) {
2266                 bzero(&lsa, sizeof(lsa));
2267                 lsa.sa_family = ARPHRD_LOOPBACK;
2268                 return (copyout(&lsa, &ifr->ifr_hwaddr, sizeof(lsa)));
2269         }
2270
2271         if (ifp->if_type != IFT_ETHER)
2272                 return (ENOENT);
2273
2274         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2275                 sdl = (struct sockaddr_dl*)ifa->ifa_addr;
2276                 if (sdl != NULL && (sdl->sdl_family == AF_LINK) &&
2277                     (sdl->sdl_type == IFT_ETHER)) {
2278                         bzero(&lsa, sizeof(lsa));
2279                         lsa.sa_family = ARPHRD_ETHER;
2280                         bcopy(LLADDR(sdl), lsa.sa_data, LINUX_IFHWADDRLEN);
2281                         return (copyout(&lsa, &ifr->ifr_hwaddr, sizeof(lsa)));
2282                 }
2283         }
2284
2285         return (ENOENT);
2286 }
2287
2288
2289  /*
2290 * If we fault in bsd_to_linux_ifreq() then we will fault when we call
2291 * the native ioctl().  Thus, we don't really need to check the return
2292 * value of this function.
2293 */
2294 static int
2295 bsd_to_linux_ifreq(struct ifreq *arg)
2296 {
2297         struct ifreq ifr;
2298         size_t ifr_len = sizeof(struct ifreq);
2299         int error;
2300
2301         if ((error = copyin(arg, &ifr, ifr_len)))
2302                 return (error);
2303
2304         *(u_short *)&ifr.ifr_addr = ifr.ifr_addr.sa_family;
2305
2306         error = copyout(&ifr, arg, ifr_len);
2307
2308         return (error);
2309 }
2310
2311 /*
2312  * Socket related ioctls
2313  */
2314
2315 static int
2316 linux_ioctl_socket(struct thread *td, struct linux_ioctl_args *args)
2317 {
2318         char lifname[LINUX_IFNAMSIZ], ifname[IFNAMSIZ];
2319         struct ifnet *ifp;
2320         struct file *fp;
2321         int error, type;
2322
2323         ifp = NULL;
2324         error = 0;
2325
2326         if ((error = fget(td, args->fd, &fp)) != 0)
2327                 return (error);
2328         type = fp->f_type;
2329         fdrop(fp, td);
2330         if (type != DTYPE_SOCKET) {
2331                 /* not a socket - probably a tap / vmnet device */
2332                 switch (args->cmd) {
2333                 case LINUX_SIOCGIFADDR:
2334                 case LINUX_SIOCSIFADDR:
2335                 case LINUX_SIOCGIFFLAGS:
2336                         return (linux_ioctl_special(td, args));
2337                 default:
2338                         return (ENOIOCTL);
2339                 }
2340         }
2341
2342         switch (args->cmd & 0xffff) {
2343
2344         case LINUX_FIOGETOWN:
2345         case LINUX_FIOSETOWN:
2346         case LINUX_SIOCADDMULTI:
2347         case LINUX_SIOCATMARK:
2348         case LINUX_SIOCDELMULTI:
2349         case LINUX_SIOCGIFCONF:
2350         case LINUX_SIOCGPGRP:
2351         case LINUX_SIOCSPGRP:
2352         case LINUX_SIOCGIFCOUNT:
2353                 /* these ioctls don't take an interface name */
2354 #ifdef DEBUG
2355                 printf("%s(): ioctl %d\n", __func__,
2356                     args->cmd & 0xffff);
2357 #endif
2358                 break;
2359
2360         case LINUX_SIOCGIFFLAGS:
2361         case LINUX_SIOCGIFADDR:
2362         case LINUX_SIOCSIFADDR:
2363         case LINUX_SIOCGIFDSTADDR:
2364         case LINUX_SIOCGIFBRDADDR:
2365         case LINUX_SIOCGIFNETMASK:
2366         case LINUX_SIOCSIFNETMASK:
2367         case LINUX_SIOCGIFMTU:
2368         case LINUX_SIOCSIFMTU:
2369         case LINUX_SIOCSIFNAME:
2370         case LINUX_SIOCGIFHWADDR:
2371         case LINUX_SIOCSIFHWADDR:
2372         case LINUX_SIOCDEVPRIVATE:
2373         case LINUX_SIOCDEVPRIVATE+1:
2374         case LINUX_SIOCGIFINDEX:
2375                 /* copy in the interface name and translate it. */
2376                 error = copyin((void *)args->arg, lifname, LINUX_IFNAMSIZ);
2377                 if (error != 0)
2378                         return (error);
2379 #ifdef DEBUG
2380                 printf("%s(): ioctl %d on %.*s\n", __func__,
2381                     args->cmd & 0xffff, LINUX_IFNAMSIZ, lifname);
2382 #endif
2383                 ifp = ifname_linux_to_bsd(lifname, ifname);
2384                 if (ifp == NULL)
2385                         return (EINVAL);
2386                 /*
2387                  * We need to copy it back out in case we pass the
2388                  * request on to our native ioctl(), which will expect
2389                  * the ifreq to be in user space and have the correct
2390                  * interface name.
2391                  */
2392                 error = copyout(ifname, (void *)args->arg, IFNAMSIZ);
2393                 if (error != 0)
2394                         return (error);
2395 #ifdef DEBUG
2396                 printf("%s(): %s translated to %s\n", __func__,
2397                     lifname, ifname);
2398 #endif
2399                 break;
2400
2401         default:
2402                 return (ENOIOCTL);
2403         }
2404
2405         switch (args->cmd & 0xffff) {
2406
2407         case LINUX_FIOSETOWN:
2408                 args->cmd = FIOSETOWN;
2409                 error = ioctl(td, (struct ioctl_args *)args);
2410                 break;
2411
2412         case LINUX_SIOCSPGRP:
2413                 args->cmd = SIOCSPGRP;
2414                 error = ioctl(td, (struct ioctl_args *)args);
2415                 break;
2416
2417         case LINUX_FIOGETOWN:
2418                 args->cmd = FIOGETOWN;
2419                 error = ioctl(td, (struct ioctl_args *)args);
2420                 break;
2421
2422         case LINUX_SIOCGPGRP:
2423                 args->cmd = SIOCGPGRP;
2424                 error = ioctl(td, (struct ioctl_args *)args);
2425                 break;
2426
2427         case LINUX_SIOCATMARK:
2428                 args->cmd = SIOCATMARK;
2429                 error = ioctl(td, (struct ioctl_args *)args);
2430                 break;
2431
2432         /* LINUX_SIOCGSTAMP */
2433
2434         case LINUX_SIOCGIFCONF:
2435                 error = linux_ifconf(td, (struct ifconf *)args->arg);
2436                 break;
2437
2438         case LINUX_SIOCGIFFLAGS:
2439                 args->cmd = SIOCGIFFLAGS;
2440                 error = linux_gifflags(td, ifp, (struct l_ifreq *)args->arg);
2441                 break;
2442
2443         case LINUX_SIOCGIFADDR:
2444                 args->cmd = SIOCGIFADDR;
2445                 error = ioctl(td, (struct ioctl_args *)args);
2446                 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2447                 break;
2448
2449         case LINUX_SIOCSIFADDR:
2450                 /* XXX probably doesn't work, included for completeness */
2451                 args->cmd = SIOCSIFADDR;
2452                 error = ioctl(td, (struct ioctl_args *)args);
2453                 break;
2454
2455         case LINUX_SIOCGIFDSTADDR:
2456                 args->cmd = SIOCGIFDSTADDR;
2457                 error = ioctl(td, (struct ioctl_args *)args);
2458                 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2459                 break;
2460
2461         case LINUX_SIOCGIFBRDADDR:
2462                 args->cmd = SIOCGIFBRDADDR;
2463                 error = ioctl(td, (struct ioctl_args *)args);
2464                 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2465                 break;
2466
2467         case LINUX_SIOCGIFNETMASK:
2468                 args->cmd = SIOCGIFNETMASK;
2469                 error = ioctl(td, (struct ioctl_args *)args);
2470                 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2471                 break;
2472
2473         case LINUX_SIOCSIFNETMASK:
2474                 error = ENOIOCTL;
2475                 break;
2476
2477         case LINUX_SIOCGIFMTU:
2478                 args->cmd = SIOCGIFMTU;
2479                 error = ioctl(td, (struct ioctl_args *)args);
2480                 break;
2481
2482         case LINUX_SIOCSIFMTU:
2483                 args->cmd = SIOCSIFMTU;
2484                 error = ioctl(td, (struct ioctl_args *)args);
2485                 break;
2486
2487         case LINUX_SIOCSIFNAME:
2488                 error = ENOIOCTL;
2489                 break;
2490
2491         case LINUX_SIOCGIFHWADDR:
2492                 error = linux_gifhwaddr(ifp, (struct l_ifreq *)args->arg);
2493                 break;
2494
2495         case LINUX_SIOCSIFHWADDR:
2496                 error = ENOIOCTL;
2497                 break;
2498
2499         case LINUX_SIOCADDMULTI:
2500                 args->cmd = SIOCADDMULTI;
2501                 error = ioctl(td, (struct ioctl_args *)args);
2502                 break;
2503
2504         case LINUX_SIOCDELMULTI:
2505                 args->cmd = SIOCDELMULTI;
2506                 error = ioctl(td, (struct ioctl_args *)args);
2507                 break;
2508
2509         case LINUX_SIOCGIFINDEX:
2510                 args->cmd = SIOCGIFINDEX;
2511                 error = ioctl(td, (struct ioctl_args *)args);
2512                 break;
2513
2514         case LINUX_SIOCGIFCOUNT:
2515                 error = 0;
2516                 break;
2517
2518         /*
2519          * XXX This is slightly bogus, but these ioctls are currently
2520          * XXX only used by the aironet (if_an) network driver.
2521          */
2522         case LINUX_SIOCDEVPRIVATE:
2523                 args->cmd = SIOCGPRIVATE_0;
2524                 error = ioctl(td, (struct ioctl_args *)args);
2525                 break;
2526
2527         case LINUX_SIOCDEVPRIVATE+1:
2528                 args->cmd = SIOCGPRIVATE_1;
2529                 error = ioctl(td, (struct ioctl_args *)args);
2530                 break;
2531         }
2532
2533         if (ifp != NULL)
2534                 /* restore the original interface name */
2535                 copyout(lifname, (void *)args->arg, LINUX_IFNAMSIZ);
2536
2537 #ifdef DEBUG
2538         printf("%s(): returning %d\n", __func__, error);
2539 #endif
2540         return (error);
2541 }
2542
2543 /*
2544  * Device private ioctl handler
2545  */
2546 static int
2547 linux_ioctl_private(struct thread *td, struct linux_ioctl_args *args)
2548 {
2549         struct file *fp;
2550         int error, type;
2551
2552         if ((error = fget(td, args->fd, &fp)) != 0)
2553                 return (error);
2554         type = fp->f_type;
2555         fdrop(fp, td);
2556         if (type == DTYPE_SOCKET)
2557                 return (linux_ioctl_socket(td, args));
2558         return (ENOIOCTL);
2559 }
2560
2561 /*
2562  * DRM ioctl handler (sys/dev/drm)
2563  */
2564 static int
2565 linux_ioctl_drm(struct thread *td, struct linux_ioctl_args *args)
2566 {
2567         args->cmd = SETDIR(args->cmd);
2568         return ioctl(td, (struct ioctl_args *)args);
2569 }
2570
2571 static int
2572 linux_ioctl_sg(struct thread *td, struct linux_ioctl_args *args)
2573 {
2574         struct file *fp;
2575         u_long cmd;
2576         int error;
2577
2578         if ((error = fget(td, args->fd, &fp)) != 0) {
2579                 printf("sg_linux_ioctl: fget returned %d\n", error);
2580                 return (error);
2581         }
2582         cmd = args->cmd;
2583
2584         error = (fo_ioctl(fp, cmd, (caddr_t)args->arg, td->td_ucred, td));
2585         fdrop(fp, td);
2586         return (error);
2587 }
2588
2589 /*
2590  * Special ioctl handler
2591  */
2592 static int
2593 linux_ioctl_special(struct thread *td, struct linux_ioctl_args *args)
2594 {
2595         int error;
2596
2597         switch (args->cmd) {
2598         case LINUX_SIOCGIFADDR:
2599                 args->cmd = SIOCGIFADDR;
2600                 error = ioctl(td, (struct ioctl_args *)args);
2601                 break;
2602         case LINUX_SIOCSIFADDR:
2603                 args->cmd = SIOCSIFADDR;
2604                 error = ioctl(td, (struct ioctl_args *)args);
2605                 break;
2606         case LINUX_SIOCGIFFLAGS:
2607                 args->cmd = SIOCGIFFLAGS;
2608                 error = ioctl(td, (struct ioctl_args *)args);
2609                 break;
2610         default:
2611                 error = ENOIOCTL;
2612         }
2613
2614         return (error);
2615 }
2616
2617 /*
2618  * main ioctl syscall function
2619  */
2620
2621 int
2622 linux_ioctl(struct thread *td, struct linux_ioctl_args *args)
2623 {
2624         struct file *fp;
2625         struct handler_element *he;
2626         int error, cmd;
2627
2628 #ifdef DEBUG
2629         if (ldebug(ioctl))
2630                 printf(ARGS(ioctl, "%d, %04lx, *"), args->fd,
2631                     (unsigned long)args->cmd);
2632 #endif
2633
2634         if ((error = fget(td, args->fd, &fp)) != 0)
2635                 return (error);
2636         if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
2637                 fdrop(fp, td);
2638                 return (EBADF);
2639         }
2640
2641         /* Iterate over the ioctl handlers */
2642         cmd = args->cmd & 0xffff;
2643         sx_slock(&linux_ioctl_sx);
2644         mtx_lock(&Giant);
2645         TAILQ_FOREACH(he, &handlers, list) {
2646                 if (cmd >= he->low && cmd <= he->high) {
2647                         error = (*he->func)(td, args);
2648                         if (error != ENOIOCTL) {
2649                                 mtx_unlock(&Giant);
2650                                 sx_sunlock(&linux_ioctl_sx);
2651                                 fdrop(fp, td);
2652                                 return (error);
2653                         }
2654                 }
2655         }
2656         mtx_unlock(&Giant);
2657         sx_sunlock(&linux_ioctl_sx);
2658         fdrop(fp, td);
2659
2660         linux_msg(td, "ioctl fd=%d, cmd=0x%x ('%c',%d) is not implemented",
2661             args->fd, (int)(args->cmd & 0xffff),
2662             (int)(args->cmd & 0xff00) >> 8, (int)(args->cmd & 0xff));
2663
2664         return (EINVAL);
2665 }
2666
2667 int
2668 linux_ioctl_register_handler(struct linux_ioctl_handler *h)
2669 {
2670         struct handler_element *he, *cur;
2671
2672         if (h == NULL || h->func == NULL)
2673                 return (EINVAL);
2674
2675         /*
2676          * Reuse the element if the handler is already on the list, otherwise
2677          * create a new element.
2678          */
2679         sx_xlock(&linux_ioctl_sx);
2680         TAILQ_FOREACH(he, &handlers, list) {
2681                 if (he->func == h->func)
2682                         break;
2683         }
2684         if (he == NULL) {
2685                 he = malloc(sizeof(*he),
2686                     M_LINUX, M_WAITOK);
2687                 he->func = h->func;
2688         } else
2689                 TAILQ_REMOVE(&handlers, he, list);
2690
2691         /* Initialize range information. */
2692         he->low = h->low;
2693         he->high = h->high;
2694         he->span = h->high - h->low + 1;
2695
2696         /* Add the element to the list, sorted on span. */
2697         TAILQ_FOREACH(cur, &handlers, list) {
2698                 if (cur->span > he->span) {
2699                         TAILQ_INSERT_BEFORE(cur, he, list);
2700                         sx_xunlock(&linux_ioctl_sx);
2701                         return (0);
2702                 }
2703         }
2704         TAILQ_INSERT_TAIL(&handlers, he, list);
2705         sx_xunlock(&linux_ioctl_sx);
2706
2707         return (0);
2708 }
2709
2710 int
2711 linux_ioctl_unregister_handler(struct linux_ioctl_handler *h)
2712 {
2713         struct handler_element *he;
2714
2715         if (h == NULL || h->func == NULL)
2716                 return (EINVAL);
2717
2718         sx_xlock(&linux_ioctl_sx);
2719         TAILQ_FOREACH(he, &handlers, list) {
2720                 if (he->func == h->func) {
2721                         TAILQ_REMOVE(&handlers, he, list);
2722                         sx_xunlock(&linux_ioctl_sx);
2723                         free(he, M_LINUX);
2724                         return (0);
2725                 }
2726         }
2727         sx_xunlock(&linux_ioctl_sx);
2728
2729         return (EINVAL);
2730 }