sys/emulation/linux/linux_ioctl.c

   1 /*
   2  * Copyright (c) 1994-1995 Søren Schmidt
   3  * Copyright (c) 2004 Simon 'corecode' Schubert
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer
  11  *    in this position and unchanged.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software withough specific prior written permission
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/sys/compat/linux/linux_ioctl.c,v 1.55.2.11 2003/05/01 20:16:09 anholt Exp $
  30  * $DragonFly: src/sys/emulation/linux/linux_ioctl.c,v 1.15 2004/08/15 14:15:00 joerg Exp $
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/sysproto.h>
  36 #include <sys/cdio.h>
  37 #include <sys/consio.h>
  38 #include <sys/ctype.h>
  39 #include <sys/disklabel.h>
  40 #include <sys/fcntl.h>
  41 #include <sys/file.h>
  42 #include <sys/filedesc.h>
  43 #include <sys/filio.h>
  44 #include <sys/ioccom.h>
  45 #include <sys/kbio.h>
  46 #include <sys/kernel.h>
  47 #include <sys/linker_set.h>
  48 #include <sys/malloc.h>
  49 #include <sys/mapped_ioctl.h>
  50 #include <sys/proc.h>
  51 #include <sys/socket.h>
  52 #include <sys/sockio.h>
  53 #include <sys/soundcard.h>
  54 #include <sys/tty.h>
  55 #include <sys/uio.h>
  56 #include <net/if.h>
  57 #include <net/if_dl.h>
  58 #include <net/if_types.h>
  59 #include <sys/file2.h>
  60
  61 #include <arch_linux/linux.h>
  62 #include <arch_linux/linux_proto.h>
  63
  64 #include "linux_ioctl.h"
  65 #include "linux_mib.h"
  66 #include "linux_util.h"
  67
  68
  69 static int
  70 linux_ioctl_BLKGETSIZE(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
  71 {
  72         int error;
  73         struct disklabel dl;
  74
  75         error = fo_ioctl(fp, DIOCGDINFO, (caddr_t)&dl, td);
  76         if (error)
  77                 return (error);
  78         bcopy(&(dl.d_secperunit), data, sizeof(dl.d_secperunit));
  79         return (0);
  80 }
  81
  82
  83 /*
  84  * termio related ioctls
  85  */
  86
  87 struct linux_termio {
  88         unsigned short c_iflag;
  89         unsigned short c_oflag;
  90         unsigned short c_cflag;
  91         unsigned short c_lflag;
  92         unsigned char c_line;
  93         unsigned char c_cc[LINUX_NCC];
  94 };
  95
  96 struct linux_termios {
  97         unsigned int c_iflag;
  98         unsigned int c_oflag;
  99         unsigned int c_cflag;
 100         unsigned int c_lflag;
 101 #ifdef __alpha__
 102         unsigned char c_cc[LINUX_NCCS];
 103         unsigned char c_line;
 104         unsigned int  c_ispeed;
 105         unsigned int  c_ospeed;
 106 #else
 107         unsigned char c_line;
 108         unsigned char c_cc[LINUX_NCCS];
 109 #endif
 110 };
 111
 112 struct linux_winsize {
 113         unsigned short ws_row, ws_col;
 114         unsigned short ws_xpixel, ws_ypixel;
 115 };
 116
 117 static struct speedtab sptab[] = {
 118         { B0, LINUX_B0 }, { B50, LINUX_B50 },
 119         { B75, LINUX_B75 }, { B110, LINUX_B110 },
 120         { B134, LINUX_B134 }, { B150, LINUX_B150 },
 121         { B200, LINUX_B200 }, { B300, LINUX_B300 },
 122         { B600, LINUX_B600 }, { B1200, LINUX_B1200 },
 123         { B1800, LINUX_B1800 }, { B2400, LINUX_B2400 },
 124         { B4800, LINUX_B4800 }, { B9600, LINUX_B9600 },
 125         { B19200, LINUX_B19200 }, { B38400, LINUX_B38400 },
 126         { B57600, LINUX_B57600 }, { B115200, LINUX_B115200 },
 127         {-1, -1 }
 128 };
 129
 130 struct linux_serial_struct {
 131         int     type;
 132         int     line;
 133         int     port;
 134         int     irq;
 135         int     flags;
 136         int     xmit_fifo_size;
 137         int     custom_divisor;
 138         int     baud_base;
 139         unsigned short close_delay;
 140         char    reserved_char[2];
 141         int     hub6;
 142         unsigned short closing_wait;
 143         unsigned short closing_wait2;
 144         int     reserved[4];
 145 };
 146
 147 static int
 148 linux_to_bsd_speed(int code, struct speedtab *table)
 149 {
 150         for ( ; table->sp_code != -1; table++)
 151                 if (table->sp_code == code)
 152                         return (table->sp_speed);
 153         return -1;
 154 }
 155
 156 static int
 157 bsd_to_linux_speed(int speed, struct speedtab *table)
 158 {
 159         for ( ; table->sp_speed != -1; table++)
 160                 if (table->sp_speed == speed)
 161                         return (table->sp_code);
 162         return -1;
 163 }
 164
 165 static void
 166 bsd_to_linux_termios(struct termios *bios, struct linux_termios *lios)
 167 {
 168         int i;
 169
 170 #ifdef DEBUG
 171         if (ldebug(ioctl)) {
 172                 printf("LINUX: BSD termios structure (input):\n");
 173                 printf("i=%08x o=%08x c=%08x l=%08x ispeed=%d ospeed=%d\n",
 174                     bios->c_iflag, bios->c_oflag, bios->c_cflag, bios->c_lflag,
 175                     bios->c_ispeed, bios->c_ospeed);
 176                 printf("c_cc ");
 177                 for (i=0; i<NCCS; i++)
 178                         printf("%02x ", bios->c_cc[i]);
 179                 printf("\n");
 180         }
 181 #endif
 182
 183         lios->c_iflag = 0;
 184         if (bios->c_iflag & IGNBRK)
 185                 lios->c_iflag |= LINUX_IGNBRK;
 186         if (bios->c_iflag & BRKINT)
 187                 lios->c_iflag |= LINUX_BRKINT;
 188         if (bios->c_iflag & IGNPAR)
 189                 lios->c_iflag |= LINUX_IGNPAR;
 190         if (bios->c_iflag & PARMRK)
 191                 lios->c_iflag |= LINUX_PARMRK;
 192         if (bios->c_iflag & INPCK)
 193                 lios->c_iflag |= LINUX_INPCK;
 194         if (bios->c_iflag & ISTRIP)
 195                 lios->c_iflag |= LINUX_ISTRIP;
 196         if (bios->c_iflag & INLCR)
 197                 lios->c_iflag |= LINUX_INLCR;
 198         if (bios->c_iflag & IGNCR)
 199                 lios->c_iflag |= LINUX_IGNCR;
 200         if (bios->c_iflag & ICRNL)
 201                 lios->c_iflag |= LINUX_ICRNL;
 202         if (bios->c_iflag & IXON)
 203                 lios->c_iflag |= LINUX_IXON;
 204         if (bios->c_iflag & IXANY)
 205                 lios->c_iflag |= LINUX_IXANY;
 206         if (bios->c_iflag & IXOFF)
 207                 lios->c_iflag |= LINUX_IXOFF;
 208         if (bios->c_iflag & IMAXBEL)
 209                 lios->c_iflag |= LINUX_IMAXBEL;
 210
 211         lios->c_oflag = 0;
 212         if (bios->c_oflag & OPOST)
 213                 lios->c_oflag |= LINUX_OPOST;
 214         if (bios->c_oflag & ONLCR)
 215                 lios->c_oflag |= LINUX_ONLCR;
 216         if (bios->c_oflag & OXTABS)
 217                 lios->c_oflag |= LINUX_XTABS;
 218
 219         lios->c_cflag = bsd_to_linux_speed(bios->c_ispeed, sptab);
 220         lios->c_cflag |= (bios->c_cflag & CSIZE) >> 4;
 221         if (bios->c_cflag & CSTOPB)
 222                 lios->c_cflag |= LINUX_CSTOPB;
 223         if (bios->c_cflag & CREAD)
 224                 lios->c_cflag |= LINUX_CREAD;
 225         if (bios->c_cflag & PARENB)
 226                 lios->c_cflag |= LINUX_PARENB;
 227         if (bios->c_cflag & PARODD)
 228                 lios->c_cflag |= LINUX_PARODD;
 229         if (bios->c_cflag & HUPCL)
 230                 lios->c_cflag |= LINUX_HUPCL;
 231         if (bios->c_cflag & CLOCAL)
 232                 lios->c_cflag |= LINUX_CLOCAL;
 233         if (bios->c_cflag & CRTSCTS)
 234                 lios->c_cflag |= LINUX_CRTSCTS;
 235
 236         lios->c_lflag = 0;
 237         if (bios->c_lflag & ISIG)
 238                 lios->c_lflag |= LINUX_ISIG;
 239         if (bios->c_lflag & ICANON)
 240                 lios->c_lflag |= LINUX_ICANON;
 241         if (bios->c_lflag & ECHO)
 242                 lios->c_lflag |= LINUX_ECHO;
 243         if (bios->c_lflag & ECHOE)
 244                 lios->c_lflag |= LINUX_ECHOE;
 245         if (bios->c_lflag & ECHOK)
 246                 lios->c_lflag |= LINUX_ECHOK;
 247         if (bios->c_lflag & ECHONL)
 248                 lios->c_lflag |= LINUX_ECHONL;
 249         if (bios->c_lflag & NOFLSH)
 250                 lios->c_lflag |= LINUX_NOFLSH;
 251         if (bios->c_lflag & TOSTOP)
 252                 lios->c_lflag |= LINUX_TOSTOP;
 253         if (bios->c_lflag & ECHOCTL)
 254                 lios->c_lflag |= LINUX_ECHOCTL;
 255         if (bios->c_lflag & ECHOPRT)
 256                 lios->c_lflag |= LINUX_ECHOPRT;
 257         if (bios->c_lflag & ECHOKE)
 258                 lios->c_lflag |= LINUX_ECHOKE;
 259         if (bios->c_lflag & FLUSHO)
 260                 lios->c_lflag |= LINUX_FLUSHO;
 261         if (bios->c_lflag & PENDIN)
 262                 lios->c_lflag |= LINUX_PENDIN;
 263         if (bios->c_lflag & IEXTEN)
 264                 lios->c_lflag |= LINUX_IEXTEN;
 265
 266         for (i=0; i<LINUX_NCCS; i++)
 267                 lios->c_cc[i] = LINUX_POSIX_VDISABLE;
 268         lios->c_cc[LINUX_VINTR] = bios->c_cc[VINTR];
 269         lios->c_cc[LINUX_VQUIT] = bios->c_cc[VQUIT];
 270         lios->c_cc[LINUX_VERASE] = bios->c_cc[VERASE];
 271         lios->c_cc[LINUX_VKILL] = bios->c_cc[VKILL];
 272         lios->c_cc[LINUX_VEOF] = bios->c_cc[VEOF];
 273         lios->c_cc[LINUX_VEOL] = bios->c_cc[VEOL];
 274         lios->c_cc[LINUX_VMIN] = bios->c_cc[VMIN];
 275         lios->c_cc[LINUX_VTIME] = bios->c_cc[VTIME];
 276         lios->c_cc[LINUX_VEOL2] = bios->c_cc[VEOL2];
 277         lios->c_cc[LINUX_VSUSP] = bios->c_cc[VSUSP];
 278         lios->c_cc[LINUX_VSTART] = bios->c_cc[VSTART];
 279         lios->c_cc[LINUX_VSTOP] = bios->c_cc[VSTOP];
 280         lios->c_cc[LINUX_VREPRINT] = bios->c_cc[VREPRINT];
 281         lios->c_cc[LINUX_VDISCARD] = bios->c_cc[VDISCARD];
 282         lios->c_cc[LINUX_VWERASE] = bios->c_cc[VWERASE];
 283         lios->c_cc[LINUX_VLNEXT] = bios->c_cc[VLNEXT];
 284
 285         for (i=0; i<LINUX_NCCS; i++) {
 286                  if (i != LINUX_VMIN && i != LINUX_VTIME &&
 287                     lios->c_cc[i] == _POSIX_VDISABLE)
 288                         lios->c_cc[i] = LINUX_POSIX_VDISABLE;
 289         }
 290         lios->c_line = 0;
 291
 292 #ifdef DEBUG
 293         if (ldebug(ioctl)) {
 294                 printf("LINUX: LINUX termios structure (output):\n");
 295                 printf("i=%08x o=%08x c=%08x l=%08x line=%d\n",
 296                     lios->c_iflag, lios->c_oflag, lios->c_cflag,
 297                     lios->c_lflag, (int)lios->c_line);
 298                 printf("c_cc ");
 299                 for (i=0; i<LINUX_NCCS; i++)
 300                         printf("%02x ", lios->c_cc[i]);
 301                 printf("\n");
 302         }
 303 #endif
 304 }
 305
 306 static void
 307 linux_to_bsd_termios(struct linux_termios *lios, struct termios *bios)
 308 {
 309         int i;
 310
 311 #ifdef DEBUG
 312         if (ldebug(ioctl)) {
 313                 printf("LINUX: LINUX termios structure (input):\n");
 314                 printf("i=%08x o=%08x c=%08x l=%08x line=%d\n",
 315                     lios->c_iflag, lios->c_oflag, lios->c_cflag,
 316                     lios->c_lflag, (int)lios->c_line);
 317                 printf("c_cc ");
 318                 for (i=0; i<LINUX_NCCS; i++)
 319                         printf("%02x ", lios->c_cc[i]);
 320                 printf("\n");
 321         }
 322 #endif
 323
 324         bios->c_iflag = 0;
 325         if (lios->c_iflag & LINUX_IGNBRK)
 326                 bios->c_iflag |= IGNBRK;
 327         if (lios->c_iflag & LINUX_BRKINT)
 328                 bios->c_iflag |= BRKINT;
 329         if (lios->c_iflag & LINUX_IGNPAR)
 330                 bios->c_iflag |= IGNPAR;
 331         if (lios->c_iflag & LINUX_PARMRK)
 332                 bios->c_iflag |= PARMRK;
 333         if (lios->c_iflag & LINUX_INPCK)
 334                 bios->c_iflag |= INPCK;
 335         if (lios->c_iflag & LINUX_ISTRIP)
 336                 bios->c_iflag |= ISTRIP;
 337         if (lios->c_iflag & LINUX_INLCR)
 338                 bios->c_iflag |= INLCR;
 339         if (lios->c_iflag & LINUX_IGNCR)
 340                 bios->c_iflag |= IGNCR;
 341         if (lios->c_iflag & LINUX_ICRNL)
 342                 bios->c_iflag |= ICRNL;
 343         if (lios->c_iflag & LINUX_IXON)
 344                 bios->c_iflag |= IXON;
 345         if (lios->c_iflag & LINUX_IXANY)
 346                 bios->c_iflag |= IXANY;
 347         if (lios->c_iflag & LINUX_IXOFF)
 348                 bios->c_iflag |= IXOFF;
 349         if (lios->c_iflag & LINUX_IMAXBEL)
 350                 bios->c_iflag |= IMAXBEL;
 351
 352         bios->c_oflag = 0;
 353         if (lios->c_oflag & LINUX_OPOST)
 354                 bios->c_oflag |= OPOST;
 355         if (lios->c_oflag & LINUX_ONLCR)
 356                 bios->c_oflag |= ONLCR;
 357         if (lios->c_oflag & LINUX_XTABS)
 358                 bios->c_oflag |= OXTABS;
 359
 360         bios->c_cflag = (lios->c_cflag & LINUX_CSIZE) << 4;
 361         if (lios->c_cflag & LINUX_CSTOPB)
 362                 bios->c_cflag |= CSTOPB;
 363         if (lios->c_cflag & LINUX_CREAD)
 364                 bios->c_cflag |= CREAD;
 365         if (lios->c_cflag & LINUX_PARENB)
 366                 bios->c_cflag |= PARENB;
 367         if (lios->c_cflag & LINUX_PARODD)
 368                 bios->c_cflag |= PARODD;
 369         if (lios->c_cflag & LINUX_HUPCL)
 370                 bios->c_cflag |= HUPCL;
 371         if (lios->c_cflag & LINUX_CLOCAL)
 372                 bios->c_cflag |= CLOCAL;
 373         if (lios->c_cflag & LINUX_CRTSCTS)
 374                 bios->c_cflag |= CRTSCTS;
 375
 376         bios->c_lflag = 0;
 377         if (lios->c_lflag & LINUX_ISIG)
 378                 bios->c_lflag |= ISIG;
 379         if (lios->c_lflag & LINUX_ICANON)
 380                 bios->c_lflag |= ICANON;
 381         if (lios->c_lflag & LINUX_ECHO)
 382                 bios->c_lflag |= ECHO;
 383         if (lios->c_lflag & LINUX_ECHOE)
 384                 bios->c_lflag |= ECHOE;
 385         if (lios->c_lflag & LINUX_ECHOK)
 386                 bios->c_lflag |= ECHOK;
 387         if (lios->c_lflag & LINUX_ECHONL)
 388                 bios->c_lflag |= ECHONL;
 389         if (lios->c_lflag & LINUX_NOFLSH)
 390                 bios->c_lflag |= NOFLSH;
 391         if (lios->c_lflag & LINUX_TOSTOP)
 392                 bios->c_lflag |= TOSTOP;
 393         if (lios->c_lflag & LINUX_ECHOCTL)
 394                 bios->c_lflag |= ECHOCTL;
 395         if (lios->c_lflag & LINUX_ECHOPRT)
 396                 bios->c_lflag |= ECHOPRT;
 397         if (lios->c_lflag & LINUX_ECHOKE)
 398                 bios->c_lflag |= ECHOKE;
 399         if (lios->c_lflag & LINUX_FLUSHO)
 400                 bios->c_lflag |= FLUSHO;
 401         if (lios->c_lflag & LINUX_PENDIN)
 402                 bios->c_lflag |= PENDIN;
 403         if (lios->c_lflag & LINUX_IEXTEN)
 404                 bios->c_lflag |= IEXTEN;
 405
 406         for (i=0; i<NCCS; i++)
 407                 bios->c_cc[i] = _POSIX_VDISABLE;
 408         bios->c_cc[VINTR] = lios->c_cc[LINUX_VINTR];
 409         bios->c_cc[VQUIT] = lios->c_cc[LINUX_VQUIT];
 410         bios->c_cc[VERASE] = lios->c_cc[LINUX_VERASE];
 411         bios->c_cc[VKILL] = lios->c_cc[LINUX_VKILL];
 412         bios->c_cc[VEOF] = lios->c_cc[LINUX_VEOF];
 413         bios->c_cc[VEOL] = lios->c_cc[LINUX_VEOL];
 414         bios->c_cc[VMIN] = lios->c_cc[LINUX_VMIN];
 415         bios->c_cc[VTIME] = lios->c_cc[LINUX_VTIME];
 416         bios->c_cc[VEOL2] = lios->c_cc[LINUX_VEOL2];
 417         bios->c_cc[VSUSP] = lios->c_cc[LINUX_VSUSP];
 418         bios->c_cc[VSTART] = lios->c_cc[LINUX_VSTART];
 419         bios->c_cc[VSTOP] = lios->c_cc[LINUX_VSTOP];
 420         bios->c_cc[VREPRINT] = lios->c_cc[LINUX_VREPRINT];
 421         bios->c_cc[VDISCARD] = lios->c_cc[LINUX_VDISCARD];
 422         bios->c_cc[VWERASE] = lios->c_cc[LINUX_VWERASE];
 423         bios->c_cc[VLNEXT] = lios->c_cc[LINUX_VLNEXT];
 424
 425         for (i=0; i<NCCS; i++) {
 426                  if (i != VMIN && i != VTIME &&
 427                     bios->c_cc[i] == LINUX_POSIX_VDISABLE)
 428                         bios->c_cc[i] = _POSIX_VDISABLE;
 429         }
 430
 431         bios->c_ispeed = bios->c_ospeed =
 432             linux_to_bsd_speed(lios->c_cflag & LINUX_CBAUD, sptab);
 433
 434 #ifdef DEBUG
 435         if (ldebug(ioctl)) {
 436                 printf("LINUX: BSD termios structure (output):\n");
 437                 printf("i=%08x o=%08x c=%08x l=%08x ispeed=%d ospeed=%d\n",
 438                     bios->c_iflag, bios->c_oflag, bios->c_cflag, bios->c_lflag,
 439                     bios->c_ispeed, bios->c_ospeed);
 440                 printf("c_cc ");
 441                 for (i=0; i<NCCS; i++)
 442                         printf("%02x ", bios->c_cc[i]);
 443                 printf("\n");
 444         }
 445 #endif
 446 }
 447
 448 static void
 449 bsd_to_linux_termio(struct termios *bios, struct linux_termio *lio)
 450 {
 451         struct linux_termios lios;
 452
 453         bsd_to_linux_termios(bios, &lios);
 454         lio->c_iflag = lios.c_iflag;
 455         lio->c_oflag = lios.c_oflag;
 456         lio->c_cflag = lios.c_cflag;
 457         lio->c_lflag = lios.c_lflag;
 458         lio->c_line  = lios.c_line;
 459 #ifdef __alpha__
 460         lio->c_cc[LINUX__VINTR] = lios.c_cc[LINUX_VINTR];
 461         lio->c_cc[LINUX__VQUIT] = lios.c_cc[LINUX_VQUIT];
 462         lio->c_cc[LINUX__VERASE] = lios.c_cc[LINUX_VERASE];
 463         lio->c_cc[LINUX__VKILL] = lios.c_cc[LINUX_VKILL];
 464         lio->c_cc[LINUX__VEOF] =
 465             lios.c_cc[(lios.c_lflag & ICANON) ? LINUX_VEOF : LINUX_VMIN];
 466         lio->c_cc[LINUX__VEOL] =
 467             lios.c_cc[(lios.c_lflag & ICANON) ? LINUX_VEOL : LINUX_VTIME];
 468         lio->c_cc[LINUX__VEOL2] = lios.c_cc[LINUX_VEOL2];
 469         lio->c_cc[LINUX__VSWTC] = lios.c_cc[LINUX_VSWTC];
 470 #else
 471         memcpy(lio->c_cc, lios.c_cc, LINUX_NCC);
 472 #endif
 473 }
 474
 475 static void
 476 linux_to_bsd_termio(struct linux_termio *lio, struct termios *bios)
 477 {
 478         struct linux_termios lios;
 479         int i;
 480
 481         lios.c_iflag = lio->c_iflag;
 482         lios.c_oflag = lio->c_oflag;
 483         lios.c_cflag = lio->c_cflag;
 484         lios.c_lflag = lio->c_lflag;
 485 #ifdef __alpha__
 486         for (i=0; i<LINUX_NCCS; i++)
 487                 lios.c_cc[i] = LINUX_POSIX_VDISABLE;
 488         lios.c_cc[LINUX_VINTR] = lio->c_cc[LINUX__VINTR];
 489         lios.c_cc[LINUX_VQUIT] = lio->c_cc[LINUX__VQUIT];
 490         lios.c_cc[LINUX_VERASE] = lio->c_cc[LINUX__VERASE];
 491         lios.c_cc[LINUX_VKILL] = lio->c_cc[LINUX__VKILL];
 492         lios.c_cc[LINUX_VEOL2] = lio->c_cc[LINUX__VEOL2];
 493         lios.c_cc[LINUX_VSWTC] = lio->c_cc[LINUX__VSWTC];
 494         lios.c_cc[(lio->c_lflag & ICANON) ? LINUX_VEOF : LINUX_VMIN] =
 495             lio->c_cc[LINUX__VEOF];
 496         lios.c_cc[(lio->c_lflag & ICANON) ? LINUX_VEOL : LINUX_VTIME] =
 497             lio->c_cc[LINUX__VEOL];
 498 #else
 499         for (i=LINUX_NCC; i<LINUX_NCCS; i++)
 500                 lios.c_cc[i] = LINUX_POSIX_VDISABLE;
 501         memcpy(lios.c_cc, lio->c_cc, LINUX_NCC);
 502 #endif
 503         linux_to_bsd_termios(&lios, bios);
 504 }
 505
 506 static int
 507 linux_ioctl_TCGETS(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 508 {
 509         struct termios bios;
 510         struct linux_termios lios;
 511         int error;
 512
 513         error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
 514         if (error)
 515                 return (error);
 516         bsd_to_linux_termios(&bios, &lios);
 517         bcopy(&lios, data, sizeof(lios));
 518         return (0);
 519 }
 520
 521 static int
 522 linux_ioctl_TCSETS(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 523 {
 524         struct termios bios;
 525         struct linux_termios lios;
 526
 527         bcopy(data, &lios, sizeof(lios));
 528         linux_to_bsd_termios(&lios, &bios);
 529         return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td));
 530 }
 531
 532 static int
 533 linux_ioctl_TCSETSW(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 534 {
 535         struct termios bios;
 536         struct linux_termios lios;
 537
 538         bcopy(data, &lios, sizeof(lios));
 539         linux_to_bsd_termios(&lios, &bios);
 540         return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td));
 541 }
 542
 543 static int
 544 linux_ioctl_TCSETSF(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 545 {
 546         struct termios bios;
 547         struct linux_termios lios;
 548
 549         bcopy(data, &lios, sizeof(lios));
 550         linux_to_bsd_termios(&lios, &bios);
 551         return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td));
 552 }
 553
 554 static int
 555 linux_ioctl_TCGETA(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 556 {
 557         struct termios bios;
 558         struct linux_termio lio;
 559         int error;
 560
 561         error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
 562         if (error)
 563                 return (error);
 564         bsd_to_linux_termio(&bios, &lio);
 565         bcopy(&lio, data, sizeof(lio));
 566         return (0);
 567 }
 568
 569 static int
 570 linux_ioctl_TCSETA(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 571 {
 572         struct termios bios;
 573         struct linux_termio lio;
 574
 575         bcopy(data, &lio, sizeof(lio));
 576         linux_to_bsd_termio(&lio, &bios);
 577         return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td));
 578 }
 579
 580 static int
 581 linux_ioctl_TCSETAW(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 582 {
 583         struct termios bios;
 584         struct linux_termio lio;
 585
 586         bcopy(data, &lio, sizeof(lio));
 587         linux_to_bsd_termio(&lio, &bios);
 588         return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td));
 589 }
 590
 591 static int
 592 linux_ioctl_TCSETAF(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 593 {
 594         struct termios bios;
 595         struct linux_termio lio;
 596
 597         bcopy(data, &lio, sizeof(lio));
 598         linux_to_bsd_termio(&lio, &bios);
 599         return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td));
 600 }
 601
 602 static int
 603 linux_ioctl_TCXONC(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 604 {
 605         switch ((u_long)data) {
 606         case LINUX_TCOOFF:
 607                 cmd = TIOCSTOP;
 608                 break;
 609         case LINUX_TCOON:
 610                 cmd = TIOCSTART;
 611                 break;
 612         case LINUX_TCIOFF:
 613         case LINUX_TCION: {
 614                 struct termios bios;
 615                 int error, c;
 616
 617                 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
 618                 if (error)
 619                         return (error);
 620                 c = ((u_long)data == LINUX_TCIOFF) ? VSTOP : VSTART;
 621                 c = bios.c_cc[c];
 622                 if (c != _POSIX_VDISABLE) {
 623                         struct uio auio;
 624                         struct iovec aiov;
 625
 626                         aiov.iov_base = (char *)&c;
 627                         aiov.iov_len = sizeof(*bios.c_cc);
 628                         auio.uio_iov = &aiov;
 629                         auio.uio_iovcnt = 1;
 630                         auio.uio_offset = -1;
 631                         auio.uio_resid = sizeof(*bios.c_cc);
 632                         auio.uio_rw = UIO_WRITE;
 633                         auio.uio_segflg = UIO_SYSSPACE;
 634                         auio.uio_td = td;
 635
 636                         return (fo_write(fp, &auio, fp->f_cred, 0, td));
 637                 }
 638
 639                 return (0);
 640         }
 641         default:
 642                 return (EINVAL);
 643         }
 644         return (fo_ioctl(fp, cmd, 0, td));
 645 }
 646
 647 static int
 648 linux_ioctl_TCFLSH(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 649 {
 650         switch ((u_long)data) {
 651         case LINUX_TCIFLUSH:
 652                 *(u_long *)data = FREAD;
 653                 break;
 654         case LINUX_TCOFLUSH:
 655                 *(u_long *)data = FWRITE;
 656                 break;
 657         case LINUX_TCIOFLUSH:
 658                 *(u_long *)data = FREAD | FWRITE;
 659                 break;
 660         default:
 661                 return (EINVAL);
 662         }
 663         return (fo_ioctl(fp, TIOCFLUSH, data, td));
 664 }
 665
 666 static int
 667 linux_ioctl_TIOCGSERIAL(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 668 {
 669         struct linux_serial_struct lss;
 670
 671         lss.type = LINUX_PORT_16550A;
 672         lss.flags = 0;
 673         lss.close_delay = 0;
 674         bcopy(&lss, data, sizeof(lss));
 675         return (0);
 676 }
 677
 678 static int
 679 linux_ioctl_TIOCSSERIAL(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 680 {
 681 #if 0
 682         struct linux_serial_struct lss;
 683
 684         bcopy(data, &lss, sizeof(lss));
 685         /* XXX - It really helps to have an implementation that
 686          * does nothing. NOT!
 687          */
 688 #endif
 689         return (0);
 690 }
 691
 692 static int
 693 linux_ioctl_TIOCSETD(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 694 {
 695         int line;
 696
 697         switch ((u_long)data) {
 698         case LINUX_N_TTY:
 699                 line = TTYDISC;
 700                 break;
 701         case LINUX_N_SLIP:
 702                 line = SLIPDISC;
 703                 break;
 704         case LINUX_N_PPP:
 705                 line = PPPDISC;
 706                 break;
 707         default:
 708                 return (EINVAL);
 709         }
 710         return (fo_ioctl(fp, TIOCSETD, (caddr_t)&line, td));
 711 }
 712
 713 static int
 714 linux_ioctl_TIOCGETD(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 715 {
 716         int linux_line, error;
 717         int bsd_line = TTYDISC;
 718
 719         error = fo_ioctl(fp, TIOCGETD, (caddr_t)&bsd_line, td);
 720         if (error)
 721                 return (error);
 722         switch (bsd_line) {
 723         case TTYDISC:
 724                 linux_line = LINUX_N_TTY;
 725                 break;
 726         case SLIPDISC:
 727                 linux_line = LINUX_N_SLIP;
 728                 break;
 729         case PPPDISC:
 730                 linux_line = LINUX_N_PPP;
 731                 break;
 732         default:
 733                 return (EINVAL);
 734         }
 735         bcopy(&linux_line, data, sizeof(int));
 736         return (0);
 737 }
 738
 739
 740 /*
 741  * CDROM related ioctls
 742  */
 743
 744 struct linux_cdrom_msf
 745 {
 746         u_char  cdmsf_min0;
 747         u_char  cdmsf_sec0;
 748         u_char  cdmsf_frame0;
 749         u_char  cdmsf_min1;
 750         u_char  cdmsf_sec1;
 751         u_char  cdmsf_frame1;
 752 };
 753
 754 struct linux_cdrom_tochdr
 755 {
 756         u_char  cdth_trk0;
 757         u_char  cdth_trk1;
 758 };
 759
 760 union linux_cdrom_addr
 761 {
 762         struct {
 763                 u_char  minute;
 764                 u_char  second;
 765                 u_char  frame;
 766         } msf;
 767         int     lba;
 768 };
 769
 770 struct linux_cdrom_tocentry
 771 {
 772         u_char  cdte_track;
 773         u_char  cdte_adr:4;
 774         u_char  cdte_ctrl:4;
 775         u_char  cdte_format;
 776         union linux_cdrom_addr cdte_addr;
 777         u_char  cdte_datamode;
 778 };
 779
 780 struct linux_cdrom_subchnl
 781 {
 782         u_char  cdsc_format;
 783         u_char  cdsc_audiostatus;
 784         u_char  cdsc_adr:4;
 785         u_char  cdsc_ctrl:4;
 786         u_char  cdsc_trk;
 787         u_char  cdsc_ind;
 788         union linux_cdrom_addr cdsc_absaddr;
 789         union linux_cdrom_addr cdsc_reladdr;
 790 };
 791
 792 static void
 793 bsd_to_linux_msf_lba(u_char af, union msf_lba *bp, union linux_cdrom_addr *lp)
 794 {
 795         if (af == CD_LBA_FORMAT)
 796                 lp->lba = bp->lba;
 797         else {
 798                 lp->msf.minute = bp->msf.minute;
 799                 lp->msf.second = bp->msf.second;
 800                 lp->msf.frame = bp->msf.frame;
 801         }
 802 }
 803
 804 static void
 805 set_linux_cdrom_addr(union linux_cdrom_addr *addr, int format, int lba)
 806 {
 807         if (format == LINUX_CDROM_MSF) {
 808                 addr->msf.frame = lba % 75;
 809                 lba /= 75;
 810                 lba += 2;
 811                 addr->msf.second = lba % 60;
 812                 addr->msf.minute = lba / 60;
 813         } else
 814                 addr->lba = lba;
 815 }
 816
 817 static int
 818 linux_ioctl_CDROMREADTOCHDR(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 819 {
 820         struct ioc_toc_header th;
 821         struct linux_cdrom_tochdr lth;
 822         int error;
 823
 824         error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&th, td);
 825         if (error)
 826                 return (error);
 827         lth.cdth_trk0 = th.starting_track;
 828         lth.cdth_trk1 = th.ending_track;
 829         bcopy(&lth, data, sizeof(lth));
 830         return (0);
 831 }
 832
 833 static int
 834 linux_ioctl_CDROMREADTOCENTRY(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 835 {
 836         struct linux_cdrom_tocentry *ltep = (struct linux_cdrom_tocentry *)data;
 837         struct ioc_read_toc_single_entry irtse;
 838         int error;
 839
 840         irtse.address_format = ltep->cdte_format;
 841         irtse.track = ltep->cdte_track;
 842         error = fo_ioctl(fp, CDIOREADTOCENTRY, (caddr_t)&irtse, td);
 843         if (error)
 844                 return (error);
 845
 846         ltep->cdte_ctrl = irtse.entry.control;
 847         ltep->cdte_adr = irtse.entry.addr_type;
 848         bsd_to_linux_msf_lba(irtse.address_format, &irtse.entry.addr,
 849                              &ltep->cdte_addr);
 850         return (0);
 851 }
 852
 853 static int
 854 linux_ioctl_CDROMSUBCHNL(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 855 {
 856         struct linux_cdrom_subchnl *sc = (struct linux_cdrom_subchnl *)data;
 857         struct ioc_read_subchannel bsdsc;
 858         struct cd_sub_channel_info *bsdinfo;
 859         int error;
 860         caddr_t sg = stackgap_init();
 861
 862         bsdinfo = stackgap_alloc(&sg, sizeof(struct cd_sub_channel_info));
 863         bsdsc.address_format = CD_LBA_FORMAT;
 864         bsdsc.data_format = CD_CURRENT_POSITION;
 865         bsdsc.track = 0;
 866         bsdsc.data_len = sizeof(struct cd_sub_channel_info);
 867         bsdsc.data = bsdinfo;
 868         error = fo_ioctl(fp, CDIOCREADSUBCHANNEL, (caddr_t)&bsdsc, td);
 869         if (error)
 870                 return (error);
 871         sc->cdsc_audiostatus = bsdinfo->header.audio_status;
 872         sc->cdsc_adr = bsdinfo->what.position.addr_type;
 873         sc->cdsc_ctrl = bsdinfo->what.position.control;
 874         sc->cdsc_trk = bsdinfo->what.position.track_number;
 875         sc->cdsc_ind = bsdinfo->what.position.index_number;
 876         set_linux_cdrom_addr(&sc->cdsc_absaddr, sc->cdsc_format, bsdinfo->what.position.absaddr.lba);
 877         set_linux_cdrom_addr(&sc->cdsc_reladdr, sc->cdsc_format, bsdinfo->what.position.reladdr.lba);
 878         return (0);
 879 }
 880
 881
 882 /*
 883  * Sound related ioctls
 884  */
 885
 886 static int
 887 linux_ioctl_OSS_GETVERSION(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 888 {
 889         int version = linux_get_oss_version(td);
 890
 891         bcopy(&version, data, sizeof(int));
 892         return (0);
 893 }
 894
 895
 896 /*
 897  * Console related ioctls
 898  */
 899
 900 #define ISSIGVALID(sig)         ((sig) > 0 && (sig) < NSIG)
 901
 902 static int
 903 linux_ioctl_KDSKBMODE(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 904 {
 905         int kbdmode;
 906
 907         switch ((u_long)data) {
 908         case LINUX_KBD_RAW:
 909                 kbdmode = K_RAW;
 910                 break;
 911         case LINUX_KBD_XLATE:
 912                 kbdmode = K_XLATE;
 913                 break;
 914         case LINUX_KBD_MEDIUMRAW:
 915                 kbdmode = K_RAW;
 916                 break;
 917         default:
 918                 return (EINVAL);
 919         }
 920         return (fo_ioctl(fp, KDSKBMODE, (caddr_t)&kbdmode, td));
 921 }
 922
 923 static int
 924 linux_ioctl_VT_SETMODE(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
 925 {
 926         struct vt_mode *mode = (struct vt_mode *)data;
 927
 928         if (!ISSIGVALID(mode->frsig) && ISSIGVALID(mode->acqsig))
 929                 mode->frsig = mode->acqsig;
 930         return (fo_ioctl(fp, VT_SETMODE, data, td));
 931 }
 932
 933
 934 /*
 935  * Socket related ioctls
 936  */
 937
 938 /*
 939  * Criteria for interface name translation
 940  */
 941 #define IFP_IS_ETH(ifp) (ifp->if_type == IFT_ETHER)
 942
 943 /*
 944  * Interface function used by linprocfs (at the time of writing). It's not
 945  * used by the Linuxulator itself.
 946  */
 947 int
 948 linux_ifname(struct ifnet *ifp, char *buffer, size_t buflen)
 949 {
 950         struct ifnet *ifscan;
 951         int ethno;
 952
 953         /* Short-circuit non ethernet interfaces */
 954         if (!IFP_IS_ETH(ifp))
 955                 return (strlcpy(buffer, ifp->if_xname, buflen));
 956
 957         /* Determine the (relative) unit number for ethernet interfaces */
 958         ethno = 0;
 959         TAILQ_FOREACH(ifscan, &ifnet, if_link) {
 960                 if (ifscan == ifp)
 961                         return (snprintf(buffer, buflen, "eth%d", ethno));
 962                 if (IFP_IS_ETH(ifscan))
 963                         ethno++;
 964         }
 965
 966         return (0);
 967 }
 968
 969 /*
 970  * Translate a Linux interface name to a FreeBSD interface name,
 971  * and return the associated ifnet structure
 972  * bsdname and lxname need to be least IFNAMSIZ bytes long, but
 973  * can point to the same buffer.
 974  */
 975
 976 static struct ifnet *
 977 ifname_linux_to_bsd(const char *lxname, char *bsdname)
 978 {
 979         struct ifnet *ifp;
 980         int len, unit;
 981         char *ep;
 982         int is_eth, index;
 983
 984         for (len = 0; len < LINUX_IFNAMSIZ; ++len)
 985                 if (!isalpha(lxname[len]))
 986                         break;
 987         if (len == 0 || len == LINUX_IFNAMSIZ)
 988                 return (NULL);
 989         unit = (int)strtoul(lxname + len, &ep, 10);
 990         if (ep == NULL || ep == lxname + len || ep >= lxname + LINUX_IFNAMSIZ)
 991                 return (NULL);
 992         index = 0;
 993         is_eth = (len == 3 && !strncmp(lxname, "eth", len)) ? 1 : 0;
 994         TAILQ_FOREACH(ifp, &ifnet, if_link) {
 995                 /*
 996                  * Allow Linux programs to use FreeBSD names. Don't presume
 997                  * we never have an interface named "eth", so don't make
 998                  * the test optional based on is_eth.
 999                  */
1000                 if (strncmp(ifp->if_xname, lxname, LINUX_IFNAMSIZ) == 0)
1001                         break;
1002                 if (is_eth && IFP_IS_ETH(ifp) && unit == index++)
1003                         break;
1004         }
1005         if (ifp != NULL)
1006                 strlcpy(bsdname, ifp->if_xname, IFNAMSIZ);
1007         return (ifp);
1008 }
1009
1010 static int
1011 linux_ioctl_SIOCGIFCONF(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
1012 {
1013         struct ifconf *ifc = (struct ifconf *)data;
1014         struct l_ifreq ifr;
1015         struct ifnet *ifp;
1016         struct ifaddr *ifa;
1017         struct iovec iov;
1018         struct uio uio;
1019         int error, ethno;
1020
1021         /* much easier to use uiomove than keep track ourselves */
1022         iov.iov_base = ifc->ifc_buf;
1023         iov.iov_len = ifc->ifc_len;
1024         uio.uio_iov = &iov;
1025         uio.uio_iovcnt = 1;
1026         uio.uio_offset = 0;
1027         uio.uio_resid = ifc->ifc_len;
1028         uio.uio_segflg = UIO_USERSPACE;
1029         uio.uio_rw = UIO_READ;
1030         uio.uio_td = td;
1031
1032         /* Keep track of eth interfaces */
1033         ethno = 0;
1034
1035         /* Return all AF_INET addresses of all interfaces */
1036         TAILQ_FOREACH(ifp, &ifnet, if_link) {
1037                 if (uio.uio_resid <= 0)
1038                         break;
1039
1040                 bzero(&ifr, sizeof ifr);
1041                 if (IFP_IS_ETH(ifp))
1042                         snprintf(ifr.ifr_name, LINUX_IFNAMSIZ, "eth%d",
1043                             ethno++);
1044                 else
1045                         strlcpy(ifr.ifr_name, ifp->if_xname, LINUX_IFNAMSIZ);
1046
1047                 /* Walk the address list */
1048                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1049                         struct sockaddr *sa = ifa->ifa_addr;
1050
1051                         if (uio.uio_resid <= 0)
1052                                 break;
1053
1054                         if (sa->sa_family == AF_INET) {
1055                                 ifr.ifr_addr.sa_family = LINUX_AF_INET;
1056                                 memcpy(ifr.ifr_addr.sa_data, sa->sa_data,
1057                                     sizeof(ifr.ifr_addr.sa_data));
1058
1059                                 error = uiomove((caddr_t)&ifr, sizeof ifr,
1060                                     &uio);
1061                                 if (error != 0)
1062                                         return (error);
1063                         }
1064                 }
1065         }
1066
1067         ifc->ifc_len -= uio.uio_resid;
1068
1069         return (0);
1070 }
1071
1072 static int
1073 linux_ioctl_SIOCGIFFLAGS(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
1074 {
1075         struct l_ifreq *ifr = (struct l_ifreq *)data;
1076         struct ifnet *ifp;
1077         char ifname[IFNAMSIZ];
1078         l_short flags;
1079
1080         if (fp->f_type != DTYPE_SOCKET) {
1081                 /* XXX: I doubt this is correct because
1082                  *      we don't translate the ifname and
1083                  *      use l_ifreq instead of ifreq
1084                  */
1085                 return (fo_ioctl(fp, SIOCGIFFLAGS, data, td));
1086         }
1087
1088         ifp = ifname_linux_to_bsd(ifr->ifr_name, ifname);
1089         flags = ifp->if_flags;
1090         /* these flags have no Linux equivalent */
1091         flags &= ~(IFF_SMART|IFF_OACTIVE|IFF_SIMPLEX|
1092             IFF_LINK0|IFF_LINK1|IFF_LINK2);
1093         /* Linux' multicast flag is in a different bit */
1094         if (flags & IFF_MULTICAST) {
1095                 flags &= ~IFF_MULTICAST;
1096                 flags |= 0x1000;
1097         }
1098
1099         ifr->ifr_flags = flags;
1100         return (0);
1101 }
1102
1103 #define ARPHRD_ETHER    1
1104 #define ARPHRD_LOOPBACK 772
1105
1106 static int
1107 linux_ioctl_SIOGIFHWADDR(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
1108 {
1109         struct l_ifreq *ifr = (struct l_ifreq *)data;
1110         struct ifnet *ifp;
1111         char ifname[IFNAMSIZ];
1112         struct ifaddr *ifa;
1113         struct sockaddr_dl *sdl;
1114         struct l_sockaddr lsa;
1115
1116         ifp = ifname_linux_to_bsd(ifr->ifr_name, ifname);
1117         if (ifp->if_type == IFT_LOOP) {
1118                 bzero(&ifr->ifr_hwaddr, sizeof lsa);
1119                 ifr->ifr_hwaddr.sa_family = ARPHRD_LOOPBACK;
1120                 return (0);
1121         }
1122
1123         if (ifp->if_type != IFT_ETHER)
1124                 return (ENOENT);
1125
1126         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1127                 sdl = (struct sockaddr_dl*)ifa->ifa_addr;
1128                 if (sdl != NULL && (sdl->sdl_family == AF_LINK) &&
1129                     (sdl->sdl_type == IFT_ETHER)) {
1130                         bzero(&ifr->ifr_hwaddr, sizeof lsa);
1131                         ifr->ifr_hwaddr.sa_family = ARPHRD_ETHER;
1132                         bcopy(LLADDR(sdl), ifr->ifr_hwaddr.sa_data, LINUX_IFHWADDRLEN);
1133                         return (0);
1134                 }
1135         }
1136
1137         return (ENOENT);
1138 }
1139
1140 static int
1141 linux_ioctl_map_ifname(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
1142 {
1143         struct ifnet *ifp;
1144         int error;
1145         char *oifname = (char *)data;
1146         char lifname[LINUX_IFNAMSIZ];
1147
1148         KASSERT(LINUX_IFNAMSIZ == IFNAMSIZ,
1149             ("%s(): LINUX_IFNAMSIZ != IFNAMSIZ", __FUNCTION__));
1150
1151         if (fp->f_type != DTYPE_SOCKET) {
1152                 /*
1153                  *  XXX: I doubt this is correct because
1154                  *       we don't map the ifname
1155                  */
1156                 /* not a socket - probably a tap / vmnet device */
1157                 if (ocmd == LINUX_SIOCGIFADDR || ocmd == LINUX_SIOCSIFADDR) {
1158                         cmd = (ocmd == LINUX_SIOCGIFADDR) ? SIOCGIFADDR : SIOCSIFADDR;
1159                         return (fo_ioctl(fp, cmd, data, td));
1160                 } else
1161                         return (ENOIOCTL);
1162         }
1163
1164         /* Save the original ifname */
1165         bcopy(oifname, lifname, LINUX_IFNAMSIZ);
1166 #ifdef DEBUG
1167         printf("%s(): ioctl %d on %.*s\n", __FUNCTION__,
1168                 (int)(cmd & 0xffff), LINUX_IFNAMSIZ, lifname);
1169 #endif
1170         /* Replace linux ifname with bsd ifname */
1171         ifp = ifname_linux_to_bsd(lifname, oifname);
1172         if (ifp == NULL) {
1173                 error = EINVAL;
1174                 goto clean_ifname;
1175         }
1176
1177 #ifdef DEBUG
1178         printf("%s(): %s translated to %s\n", __FUNCTION__,
1179                 lifname, oifname);
1180 #endif
1181
1182         error = fo_ioctl(fp, cmd, data, td);
1183
1184 clean_ifname:
1185         bcopy(lifname, oifname, LINUX_IFNAMSIZ);
1186         return (error);
1187 }
1188
1189
1190 /*
1191  * generic linux -> BSD syscall direction mapper
1192  */
1193 int
1194 linux_ioctl_dirmap(struct file *fp, u_long cmd, u_long ocmd, caddr_t data, struct thread *td)
1195 {
1196         static u_int32_t dirbits[4] = { IOC_VOID, IOC_IN, IOC_OUT, IOC_INOUT };
1197
1198         return (fo_ioctl(fp, (cmd & ~IOC_DIRMASK) | dirbits[ocmd >> 30], data, td));
1199 }
1200
1201
1202 static struct ioctl_map_range linux_ioctl_map_entries[] = {
1203         /* disk ioctl */
1204         MAPPED_IOCTL_IOR(LINUX_BLKGETSIZE, linux_ioctl_BLKGETSIZE, uint32_t),
1205         /* termio ioctl */
1206         MAPPED_IOCTL_IOR(LINUX_TCGETS, linux_ioctl_TCGETS, struct linux_termios),
1207         MAPPED_IOCTL_IOW(LINUX_TCSETS, linux_ioctl_TCSETS, struct linux_termios),
1208         MAPPED_IOCTL_IOW(LINUX_TCSETSW, linux_ioctl_TCSETSW, struct linux_termios),
1209         MAPPED_IOCTL_IOW(LINUX_TCSETSF, linux_ioctl_TCSETSF, struct linux_termios),
1210         MAPPED_IOCTL_IOR(LINUX_TCGETA, linux_ioctl_TCGETA, struct linux_termio),
1211         MAPPED_IOCTL_IOW(LINUX_TCSETA, linux_ioctl_TCSETA, struct linux_termio),
1212         MAPPED_IOCTL_IOW(LINUX_TCSETAW, linux_ioctl_TCSETAW, struct linux_termio),
1213         MAPPED_IOCTL_IOW(LINUX_TCSETAF, linux_ioctl_TCSETAF, struct linux_termio),
1214         MAPPED_IOCTL_IO(LINUX_TCXONC, linux_ioctl_TCXONC),
1215         MAPPED_IOCTL_IO(LINUX_TCFLSH, linux_ioctl_TCFLSH),
1216         MAPPED_IOCTL_MAP(LINUX_TIOCEXCL, TIOCEXCL),
1217         MAPPED_IOCTL_MAP(LINUX_TIOCNXCL, TIOCNXCL),
1218         MAPPED_IOCTL_MAP(LINUX_TIOCGPGRP, TIOCGPGRP),
1219         MAPPED_IOCTL_MAP(LINUX_TIOCSPGRP, TIOCSPGRP),
1220         MAPPED_IOCTL_MAP(LINUX_TIOCGWINSZ, TIOCGWINSZ),
1221         MAPPED_IOCTL_MAP(LINUX_TIOCSWINSZ, TIOCSWINSZ),
1222         MAPPED_IOCTL_MAP(LINUX_TIOCMGET, TIOCMGET),
1223         MAPPED_IOCTL_MAP(LINUX_TIOCMBIS, TIOCMBIS),
1224         MAPPED_IOCTL_MAP(LINUX_TIOCMBIC, TIOCMBIC),
1225         MAPPED_IOCTL_MAP(LINUX_TIOCMSET, TIOCMSET),
1226         MAPPED_IOCTL_MAP(LINUX_FIONREAD, FIONREAD),
1227         MAPPED_IOCTL_MAP(LINUX_TIOCCONS, TIOCCONS),
1228         MAPPED_IOCTL_IOR(LINUX_TIOCGSERIAL, linux_ioctl_TIOCGSERIAL, struct linux_serial_struct),
1229         MAPPED_IOCTL_IOW(LINUX_TIOCSSERIAL, linux_ioctl_TIOCSSERIAL, struct linux_serial_struct),
1230         MAPPED_IOCTL_MAP(LINUX_FIONBIO, FIONBIO),
1231         MAPPED_IOCTL_MAP(LINUX_TIOCNOTTY, TIOCNOTTY),
1232         MAPPED_IOCTL_IO(LINUX_TIOCSETD, linux_ioctl_TIOCSETD),
1233         MAPPED_IOCTL_IOR(LINUX_TIOCGETD, linux_ioctl_TIOCGETD, int),
1234         MAPPED_IOCTL_MAP(LINUX_FIONCLEX, FIONCLEX),
1235         MAPPED_IOCTL_MAP(LINUX_FIOCLEX, FIOCLEX),
1236         MAPPED_IOCTL_MAP(LINUX_FIOASYNC, FIOASYNC),
1237         /* cdrom ioctl */
1238         MAPPED_IOCTL_MAP(LINUX_CDROMPAUSE, CDIOCPAUSE),
1239         MAPPED_IOCTL_MAP(LINUX_CDROMRESUME, CDIOCRESUME),
1240         MAPPED_IOCTL_MAP(LINUX_CDROMPLAYMSF, CDIOCPLAYMSF),
1241         MAPPED_IOCTL_MAP(LINUX_CDROMPLAYTRKIND, CDIOCPLAYTRACKS),
1242         MAPPED_IOCTL_IOR(LINUX_CDROMREADTOCHDR, linux_ioctl_CDROMREADTOCHDR, struct linux_cdrom_tochdr),
1243         MAPPED_IOCTL_IOWR(LINUX_CDROMREADTOCENTRY, linux_ioctl_CDROMREADTOCENTRY, struct linux_cdrom_tocentry),
1244         MAPPED_IOCTL_MAP(LINUX_CDROMSTOP, CDIOCSTOP),
1245         MAPPED_IOCTL_MAP(LINUX_CDROMSTART, CDIOCSTART),
1246         MAPPED_IOCTL_MAP(LINUX_CDROMEJECT, CDIOCEJECT),
1247         MAPPED_IOCTL_IOWR(LINUX_CDROMSUBCHNL, linux_ioctl_CDROMSUBCHNL, struct linux_cdrom_subchnl),
1248         MAPPED_IOCTL_MAP(LINUX_CDROMRESET, CDIOCRESET),
1249         /* sound ioctl */
1250         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_VOLUME, SOUND_MIXER_WRITE_VOLUME, linux_ioctl_dirmap),
1251         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_BASS, SOUND_MIXER_WRITE_BASS, linux_ioctl_dirmap),
1252         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_TREBLE, SOUND_MIXER_WRITE_TREBLE, linux_ioctl_dirmap),
1253         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_SYNTH, SOUND_MIXER_WRITE_SYNTH, linux_ioctl_dirmap),
1254         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_PCM, SOUND_MIXER_WRITE_PCM, linux_ioctl_dirmap),
1255         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_SPEAKER, SOUND_MIXER_WRITE_SPEAKER, linux_ioctl_dirmap),
1256         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_LINE, SOUND_MIXER_WRITE_LINE, linux_ioctl_dirmap),
1257         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_MIC, SOUND_MIXER_WRITE_MIC, linux_ioctl_dirmap),
1258         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_CD, SOUND_MIXER_WRITE_CD, linux_ioctl_dirmap),
1259         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_IMIX, SOUND_MIXER_WRITE_IMIX, linux_ioctl_dirmap),
1260         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_ALTPCM, SOUND_MIXER_WRITE_ALTPCM, linux_ioctl_dirmap),
1261         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_RECLEV, SOUND_MIXER_WRITE_RECLEV, linux_ioctl_dirmap),
1262         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_IGAIN, SOUND_MIXER_WRITE_IGAIN, linux_ioctl_dirmap),
1263         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_OGAIN, SOUND_MIXER_WRITE_OGAIN, linux_ioctl_dirmap),
1264         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_LINE1, SOUND_MIXER_WRITE_LINE1, linux_ioctl_dirmap),
1265         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_LINE2, SOUND_MIXER_WRITE_LINE2, linux_ioctl_dirmap),
1266         MAPPED_IOCTL_MAPF(LINUX_SOUND_MIXER_WRITE_LINE3, SOUND_MIXER_WRITE_LINE3, linux_ioctl_dirmap),
1267         MAPPED_IOCTL_IOR(LINUX_OSS_GETVERSION, linux_ioctl_OSS_GETVERSION, int),
1268         MAPPED_IOCTL_MAP(LINUX_SOUND_MIXER_READ_DEVMASK, SOUND_MIXER_READ_DEVMASK),
1269         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_RESET, SNDCTL_DSP_RESET),
1270         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_SYNC, SNDCTL_DSP_SYNC),
1271         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_SPEED, SNDCTL_DSP_SPEED),
1272         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_STEREO, SNDCTL_DSP_STEREO),
1273         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETBLKSIZE, SNDCTL_DSP_GETBLKSIZE),
1274         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_SETFMT, SNDCTL_DSP_SETFMT),
1275         MAPPED_IOCTL_MAP(LINUX_SOUND_PCM_WRITE_CHANNELS, SOUND_PCM_WRITE_CHANNELS),
1276         MAPPED_IOCTL_MAP(LINUX_SOUND_PCM_WRITE_FILTER, SOUND_PCM_WRITE_FILTER),
1277         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_POST, SNDCTL_DSP_POST),
1278         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_SUBDIVIDE, SNDCTL_DSP_SUBDIVIDE),
1279         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_SETFRAGMENT, SNDCTL_DSP_SETFRAGMENT),
1280         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETFMTS, SNDCTL_DSP_GETFMTS),
1281         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETOSPACE, SNDCTL_DSP_GETOSPACE),
1282         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETISPACE, SNDCTL_DSP_GETISPACE),
1283         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_NONBLOCK, SNDCTL_DSP_NONBLOCK),
1284         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETCAPS, SNDCTL_DSP_GETCAPS),
1285         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_SETTRIGGER, SNDCTL_DSP_SETTRIGGER),
1286         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETIPTR, SNDCTL_DSP_GETIPTR),
1287         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETOPTR, SNDCTL_DSP_GETOPTR),
1288         MAPPED_IOCTL_MAP(LINUX_SNDCTL_DSP_GETODELAY, SNDCTL_DSP_GETODELAY),
1289         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_RESET, SNDCTL_SEQ_RESET),
1290         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_SYNC, SNDCTL_SEQ_SYNC),
1291         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SYNTH_INFO, SNDCTL_SYNTH_INFO),
1292         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_CTRLRATE, SNDCTL_SEQ_CTRLRATE),
1293         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_GETOUTCOUNT, SNDCTL_SEQ_GETOUTCOUNT),
1294         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_GETINCOUNT, SNDCTL_SEQ_GETINCOUNT),
1295         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_PERCMODE, SNDCTL_SEQ_PERCMODE),
1296         MAPPED_IOCTL_MAP(LINUX_SNDCTL_FM_LOAD_INSTR, SNDCTL_FM_LOAD_INSTR),
1297         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_TESTMIDI, SNDCTL_SEQ_TESTMIDI),
1298         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_RESETSAMPLES, SNDCTL_SEQ_RESETSAMPLES),
1299         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_NRSYNTHS, SNDCTL_SEQ_NRSYNTHS),
1300         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_NRMIDIS, SNDCTL_SEQ_NRMIDIS),
1301         MAPPED_IOCTL_MAP(LINUX_SNDCTL_MIDI_INFO, SNDCTL_MIDI_INFO),
1302         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SEQ_TRESHOLD, SNDCTL_SEQ_TRESHOLD),
1303         MAPPED_IOCTL_MAP(LINUX_SNDCTL_SYNTH_MEMAVL, SNDCTL_SYNTH_MEMAVL),
1304         /* console ioctl */
1305         MAPPED_IOCTL_MAP(LINUX_KIOCSOUND, KIOCSOUND),
1306         MAPPED_IOCTL_MAP(LINUX_KDMKTONE, KDMKTONE),
1307         MAPPED_IOCTL_MAP(LINUX_KDGETLED, KDGETLED),
1308         MAPPED_IOCTL_MAP(LINUX_KDSETLED, KDSETLED),
1309         MAPPED_IOCTL_MAP(LINUX_KDSETMODE, KDSETMODE),
1310         MAPPED_IOCTL_MAP(LINUX_KDGETMODE, KDGETMODE),
1311         MAPPED_IOCTL_MAP(LINUX_KDGKBMODE, KDGKBMODE),
1312         MAPPED_IOCTL_IOW(LINUX_KDSKBMODE, linux_ioctl_KDSKBMODE, int),
1313         MAPPED_IOCTL_MAP(LINUX_VT_OPENQRY, VT_OPENQRY),
1314         MAPPED_IOCTL_MAP(LINUX_VT_GETMODE, VT_GETMODE),
1315         MAPPED_IOCTL_IOW(LINUX_VT_SETMODE, linux_ioctl_VT_SETMODE, struct vt_mode),
1316         MAPPED_IOCTL_MAP(LINUX_VT_GETSTATE, VT_GETACTIVE),
1317         MAPPED_IOCTL_MAP(LINUX_VT_RELDISP, VT_RELDISP),
1318         MAPPED_IOCTL_MAP(LINUX_VT_ACTIVATE, VT_ACTIVATE),
1319         MAPPED_IOCTL_MAP(LINUX_VT_WAITACTIVE, VT_WAITACTIVE),
1320         /* socket ioctl */
1321         MAPPED_IOCTL_MAP(LINUX_FIOSETOWN, FIOSETOWN),
1322         MAPPED_IOCTL_MAP(LINUX_SIOCSPGRP, SIOCSPGRP),
1323         MAPPED_IOCTL_MAP(LINUX_FIOGETOWN, FIOGETOWN),
1324         MAPPED_IOCTL_MAP(LINUX_SIOCGPGRP, SIOCGPGRP),
1325         MAPPED_IOCTL_MAP(LINUX_SIOCATMARK, SIOCATMARK),
1326         MAPPED_IOCTL_IOWR(LINUX_SIOCGIFCONF, linux_ioctl_SIOCGIFCONF, struct ifconf),
1327         MAPPED_IOCTL_IOWR(LINUX_SIOCGIFFLAGS, linux_ioctl_SIOCGIFFLAGS, struct l_ifreq),
1328         MAPPED_IOCTL_MAPF(LINUX_SIOCGIFADDR, OSIOCGIFADDR, linux_ioctl_map_ifname),
1329         MAPPED_IOCTL_MAPF(LINUX_SIOCSIFADDR, SIOCSIFADDR, linux_ioctl_map_ifname),
1330         MAPPED_IOCTL_MAPF(LINUX_SIOCGIFDSTADDR, OSIOCGIFDSTADDR, linux_ioctl_map_ifname),
1331         MAPPED_IOCTL_MAPF(LINUX_SIOCGIFBRDADDR, OSIOCGIFBRDADDR, linux_ioctl_map_ifname),
1332         MAPPED_IOCTL_MAPF(LINUX_SIOCGIFNETMASK, OSIOCGIFNETMASK, linux_ioctl_map_ifname),
1333         /*MAPPED_IOCTL_IOx(LINUX_SIOCSIFNETMASK, x, x),*/
1334         MAPPED_IOCTL_MAPF(LINUX_SIOCGIFMTU, SIOCGIFMTU, linux_ioctl_map_ifname),
1335         MAPPED_IOCTL_MAPF(LINUX_SIOCSIFMTU, SIOCSIFMTU, linux_ioctl_map_ifname),
1336         MAPPED_IOCTL_IOWR(LINUX_SIOCGIFHWADDR, linux_ioctl_SIOGIFHWADDR, struct l_ifreq),
1337         MAPPED_IOCTL_MAP(LINUX_SIOCADDMULTI, SIOCADDMULTI),
1338         MAPPED_IOCTL_MAP(LINUX_SIOCDELMULTI, SIOCDELMULTI),
1339         /*
1340          * XXX This is slightly bogus, but these ioctls are currently
1341          * XXX only used by the aironet (if_an) network driver.
1342          */
1343         MAPPED_IOCTL_MAPF(LINUX_SIOCDEVPRIVATE, SIOCGPRIVATE_0, linux_ioctl_map_ifname),
1344         MAPPED_IOCTL_MAPF(LINUX_SIOCDEVPRIVATE+1, SIOCGPRIVATE_1, linux_ioctl_map_ifname),
1345         MAPPED_IOCTL_MAPF(0, 0, NULL)
1346         };
1347
1348 struct ioctl_map linux_ioctl_map = {
1349         0xffff,         /* mask */
1350         "linux",        /* subsys */
1351         LIST_HEAD_INITIALIZER(mapping)
1352         };
1353
1354 static struct ioctl_map_handler linux_ioctl_base_handler = {
1355         &linux_ioctl_map,
1356         "base",
1357         linux_ioctl_map_entries
1358         };
1359
1360 /*
1361  * main ioctl syscall function
1362  */
1363
1364 int
1365 linux_ioctl(struct linux_ioctl_args *args)
1366 {
1367 #ifdef DEBUG
1368         if (ldebug(ioctl))
1369                 printf(ARGS(ioctl, "%d, %04x, *"), args->fd, args->cmd);
1370 #endif
1371
1372         return (mapped_ioctl(args->fd, args->cmd, (caddr_t)args->arg, &linux_ioctl_map));
1373 }
1374
1375 SYSINIT  (linux_ioctl_register, SI_SUB_KLD, SI_ORDER_MIDDLE,
1376           mapped_ioctl_register_handler, &linux_ioctl_base_handler);
1377 SYSUNINIT(linux_ioctl_register, SI_SUB_KLD, SI_ORDER_MIDDLE,
1378           mapped_ioctl_unregister_handler, &linux_ioctl_base_handler);