git.oblomov.eu Git - linux-2.6/blob - drivers/char/tty_ioctl.c

   1 /*
   2  *  linux/drivers/char/tty_ioctl.c
   3  *
   4  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
   5  *
   6  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
   7  * which can be dynamically activated and de-activated by the line
   8  * discipline handling modules (like SLIP).
   9  */
  10
  11 #include <linux/types.h>
  12 #include <linux/termios.h>
  13 #include <linux/errno.h>
  14 #include <linux/sched.h>
  15 #include <linux/kernel.h>
  16 #include <linux/major.h>
  17 #include <linux/tty.h>
  18 #include <linux/fcntl.h>
  19 #include <linux/string.h>
  20 #include <linux/mm.h>
  21 #include <linux/module.h>
  22 #include <linux/bitops.h>
  23 #include <linux/mutex.h>
  24
  25 #include <asm/io.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/system.h>
  28
  29 #undef TTY_DEBUG_WAIT_UNTIL_SENT
  30
  31 #undef  DEBUG
  32
  33 /*
  34  * Internal flag options for termios setting behavior
  35  */
  36 #define TERMIOS_FLUSH   1
  37 #define TERMIOS_WAIT    2
  38 #define TERMIOS_TERMIO  4
  39 #define TERMIOS_OLD     8
  40
  41
  42 /**
  43  *      tty_wait_until_sent     -       wait for I/O to finish
  44  *      @tty: tty we are waiting for
  45  *      @timeout: how long we will wait
  46  *
  47  *      Wait for characters pending in a tty driver to hit the wire, or
  48  *      for a timeout to occur (eg due to flow control)
  49  *
  50  *      Locking: none
  51  */
  52
  53 void tty_wait_until_sent(struct tty_struct * tty, long timeout)
  54 {
  55 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  56         char buf[64];
  57
  58         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
  59 #endif
  60         if (!tty->driver->chars_in_buffer)
  61                 return;
  62         if (!timeout)
  63                 timeout = MAX_SCHEDULE_TIMEOUT;
  64         if (wait_event_interruptible_timeout(tty->write_wait,
  65                         !tty->driver->chars_in_buffer(tty), timeout) < 0)
  66                 return;
  67         if (tty->driver->wait_until_sent)
  68                 tty->driver->wait_until_sent(tty, timeout);
  69 }
  70
  71 EXPORT_SYMBOL(tty_wait_until_sent);
  72
  73 static void unset_locked_termios(struct ktermios *termios,
  74                                  struct ktermios *old,
  75                                  struct ktermios *locked)
  76 {
  77         int     i;
  78
  79 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
  80
  81         if (!locked) {
  82                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
  83                 return;
  84         }
  85
  86         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
  87         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
  88         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
  89         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
  90         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
  91         for (i=0; i < NCCS; i++)
  92                 termios->c_cc[i] = locked->c_cc[i] ?
  93                         old->c_cc[i] : termios->c_cc[i];
  94         /* FIXME: What should we do for i/ospeed */
  95 }
  96
  97 /*
  98  * Routine which returns the baud rate of the tty
  99  *
 100  * Note that the baud_table needs to be kept in sync with the
 101  * include/asm/termbits.h file.
 102  */
 103 static const speed_t baud_table[] = {
 104         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
 105         9600, 19200, 38400, 57600, 115200, 230400, 460800,
 106 #ifdef __sparc__
 107         76800, 153600, 307200, 614400, 921600
 108 #else
 109         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
 110         2500000, 3000000, 3500000, 4000000
 111 #endif
 112 };
 113
 114 #ifndef __sparc__
 115 static const tcflag_t baud_bits[] = {
 116         B0, B50, B75, B110, B134, B150, B200, B300, B600,
 117         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
 118         B57600, B115200, B230400, B460800, B500000, B576000,
 119         B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
 120         B3000000, B3500000, B4000000
 121 };
 122 #else
 123 static const tcflag_t baud_bits[] = {
 124         B0, B50, B75, B110, B134, B150, B200, B300, B600,
 125         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
 126         B57600, B115200, B230400, B460800, B76800, B153600,
 127         B307200, B614400, B921600
 128 };
 129 #endif
 130
 131 static int n_baud_table = ARRAY_SIZE(baud_table);
 132
 133 /**
 134  *      tty_termios_baud_rate
 135  *      @termios: termios structure
 136  *
 137  *      Convert termios baud rate data into a speed. This should be called
 138  *      with the termios lock held if this termios is a terminal termios
 139  *      structure. May change the termios data. Device drivers can call this
 140  *      function but should use ->c_[io]speed directly as they are updated.
 141  *
 142  *      Locking: none
 143  */
 144
 145 speed_t tty_termios_baud_rate(struct ktermios *termios)
 146 {
 147         unsigned int cbaud;
 148
 149         cbaud = termios->c_cflag & CBAUD;
 150
 151 #ifdef BOTHER
 152         /* Magic token for arbitary speed via c_ispeed/c_ospeed */
 153         if (cbaud == BOTHER)
 154                 return termios->c_ospeed;
 155 #endif
 156         if (cbaud & CBAUDEX) {
 157                 cbaud &= ~CBAUDEX;
 158
 159                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
 160                         termios->c_cflag &= ~CBAUDEX;
 161                 else
 162                         cbaud += 15;
 163         }
 164         return baud_table[cbaud];
 165 }
 166
 167 EXPORT_SYMBOL(tty_termios_baud_rate);
 168
 169 /**
 170  *      tty_termios_input_baud_rate
 171  *      @termios: termios structure
 172  *
 173  *      Convert termios baud rate data into a speed. This should be called
 174  *      with the termios lock held if this termios is a terminal termios
 175  *      structure. May change the termios data. Device drivers can call this
 176  *      function but should use ->c_[io]speed directly as they are updated.
 177  *
 178  *      Locking: none
 179  */
 180
 181 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
 182 {
 183 #ifdef IBSHIFT
 184         unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
 185
 186         if (cbaud == B0)
 187                 return tty_termios_baud_rate(termios);
 188
 189         /* Magic token for arbitary speed via c_ispeed*/
 190         if (cbaud == BOTHER)
 191                 return termios->c_ispeed;
 192
 193         if (cbaud & CBAUDEX) {
 194                 cbaud &= ~CBAUDEX;
 195
 196                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
 197                         termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
 198                 else
 199                         cbaud += 15;
 200         }
 201         return baud_table[cbaud];
 202 #else
 203         return tty_termios_baud_rate(termios);
 204 #endif
 205 }
 206
 207 EXPORT_SYMBOL(tty_termios_input_baud_rate);
 208
 209 /**
 210  *      tty_termios_encode_baud_rate
 211  *      @termios: ktermios structure holding user requested state
 212  *      @ispeed: input speed
 213  *      @ospeed: output speed
 214  *
 215  *      Encode the speeds set into the passed termios structure. This is
 216  *      used as a library helper for drivers os that they can report back
 217  *      the actual speed selected when it differs from the speed requested
 218  *
 219  *      For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
 220  *      we need to carefully set the bits when the user does not get the
 221  *      desired speed. We allow small margins and preserve as much of possible
 222  *      of the input intent to keep compatiblity.
 223  *
 224  *      Locking: Caller should hold termios lock. This is already held
 225  *      when calling this function from the driver termios handler.
 226  *
 227  *      The ifdefs deal with platforms whose owners have yet to update them
 228  *      and will all go away once this is done.
 229  */
 230
 231 void tty_termios_encode_baud_rate(struct ktermios *termios,
 232                                   speed_t ibaud, speed_t obaud)
 233 {
 234         int i = 0;
 235         int ifound = -1, ofound = -1;
 236         int iclose = ibaud/50, oclose = obaud/50;
 237         int ibinput = 0;
 238
 239         if (obaud == 0)                 /* CD dropped             */
 240                 ibaud = 0;              /* Clear ibaud to be sure */
 241
 242         termios->c_ispeed = ibaud;
 243         termios->c_ospeed = obaud;
 244
 245 #ifdef BOTHER
 246         /* If the user asked for a precise weird speed give a precise weird
 247            answer. If they asked for a Bfoo speed they many have problems
 248            digesting non-exact replies so fuzz a bit */
 249
 250         if ((termios->c_cflag & CBAUD) == BOTHER)
 251                 oclose = 0;
 252         if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
 253                 iclose = 0;
 254         if ((termios->c_cflag >> IBSHIFT) & CBAUD)
 255                 ibinput = 1;    /* An input speed was specified */
 256 #endif
 257         termios->c_cflag &= ~CBAUD;
 258
 259         /*
 260          *      Our goal is to find a close match to the standard baud rate
 261          *      returned. Walk the baud rate table and if we get a very close
 262          *      match then report back the speed as a POSIX Bxxxx value by
 263          *      preference
 264          */
 265
 266         do {
 267                 if (obaud - oclose <= baud_table[i] &&
 268                     obaud + oclose >= baud_table[i]) {
 269                         termios->c_cflag |= baud_bits[i];
 270                         ofound = i;
 271                 }
 272                 if (ibaud - iclose <= baud_table[i] &&
 273                     ibaud + iclose >= baud_table[i]) {
 274                         /* For the case input == output don't set IBAUD bits
 275                            if the user didn't do so */
 276                         if (ofound == i && !ibinput)
 277                                 ifound  = i;
 278 #ifdef IBSHIFT
 279                         else {
 280                                 ifound = i;
 281                                 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
 282                         }
 283 #endif
 284                 }
 285         } while (++i < n_baud_table);
 286
 287         /*
 288          *      If we found no match then use BOTHER if provided or warn
 289          *      the user their platform maintainer needs to wake up if not.
 290          */
 291 #ifdef BOTHER
 292         if (ofound == -1)
 293                 termios->c_cflag |= BOTHER;
 294         /* Set exact input bits only if the input and output differ or the
 295            user already did */
 296         if (ifound == -1 && (ibaud != obaud || ibinput))
 297                 termios->c_cflag |= (BOTHER << IBSHIFT);
 298 #else
 299         if (ifound == -1 || ofound == -1) {
 300                 static int warned;
 301                 if (!warned++)
 302                         printk(KERN_WARNING "tty: Unable to return correct "
 303                           "speed data as your architecture needs updating.\n");
 304         }
 305 #endif
 306 }
 307 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
 308
 309 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
 310 {
 311         tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
 312 }
 313 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
 314
 315 /**
 316  *      tty_get_baud_rate       -       get tty bit rates
 317  *      @tty: tty to query
 318  *
 319  *      Returns the baud rate as an integer for this terminal. The
 320  *      termios lock must be held by the caller and the terminal bit
 321  *      flags may be updated.
 322  *
 323  *      Locking: none
 324  */
 325
 326 speed_t tty_get_baud_rate(struct tty_struct *tty)
 327 {
 328         speed_t baud = tty_termios_baud_rate(tty->termios);
 329
 330         if (baud == 38400 && tty->alt_speed) {
 331                 if (!tty->warned) {
 332                         printk(KERN_WARNING "Use of setserial/setrocket to "
 333                                             "set SPD_* flags is deprecated\n");
 334                         tty->warned = 1;
 335                 }
 336                 baud = tty->alt_speed;
 337         }
 338
 339         return baud;
 340 }
 341
 342 EXPORT_SYMBOL(tty_get_baud_rate);
 343
 344 /**
 345  *      tty_termios_copy_hw     -       copy hardware settings
 346  *      @new: New termios
 347  *      @old: Old termios
 348  *
 349  *      Propogate the hardware specific terminal setting bits from
 350  *      the old termios structure to the new one. This is used in cases
 351  *      where the hardware does not support reconfiguration or as a helper
 352  *      in some cases where only minimal reconfiguration is supported
 353  */
 354
 355 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
 356 {
 357         /* The bits a dumb device handles in software. Smart devices need
 358            to always provide a set_termios method */
 359         new->c_cflag &= HUPCL | CREAD | CLOCAL;
 360         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
 361         new->c_ispeed = old->c_ispeed;
 362         new->c_ospeed = old->c_ospeed;
 363 }
 364
 365 EXPORT_SYMBOL(tty_termios_copy_hw);
 366
 367 /**
 368  *      change_termios          -       update termios values
 369  *      @tty: tty to update
 370  *      @new_termios: desired new value
 371  *
 372  *      Perform updates to the termios values set on this terminal. There
 373  *      is a bit of layering violation here with n_tty in terms of the
 374  *      internal knowledge of this function.
 375  *
 376  *      Locking: termios_sem
 377  */
 378
 379 static void change_termios(struct tty_struct * tty, struct ktermios * new_termios)
 380 {
 381         int canon_change;
 382         struct ktermios old_termios = *tty->termios;
 383         struct tty_ldisc *ld;
 384
 385         /*
 386          *      Perform the actual termios internal changes under lock.
 387          */
 388
 389
 390         /* FIXME: we need to decide on some locking/ordering semantics
 391            for the set_termios notification eventually */
 392         mutex_lock(&tty->termios_mutex);
 393
 394         *tty->termios = *new_termios;
 395         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
 396         canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
 397         if (canon_change) {
 398                 memset(&tty->read_flags, 0, sizeof tty->read_flags);
 399                 tty->canon_head = tty->read_tail;
 400                 tty->canon_data = 0;
 401                 tty->erasing = 0;
 402         }
 403
 404         /* This bit should be in the ldisc code */
 405         if (canon_change && !L_ICANON(tty) && tty->read_cnt)
 406                 /* Get characters left over from canonical mode. */
 407                 wake_up_interruptible(&tty->read_wait);
 408
 409         /* See if packet mode change of state. */
 410         if (tty->link && tty->link->packet) {
 411                 int old_flow = ((old_termios.c_iflag & IXON) &&
 412                                 (old_termios.c_cc[VSTOP] == '\023') &&
 413                                 (old_termios.c_cc[VSTART] == '\021'));
 414                 int new_flow = (I_IXON(tty) &&
 415                                 STOP_CHAR(tty) == '\023' &&
 416                                 START_CHAR(tty) == '\021');
 417                 if (old_flow != new_flow) {
 418                         tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
 419                         if (new_flow)
 420                                 tty->ctrl_status |= TIOCPKT_DOSTOP;
 421                         else
 422                                 tty->ctrl_status |= TIOCPKT_NOSTOP;
 423                         wake_up_interruptible(&tty->link->read_wait);
 424                 }
 425         }
 426
 427         if (tty->driver->set_termios)
 428                 (*tty->driver->set_termios)(tty, &old_termios);
 429         else
 430                 tty_termios_copy_hw(tty->termios, &old_termios);
 431
 432         ld = tty_ldisc_ref(tty);
 433         if (ld != NULL) {
 434                 if (ld->set_termios)
 435                         (ld->set_termios)(tty, &old_termios);
 436                 tty_ldisc_deref(ld);
 437         }
 438         mutex_unlock(&tty->termios_mutex);
 439 }
 440
 441 /**
 442  *      set_termios             -       set termios values for a tty
 443  *      @tty: terminal device
 444  *      @arg: user data
 445  *      @opt: option information
 446  *
 447  *      Helper function to prepare termios data and run necessary other
 448  *      functions before using change_termios to do the actual changes.
 449  *
 450  *      Locking:
 451  *              Called functions take ldisc and termios_sem locks
 452  */
 453
 454 static int set_termios(struct tty_struct * tty, void __user *arg, int opt)
 455 {
 456         struct ktermios tmp_termios;
 457         struct tty_ldisc *ld;
 458         int retval = tty_check_change(tty);
 459
 460         if (retval)
 461                 return retval;
 462
 463         memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
 464
 465         if (opt & TERMIOS_TERMIO) {
 466                 if (user_termio_to_kernel_termios(&tmp_termios,
 467                                                 (struct termio __user *)arg))
 468                         return -EFAULT;
 469 #ifdef TCGETS2
 470         } else if (opt & TERMIOS_OLD) {
 471                 if (user_termios_to_kernel_termios_1(&tmp_termios,
 472                                                 (struct termios __user *)arg))
 473                         return -EFAULT;
 474         } else {
 475                 if (user_termios_to_kernel_termios(&tmp_termios,
 476                                                 (struct termios2 __user *)arg))
 477                         return -EFAULT;
 478         }
 479 #else
 480         } else if (user_termios_to_kernel_termios(&tmp_termios,
 481                                         (struct termios __user *)arg))
 482                 return -EFAULT;
 483 #endif
 484
 485         /* If old style Bfoo values are used then load c_ispeed/c_ospeed with the real speed
 486            so its unconditionally usable */
 487         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
 488         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
 489
 490         ld = tty_ldisc_ref(tty);
 491
 492         if (ld != NULL) {
 493                 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
 494                         ld->flush_buffer(tty);
 495                 tty_ldisc_deref(ld);
 496         }
 497
 498         if (opt & TERMIOS_WAIT) {
 499                 tty_wait_until_sent(tty, 0);
 500                 if (signal_pending(current))
 501                         return -EINTR;
 502         }
 503
 504         change_termios(tty, &tmp_termios);
 505
 506         /* FIXME: Arguably if tmp_termios == tty->termios AND the
 507            actual requested termios was not tmp_termios then we may
 508            want to return an error as no user requested change has
 509            succeeded */
 510         return 0;
 511 }
 512
 513 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
 514 {
 515         if (kernel_termios_to_user_termio(termio, tty->termios))
 516                 return -EFAULT;
 517         return 0;
 518 }
 519
 520 static unsigned long inq_canon(struct tty_struct * tty)
 521 {
 522         int nr, head, tail;
 523
 524         if (!tty->canon_data || !tty->read_buf)
 525                 return 0;
 526         head = tty->canon_head;
 527         tail = tty->read_tail;
 528         nr = (head - tail) & (N_TTY_BUF_SIZE-1);
 529         /* Skip EOF-chars.. */
 530         while (head != tail) {
 531                 if (test_bit(tail, tty->read_flags) &&
 532                     tty->read_buf[tail] == __DISABLED_CHAR)
 533                         nr--;
 534                 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
 535         }
 536         return nr;
 537 }
 538
 539 #ifdef TIOCGETP
 540 /*
 541  * These are deprecated, but there is limited support..
 542  *
 543  * The "sg_flags" translation is a joke..
 544  */
 545 static int get_sgflags(struct tty_struct * tty)
 546 {
 547         int flags = 0;
 548
 549         if (!(tty->termios->c_lflag & ICANON)) {
 550                 if (tty->termios->c_lflag & ISIG)
 551                         flags |= 0x02;          /* cbreak */
 552                 else
 553                         flags |= 0x20;          /* raw */
 554         }
 555         if (tty->termios->c_lflag & ECHO)
 556                 flags |= 0x08;                  /* echo */
 557         if (tty->termios->c_oflag & OPOST)
 558                 if (tty->termios->c_oflag & ONLCR)
 559                         flags |= 0x10;          /* crmod */
 560         return flags;
 561 }
 562
 563 static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
 564 {
 565         struct sgttyb tmp;
 566
 567         mutex_lock(&tty->termios_mutex);
 568         tmp.sg_ispeed = tty->termios->c_ispeed;
 569         tmp.sg_ospeed = tty->termios->c_ospeed;
 570         tmp.sg_erase = tty->termios->c_cc[VERASE];
 571         tmp.sg_kill = tty->termios->c_cc[VKILL];
 572         tmp.sg_flags = get_sgflags(tty);
 573         mutex_unlock(&tty->termios_mutex);
 574
 575         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 576 }
 577
 578 static void set_sgflags(struct ktermios * termios, int flags)
 579 {
 580         termios->c_iflag = ICRNL | IXON;
 581         termios->c_oflag = 0;
 582         termios->c_lflag = ISIG | ICANON;
 583         if (flags & 0x02) {     /* cbreak */
 584                 termios->c_iflag = 0;
 585                 termios->c_lflag &= ~ICANON;
 586         }
 587         if (flags & 0x08) {             /* echo */
 588                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
 589                                     ECHOCTL | ECHOKE | IEXTEN;
 590         }
 591         if (flags & 0x10) {             /* crmod */
 592                 termios->c_oflag |= OPOST | ONLCR;
 593         }
 594         if (flags & 0x20) {     /* raw */
 595                 termios->c_iflag = 0;
 596                 termios->c_lflag &= ~(ISIG | ICANON);
 597         }
 598         if (!(termios->c_lflag & ICANON)) {
 599                 termios->c_cc[VMIN] = 1;
 600                 termios->c_cc[VTIME] = 0;
 601         }
 602 }
 603
 604 /**
 605  *      set_sgttyb              -       set legacy terminal values
 606  *      @tty: tty structure
 607  *      @sgttyb: pointer to old style terminal structure
 608  *
 609  *      Updates a terminal from the legacy BSD style terminal information
 610  *      structure.
 611  *
 612  *      Locking: termios_sem
 613  */
 614
 615 static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
 616 {
 617         int retval;
 618         struct sgttyb tmp;
 619         struct ktermios termios;
 620
 621         retval = tty_check_change(tty);
 622         if (retval)
 623                 return retval;
 624
 625         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
 626                 return -EFAULT;
 627
 628         mutex_lock(&tty->termios_mutex);
 629         termios = *tty->termios;
 630         termios.c_cc[VERASE] = tmp.sg_erase;
 631         termios.c_cc[VKILL] = tmp.sg_kill;
 632         set_sgflags(&termios, tmp.sg_flags);
 633         /* Try and encode into Bfoo format */
 634 #ifdef BOTHER
 635         tty_termios_encode_baud_rate(&termios, termios.c_ispeed, termios.c_ospeed);
 636 #endif
 637         mutex_unlock(&tty->termios_mutex);
 638         change_termios(tty, &termios);
 639         return 0;
 640 }
 641 #endif
 642
 643 #ifdef TIOCGETC
 644 static int get_tchars(struct tty_struct * tty, struct tchars __user * tchars)
 645 {
 646         struct tchars tmp;
 647
 648         tmp.t_intrc = tty->termios->c_cc[VINTR];
 649         tmp.t_quitc = tty->termios->c_cc[VQUIT];
 650         tmp.t_startc = tty->termios->c_cc[VSTART];
 651         tmp.t_stopc = tty->termios->c_cc[VSTOP];
 652         tmp.t_eofc = tty->termios->c_cc[VEOF];
 653         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
 654         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 655 }
 656
 657 static int set_tchars(struct tty_struct * tty, struct tchars __user * tchars)
 658 {
 659         struct tchars tmp;
 660
 661         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
 662                 return -EFAULT;
 663         tty->termios->c_cc[VINTR] = tmp.t_intrc;
 664         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
 665         tty->termios->c_cc[VSTART] = tmp.t_startc;
 666         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
 667         tty->termios->c_cc[VEOF] = tmp.t_eofc;
 668         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
 669         return 0;
 670 }
 671 #endif
 672
 673 #ifdef TIOCGLTC
 674 static int get_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
 675 {
 676         struct ltchars tmp;
 677
 678         tmp.t_suspc = tty->termios->c_cc[VSUSP];
 679         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];       /* what is dsuspc anyway? */
 680         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
 681         tmp.t_flushc = tty->termios->c_cc[VEOL2];       /* what is flushc anyway? */
 682         tmp.t_werasc = tty->termios->c_cc[VWERASE];
 683         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
 684         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 685 }
 686
 687 static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
 688 {
 689         struct ltchars tmp;
 690
 691         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
 692                 return -EFAULT;
 693
 694         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
 695         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;       /* what is dsuspc anyway? */
 696         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
 697         tty->termios->c_cc[VEOL2] = tmp.t_flushc;       /* what is flushc anyway? */
 698         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
 699         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
 700         return 0;
 701 }
 702 #endif
 703
 704 /**
 705  *      send_prio_char          -       send priority character
 706  *
 707  *      Send a high priority character to the tty even if stopped
 708  *
 709  *      Locking: none for xchar method, write ordering for write method.
 710  */
 711
 712 static int send_prio_char(struct tty_struct *tty, char ch)
 713 {
 714         int     was_stopped = tty->stopped;
 715
 716         if (tty->driver->send_xchar) {
 717                 tty->driver->send_xchar(tty, ch);
 718                 return 0;
 719         }
 720
 721         if (tty_write_lock(tty, 0) < 0)
 722                 return -ERESTARTSYS;
 723
 724         if (was_stopped)
 725                 start_tty(tty);
 726         tty->driver->write(tty, &ch, 1);
 727         if (was_stopped)
 728                 stop_tty(tty);
 729         tty_write_unlock(tty);
 730         return 0;
 731 }
 732
 733 /**
 734  *      tty_mode_ioctl          -       mode related ioctls
 735  *      @tty: tty for the ioctl
 736  *      @file: file pointer for the tty
 737  *      @cmd: command
 738  *      @arg: ioctl argument
 739  *
 740  *      Perform non line discipline specific mode control ioctls. This
 741  *      is designed to be called by line disciplines to ensure they provide
 742  *      consistent mode setting.
 743  */
 744
 745 int tty_mode_ioctl(struct tty_struct * tty, struct file *file,
 746                         unsigned int cmd, unsigned long arg)
 747 {
 748         struct tty_struct * real_tty;
 749         void __user *p = (void __user *)arg;
 750
 751         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 752             tty->driver->subtype == PTY_TYPE_MASTER)
 753                 real_tty = tty->link;
 754         else
 755                 real_tty = tty;
 756
 757         switch (cmd) {
 758 #ifdef TIOCGETP
 759                 case TIOCGETP:
 760                         return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
 761                 case TIOCSETP:
 762                 case TIOCSETN:
 763                         return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
 764 #endif
 765 #ifdef TIOCGETC
 766                 case TIOCGETC:
 767                         return get_tchars(real_tty, p);
 768                 case TIOCSETC:
 769                         return set_tchars(real_tty, p);
 770 #endif
 771 #ifdef TIOCGLTC
 772                 case TIOCGLTC:
 773                         return get_ltchars(real_tty, p);
 774                 case TIOCSLTC:
 775                         return set_ltchars(real_tty, p);
 776 #endif
 777                 case TCSETSF:
 778                         return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
 779                 case TCSETSW:
 780                         return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
 781                 case TCSETS:
 782                         return set_termios(real_tty, p, TERMIOS_OLD);
 783 #ifndef TCGETS2
 784                 case TCGETS:
 785                         if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
 786                                 return -EFAULT;
 787                         return 0;
 788 #else
 789                 case TCGETS:
 790                         if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
 791                                 return -EFAULT;
 792                         return 0;
 793                 case TCGETS2:
 794                         if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
 795                                 return -EFAULT;
 796                         return 0;
 797                 case TCSETSF2:
 798                         return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
 799                 case TCSETSW2:
 800                         return set_termios(real_tty, p, TERMIOS_WAIT);
 801                 case TCSETS2:
 802                         return set_termios(real_tty, p, 0);
 803 #endif
 804                 case TCGETA:
 805                         return get_termio(real_tty, p);
 806                 case TCSETAF:
 807                         return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
 808                 case TCSETAW:
 809                         return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
 810                 case TCSETA:
 811                         return set_termios(real_tty, p, TERMIOS_TERMIO);
 812 #ifndef TCGETS2
 813                 case TIOCGLCKTRMIOS:
 814                         if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
 815                                 return -EFAULT;
 816                         return 0;
 817
 818                 case TIOCSLCKTRMIOS:
 819                         if (!capable(CAP_SYS_ADMIN))
 820                                 return -EPERM;
 821                         if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios __user *) arg))
 822                                 return -EFAULT;
 823                         return 0;
 824 #else
 825                 case TIOCGLCKTRMIOS:
 826                         if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios_locked))
 827                                 return -EFAULT;
 828                         return 0;
 829
 830                 case TIOCSLCKTRMIOS:
 831                         if (!capable(CAP_SYS_ADMIN))
 832                                 return -EPERM;
 833                         if (user_termios_to_kernel_termios_1(real_tty->termios_locked, (struct termios __user *) arg))
 834                                 return -EFAULT;
 835                         return 0;
 836 #endif
 837                 case TIOCGSOFTCAR:
 838                         return put_user(C_CLOCAL(tty) ? 1 : 0, (int __user *)arg);
 839                 case TIOCSSOFTCAR:
 840                         if (get_user(arg, (unsigned int __user *) arg))
 841                                 return -EFAULT;
 842                         mutex_lock(&tty->termios_mutex);
 843                         tty->termios->c_cflag =
 844                                 ((tty->termios->c_cflag & ~CLOCAL) |
 845                                  (arg ? CLOCAL : 0));
 846                         mutex_unlock(&tty->termios_mutex);
 847                         return 0;
 848                 default:
 849                         return -ENOIOCTLCMD;
 850         }
 851 }
 852
 853 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
 854
 855 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
 856 {
 857         struct tty_ldisc *ld;
 858         int retval = tty_check_change(tty);
 859         if (retval)
 860                 return retval;
 861
 862         ld = tty_ldisc_ref(tty);
 863         switch (arg) {
 864         case TCIFLUSH:
 865                 if (ld && ld->flush_buffer)
 866                         ld->flush_buffer(tty);
 867                 break;
 868         case TCIOFLUSH:
 869                 if (ld && ld->flush_buffer)
 870                         ld->flush_buffer(tty);
 871                 /* fall through */
 872         case TCOFLUSH:
 873                 if (tty->driver->flush_buffer)
 874                         tty->driver->flush_buffer(tty);
 875                 break;
 876         default:
 877                 tty_ldisc_deref(ld);
 878                 return -EINVAL;
 879         }
 880         tty_ldisc_deref(ld);
 881         return 0;
 882 }
 883
 884 EXPORT_SYMBOL_GPL(tty_perform_flush);
 885
 886 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
 887                        unsigned int cmd, unsigned long arg)
 888 {
 889         struct tty_struct * real_tty;
 890         int retval;
 891
 892         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 893             tty->driver->subtype == PTY_TYPE_MASTER)
 894                 real_tty = tty->link;
 895         else
 896                 real_tty = tty;
 897
 898         switch (cmd) {
 899                 case TCXONC:
 900                         retval = tty_check_change(tty);
 901                         if (retval)
 902                                 return retval;
 903                         switch (arg) {
 904                         case TCOOFF:
 905                                 if (!tty->flow_stopped) {
 906                                         tty->flow_stopped = 1;
 907                                         stop_tty(tty);
 908                                 }
 909                                 break;
 910                         case TCOON:
 911                                 if (tty->flow_stopped) {
 912                                         tty->flow_stopped = 0;
 913                                         start_tty(tty);
 914                                 }
 915                                 break;
 916                         case TCIOFF:
 917                                 if (STOP_CHAR(tty) != __DISABLED_CHAR)
 918                                         return send_prio_char(tty, STOP_CHAR(tty));
 919                                 break;
 920                         case TCION:
 921                                 if (START_CHAR(tty) != __DISABLED_CHAR)
 922                                         return send_prio_char(tty, START_CHAR(tty));
 923                                 break;
 924                         default:
 925                                 return -EINVAL;
 926                         }
 927                         return 0;
 928                 case TCFLSH:
 929                         return tty_perform_flush(tty, arg);
 930                 case TIOCOUTQ:
 931                         return put_user(tty->driver->chars_in_buffer ?
 932                                         tty->driver->chars_in_buffer(tty) : 0,
 933                                         (int __user *) arg);
 934                 case TIOCINQ:
 935                         retval = tty->read_cnt;
 936                         if (L_ICANON(tty))
 937                                 retval = inq_canon(tty);
 938                         return put_user(retval, (unsigned int __user *) arg);
 939                 case TIOCPKT:
 940                 {
 941                         int pktmode;
 942
 943                         if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
 944                             tty->driver->subtype != PTY_TYPE_MASTER)
 945                                 return -ENOTTY;
 946                         if (get_user(pktmode, (int __user *) arg))
 947                                 return -EFAULT;
 948                         if (pktmode) {
 949                                 if (!tty->packet) {
 950                                         tty->packet = 1;
 951                                         tty->link->ctrl_status = 0;
 952                                 }
 953                         } else
 954                                 tty->packet = 0;
 955                         return 0;
 956                 }
 957                 default:
 958                         /* Try the mode commands */
 959                         return tty_mode_ioctl(tty, file, cmd, arg);
 960                 }
 961 }
 962
 963 EXPORT_SYMBOL(n_tty_ioctl);