drivers/tty/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_chars_in_buffer     -       characters pending
  44  *      @tty: terminal
  45  *
  46  *      Return the number of bytes of data in the device private
  47  *      output queue. If no private method is supplied there is assumed
  48  *      to be no queue on the device.
  49  */
  50
  51 int tty_chars_in_buffer(struct tty_struct *tty)
  52 {
  53         if (tty->ops->chars_in_buffer)
  54                 return tty->ops->chars_in_buffer(tty);
  55         else
  56                 return 0;
  57 }
  58 EXPORT_SYMBOL(tty_chars_in_buffer);
  59
  60 /**
  61  *      tty_write_room          -       write queue space
  62  *      @tty: terminal
  63  *
  64  *      Return the number of bytes that can be queued to this device
  65  *      at the present time. The result should be treated as a guarantee
  66  *      and the driver cannot offer a value it later shrinks by more than
  67  *      the number of bytes written. If no method is provided 2K is always
  68  *      returned and data may be lost as there will be no flow control.
  69  */
  70
  71 int tty_write_room(struct tty_struct *tty)
  72 {
  73         if (tty->ops->write_room)
  74                 return tty->ops->write_room(tty);
  75         return 2048;
  76 }
  77 EXPORT_SYMBOL(tty_write_room);
  78
  79 /**
  80  *      tty_driver_flush_buffer -       discard internal buffer
  81  *      @tty: terminal
  82  *
  83  *      Discard the internal output buffer for this device. If no method
  84  *      is provided then either the buffer cannot be hardware flushed or
  85  *      there is no buffer driver side.
  86  */
  87 void tty_driver_flush_buffer(struct tty_struct *tty)
  88 {
  89         if (tty->ops->flush_buffer)
  90                 tty->ops->flush_buffer(tty);
  91 }
  92 EXPORT_SYMBOL(tty_driver_flush_buffer);
  93
  94 /**
  95  *      tty_throttle            -       flow control
  96  *      @tty: terminal
  97  *
  98  *      Indicate that a tty should stop transmitting data down the stack.
  99  *      Takes the termios mutex to protect against parallel throttle/unthrottle
 100  *      and also to ensure the driver can consistently reference its own
 101  *      termios data at this point when implementing software flow control.
 102  */
 103
 104 void tty_throttle(struct tty_struct *tty)
 105 {
 106         mutex_lock(&tty->termios_mutex);
 107         /* check TTY_THROTTLED first so it indicates our state */
 108         if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
 109             tty->ops->throttle)
 110                 tty->ops->throttle(tty);
 111         mutex_unlock(&tty->termios_mutex);
 112 }
 113 EXPORT_SYMBOL(tty_throttle);
 114
 115 /**
 116  *      tty_unthrottle          -       flow control
 117  *      @tty: terminal
 118  *
 119  *      Indicate that a tty may continue transmitting data down the stack.
 120  *      Takes the termios mutex to protect against parallel throttle/unthrottle
 121  *      and also to ensure the driver can consistently reference its own
 122  *      termios data at this point when implementing software flow control.
 123  *
 124  *      Drivers should however remember that the stack can issue a throttle,
 125  *      then change flow control method, then unthrottle.
 126  */
 127
 128 void tty_unthrottle(struct tty_struct *tty)
 129 {
 130         mutex_lock(&tty->termios_mutex);
 131         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
 132             tty->ops->unthrottle)
 133                 tty->ops->unthrottle(tty);
 134         mutex_unlock(&tty->termios_mutex);
 135 }
 136 EXPORT_SYMBOL(tty_unthrottle);
 137
 138 /**
 139  *      tty_wait_until_sent     -       wait for I/O to finish
 140  *      @tty: tty we are waiting for
 141  *      @timeout: how long we will wait
 142  *
 143  *      Wait for characters pending in a tty driver to hit the wire, or
 144  *      for a timeout to occur (eg due to flow control)
 145  *
 146  *      Locking: none
 147  */
 148
 149 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
 150 {
 151 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
 152         char buf[64];
 153
 154         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
 155 #endif
 156         if (!timeout)
 157                 timeout = MAX_SCHEDULE_TIMEOUT;
 158         if (wait_event_interruptible_timeout(tty->write_wait,
 159                         !tty_chars_in_buffer(tty), timeout) >= 0) {
 160                 if (tty->ops->wait_until_sent)
 161                         tty->ops->wait_until_sent(tty, timeout);
 162         }
 163 }
 164 EXPORT_SYMBOL(tty_wait_until_sent);
 165
 166
 167 /*
 168  *              Termios Helper Methods
 169  */
 170
 171 static void unset_locked_termios(struct ktermios *termios,
 172                                  struct ktermios *old,
 173                                  struct ktermios *locked)
 174 {
 175         int     i;
 176
 177 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
 178
 179         if (!locked) {
 180                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
 181                 return;
 182         }
 183
 184         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
 185         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
 186         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
 187         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
 188         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
 189         for (i = 0; i < NCCS; i++)
 190                 termios->c_cc[i] = locked->c_cc[i] ?
 191                         old->c_cc[i] : termios->c_cc[i];
 192         /* FIXME: What should we do for i/ospeed */
 193 }
 194
 195 /*
 196  * Routine which returns the baud rate of the tty
 197  *
 198  * Note that the baud_table needs to be kept in sync with the
 199  * include/asm/termbits.h file.
 200  */
 201 static const speed_t baud_table[] = {
 202         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
 203         9600, 19200, 38400, 57600, 115200, 230400, 460800,
 204 #ifdef __sparc__
 205         76800, 153600, 307200, 614400, 921600
 206 #else
 207         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
 208         2500000, 3000000, 3500000, 4000000
 209 #endif
 210 };
 211
 212 #ifndef __sparc__
 213 static const tcflag_t baud_bits[] = {
 214         B0, B50, B75, B110, B134, B150, B200, B300, B600,
 215         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
 216         B57600, B115200, B230400, B460800, B500000, B576000,
 217         B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
 218         B3000000, B3500000, B4000000
 219 };
 220 #else
 221 static const tcflag_t baud_bits[] = {
 222         B0, B50, B75, B110, B134, B150, B200, B300, B600,
 223         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
 224         B57600, B115200, B230400, B460800, B76800, B153600,
 225         B307200, B614400, B921600
 226 };
 227 #endif
 228
 229 static int n_baud_table = ARRAY_SIZE(baud_table);
 230
 231 /**
 232  *      tty_termios_baud_rate
 233  *      @termios: termios structure
 234  *
 235  *      Convert termios baud rate data into a speed. This should be called
 236  *      with the termios lock held if this termios is a terminal termios
 237  *      structure. May change the termios data. Device drivers can call this
 238  *      function but should use ->c_[io]speed directly as they are updated.
 239  *
 240  *      Locking: none
 241  */
 242
 243 speed_t tty_termios_baud_rate(struct ktermios *termios)
 244 {
 245         unsigned int cbaud;
 246
 247         cbaud = termios->c_cflag & CBAUD;
 248
 249 #ifdef BOTHER
 250         /* Magic token for arbitary speed via c_ispeed/c_ospeed */
 251         if (cbaud == BOTHER)
 252                 return termios->c_ospeed;
 253 #endif
 254         if (cbaud & CBAUDEX) {
 255                 cbaud &= ~CBAUDEX;
 256
 257                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
 258                         termios->c_cflag &= ~CBAUDEX;
 259                 else
 260                         cbaud += 15;
 261         }
 262         return baud_table[cbaud];
 263 }
 264 EXPORT_SYMBOL(tty_termios_baud_rate);
 265
 266 /**
 267  *      tty_termios_input_baud_rate
 268  *      @termios: termios structure
 269  *
 270  *      Convert termios baud rate data into a speed. This should be called
 271  *      with the termios lock held if this termios is a terminal termios
 272  *      structure. May change the termios data. Device drivers can call this
 273  *      function but should use ->c_[io]speed directly as they are updated.
 274  *
 275  *      Locking: none
 276  */
 277
 278 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
 279 {
 280 #ifdef IBSHIFT
 281         unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
 282
 283         if (cbaud == B0)
 284                 return tty_termios_baud_rate(termios);
 285
 286         /* Magic token for arbitary speed via c_ispeed*/
 287         if (cbaud == BOTHER)
 288                 return termios->c_ispeed;
 289
 290         if (cbaud & CBAUDEX) {
 291                 cbaud &= ~CBAUDEX;
 292
 293                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
 294                         termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
 295                 else
 296                         cbaud += 15;
 297         }
 298         return baud_table[cbaud];
 299 #else
 300         return tty_termios_baud_rate(termios);
 301 #endif
 302 }
 303 EXPORT_SYMBOL(tty_termios_input_baud_rate);
 304
 305 /**
 306  *      tty_termios_encode_baud_rate
 307  *      @termios: ktermios structure holding user requested state
 308  *      @ispeed: input speed
 309  *      @ospeed: output speed
 310  *
 311  *      Encode the speeds set into the passed termios structure. This is
 312  *      used as a library helper for drivers os that they can report back
 313  *      the actual speed selected when it differs from the speed requested
 314  *
 315  *      For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
 316  *      we need to carefully set the bits when the user does not get the
 317  *      desired speed. We allow small margins and preserve as much of possible
 318  *      of the input intent to keep compatibility.
 319  *
 320  *      Locking: Caller should hold termios lock. This is already held
 321  *      when calling this function from the driver termios handler.
 322  *
 323  *      The ifdefs deal with platforms whose owners have yet to update them
 324  *      and will all go away once this is done.
 325  */
 326
 327 void tty_termios_encode_baud_rate(struct ktermios *termios,
 328                                   speed_t ibaud, speed_t obaud)
 329 {
 330         int i = 0;
 331         int ifound = -1, ofound = -1;
 332         int iclose = ibaud/50, oclose = obaud/50;
 333         int ibinput = 0;
 334
 335         if (obaud == 0)                 /* CD dropped             */
 336                 ibaud = 0;              /* Clear ibaud to be sure */
 337
 338         termios->c_ispeed = ibaud;
 339         termios->c_ospeed = obaud;
 340
 341 #ifdef BOTHER
 342         /* If the user asked for a precise weird speed give a precise weird
 343            answer. If they asked for a Bfoo speed they many have problems
 344            digesting non-exact replies so fuzz a bit */
 345
 346         if ((termios->c_cflag & CBAUD) == BOTHER)
 347                 oclose = 0;
 348         if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
 349                 iclose = 0;
 350         if ((termios->c_cflag >> IBSHIFT) & CBAUD)
 351                 ibinput = 1;    /* An input speed was specified */
 352 #endif
 353         termios->c_cflag &= ~CBAUD;
 354
 355         /*
 356          *      Our goal is to find a close match to the standard baud rate
 357          *      returned. Walk the baud rate table and if we get a very close
 358          *      match then report back the speed as a POSIX Bxxxx value by
 359          *      preference
 360          */
 361
 362         do {
 363                 if (obaud - oclose <= baud_table[i] &&
 364                     obaud + oclose >= baud_table[i]) {
 365                         termios->c_cflag |= baud_bits[i];
 366                         ofound = i;
 367                 }
 368                 if (ibaud - iclose <= baud_table[i] &&
 369                     ibaud + iclose >= baud_table[i]) {
 370                         /* For the case input == output don't set IBAUD bits
 371                            if the user didn't do so */
 372                         if (ofound == i && !ibinput)
 373                                 ifound  = i;
 374 #ifdef IBSHIFT
 375                         else {
 376                                 ifound = i;
 377                                 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
 378                         }
 379 #endif
 380                 }
 381         } while (++i < n_baud_table);
 382
 383         /*
 384          *      If we found no match then use BOTHER if provided or warn
 385          *      the user their platform maintainer needs to wake up if not.
 386          */
 387 #ifdef BOTHER
 388         if (ofound == -1)
 389                 termios->c_cflag |= BOTHER;
 390         /* Set exact input bits only if the input and output differ or the
 391            user already did */
 392         if (ifound == -1 && (ibaud != obaud || ibinput))
 393                 termios->c_cflag |= (BOTHER << IBSHIFT);
 394 #else
 395         if (ifound == -1 || ofound == -1) {
 396                 printk_once(KERN_WARNING "tty: Unable to return correct "
 397                           "speed data as your architecture needs updating.\n");
 398         }
 399 #endif
 400 }
 401 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
 402
 403 /**
 404  *      tty_encode_baud_rate            -       set baud rate of the tty
 405  *      @ibaud: input baud rate
 406  *      @obad: output baud rate
 407  *
 408  *      Update the current termios data for the tty with the new speed
 409  *      settings. The caller must hold the termios_mutex for the tty in
 410  *      question.
 411  */
 412
 413 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
 414 {
 415         tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
 416 }
 417 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
 418
 419 /**
 420  *      tty_get_baud_rate       -       get tty bit rates
 421  *      @tty: tty to query
 422  *
 423  *      Returns the baud rate as an integer for this terminal. The
 424  *      termios lock must be held by the caller and the terminal bit
 425  *      flags may be updated.
 426  *
 427  *      Locking: none
 428  */
 429
 430 speed_t tty_get_baud_rate(struct tty_struct *tty)
 431 {
 432         speed_t baud = tty_termios_baud_rate(tty->termios);
 433
 434         if (baud == 38400 && tty->alt_speed) {
 435                 if (!tty->warned) {
 436                         printk(KERN_WARNING "Use of setserial/setrocket to "
 437                                             "set SPD_* flags is deprecated\n");
 438                         tty->warned = 1;
 439                 }
 440                 baud = tty->alt_speed;
 441         }
 442
 443         return baud;
 444 }
 445 EXPORT_SYMBOL(tty_get_baud_rate);
 446
 447 /**
 448  *      tty_termios_copy_hw     -       copy hardware settings
 449  *      @new: New termios
 450  *      @old: Old termios
 451  *
 452  *      Propogate the hardware specific terminal setting bits from
 453  *      the old termios structure to the new one. This is used in cases
 454  *      where the hardware does not support reconfiguration or as a helper
 455  *      in some cases where only minimal reconfiguration is supported
 456  */
 457
 458 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
 459 {
 460         /* The bits a dumb device handles in software. Smart devices need
 461            to always provide a set_termios method */
 462         new->c_cflag &= HUPCL | CREAD | CLOCAL;
 463         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
 464         new->c_ispeed = old->c_ispeed;
 465         new->c_ospeed = old->c_ospeed;
 466 }
 467 EXPORT_SYMBOL(tty_termios_copy_hw);
 468
 469 /**
 470  *      tty_termios_hw_change   -       check for setting change
 471  *      @a: termios
 472  *      @b: termios to compare
 473  *
 474  *      Check if any of the bits that affect a dumb device have changed
 475  *      between the two termios structures, or a speed change is needed.
 476  */
 477
 478 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
 479 {
 480         if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
 481                 return 1;
 482         if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
 483                 return 1;
 484         return 0;
 485 }
 486 EXPORT_SYMBOL(tty_termios_hw_change);
 487
 488 /**
 489  *      change_termios          -       update termios values
 490  *      @tty: tty to update
 491  *      @new_termios: desired new value
 492  *
 493  *      Perform updates to the termios values set on this terminal. There
 494  *      is a bit of layering violation here with n_tty in terms of the
 495  *      internal knowledge of this function.
 496  *
 497  *      Locking: termios_mutex
 498  */
 499
 500 static void change_termios(struct tty_struct *tty, struct ktermios *new_termios)
 501 {
 502         struct ktermios old_termios;
 503         struct tty_ldisc *ld;
 504         unsigned long flags;
 505
 506         /*
 507          *      Perform the actual termios internal changes under lock.
 508          */
 509
 510
 511         /* FIXME: we need to decide on some locking/ordering semantics
 512            for the set_termios notification eventually */
 513         mutex_lock(&tty->termios_mutex);
 514         old_termios = *tty->termios;
 515         *tty->termios = *new_termios;
 516         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
 517
 518         /* See if packet mode change of state. */
 519         if (tty->link && tty->link->packet) {
 520                 int extproc = (old_termios.c_lflag & EXTPROC) |
 521                                 (tty->termios->c_lflag & EXTPROC);
 522                 int old_flow = ((old_termios.c_iflag & IXON) &&
 523                                 (old_termios.c_cc[VSTOP] == '\023') &&
 524                                 (old_termios.c_cc[VSTART] == '\021'));
 525                 int new_flow = (I_IXON(tty) &&
 526                                 STOP_CHAR(tty) == '\023' &&
 527                                 START_CHAR(tty) == '\021');
 528                 if ((old_flow != new_flow) || extproc) {
 529                         spin_lock_irqsave(&tty->ctrl_lock, flags);
 530                         if (old_flow != new_flow) {
 531                                 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
 532                                 if (new_flow)
 533                                         tty->ctrl_status |= TIOCPKT_DOSTOP;
 534                                 else
 535                                         tty->ctrl_status |= TIOCPKT_NOSTOP;
 536                         }
 537                         if (extproc)
 538                                 tty->ctrl_status |= TIOCPKT_IOCTL;
 539                         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 540                         wake_up_interruptible(&tty->link->read_wait);
 541                 }
 542         }
 543
 544         if (tty->ops->set_termios)
 545                 (*tty->ops->set_termios)(tty, &old_termios);
 546         else
 547                 tty_termios_copy_hw(tty->termios, &old_termios);
 548
 549         ld = tty_ldisc_ref(tty);
 550         if (ld != NULL) {
 551                 if (ld->ops->set_termios)
 552                         (ld->ops->set_termios)(tty, &old_termios);
 553                 tty_ldisc_deref(ld);
 554         }
 555         mutex_unlock(&tty->termios_mutex);
 556 }
 557
 558 /**
 559  *      set_termios             -       set termios values for a tty
 560  *      @tty: terminal device
 561  *      @arg: user data
 562  *      @opt: option information
 563  *
 564  *      Helper function to prepare termios data and run necessary other
 565  *      functions before using change_termios to do the actual changes.
 566  *
 567  *      Locking:
 568  *              Called functions take ldisc and termios_mutex locks
 569  */
 570
 571 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
 572 {
 573         struct ktermios tmp_termios;
 574         struct tty_ldisc *ld;
 575         int retval = tty_check_change(tty);
 576
 577         if (retval)
 578                 return retval;
 579
 580         mutex_lock(&tty->termios_mutex);
 581         memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
 582         mutex_unlock(&tty->termios_mutex);
 583
 584         if (opt & TERMIOS_TERMIO) {
 585                 if (user_termio_to_kernel_termios(&tmp_termios,
 586                                                 (struct termio __user *)arg))
 587                         return -EFAULT;
 588 #ifdef TCGETS2
 589         } else if (opt & TERMIOS_OLD) {
 590                 if (user_termios_to_kernel_termios_1(&tmp_termios,
 591                                                 (struct termios __user *)arg))
 592                         return -EFAULT;
 593         } else {
 594                 if (user_termios_to_kernel_termios(&tmp_termios,
 595                                                 (struct termios2 __user *)arg))
 596                         return -EFAULT;
 597         }
 598 #else
 599         } else if (user_termios_to_kernel_termios(&tmp_termios,
 600                                         (struct termios __user *)arg))
 601                 return -EFAULT;
 602 #endif
 603
 604         /* If old style Bfoo values are used then load c_ispeed/c_ospeed
 605          * with the real speed so its unconditionally usable */
 606         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
 607         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
 608
 609         ld = tty_ldisc_ref(tty);
 610
 611         if (ld != NULL) {
 612                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 613                         ld->ops->flush_buffer(tty);
 614                 tty_ldisc_deref(ld);
 615         }
 616
 617         if (opt & TERMIOS_WAIT) {
 618                 tty_wait_until_sent(tty, 0);
 619                 if (signal_pending(current))
 620                         return -EINTR;
 621         }
 622
 623         change_termios(tty, &tmp_termios);
 624
 625         /* FIXME: Arguably if tmp_termios == tty->termios AND the
 626            actual requested termios was not tmp_termios then we may
 627            want to return an error as no user requested change has
 628            succeeded */
 629         return 0;
 630 }
 631
 632 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
 633 {
 634         mutex_lock(&tty->termios_mutex);
 635         memcpy(kterm, tty->termios, sizeof(struct ktermios));
 636         mutex_unlock(&tty->termios_mutex);
 637 }
 638
 639 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
 640 {
 641         mutex_lock(&tty->termios_mutex);
 642         memcpy(kterm, tty->termios_locked, sizeof(struct ktermios));
 643         mutex_unlock(&tty->termios_mutex);
 644 }
 645
 646 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
 647 {
 648         struct ktermios kterm;
 649         copy_termios(tty, &kterm);
 650         if (kernel_termios_to_user_termio(termio, &kterm))
 651                 return -EFAULT;
 652         return 0;
 653 }
 654
 655
 656 #ifdef TCGETX
 657
 658 /**
 659  *      set_termiox     -       set termiox fields if possible
 660  *      @tty: terminal
 661  *      @arg: termiox structure from user
 662  *      @opt: option flags for ioctl type
 663  *
 664  *      Implement the device calling points for the SYS5 termiox ioctl
 665  *      interface in Linux
 666  */
 667
 668 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
 669 {
 670         struct termiox tnew;
 671         struct tty_ldisc *ld;
 672
 673         if (tty->termiox == NULL)
 674                 return -EINVAL;
 675         if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
 676                 return -EFAULT;
 677
 678         ld = tty_ldisc_ref(tty);
 679         if (ld != NULL) {
 680                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 681                         ld->ops->flush_buffer(tty);
 682                 tty_ldisc_deref(ld);
 683         }
 684         if (opt & TERMIOS_WAIT) {
 685                 tty_wait_until_sent(tty, 0);
 686                 if (signal_pending(current))
 687                         return -EINTR;
 688         }
 689
 690         mutex_lock(&tty->termios_mutex);
 691         if (tty->ops->set_termiox)
 692                 tty->ops->set_termiox(tty, &tnew);
 693         mutex_unlock(&tty->termios_mutex);
 694         return 0;
 695 }
 696
 697 #endif
 698
 699
 700 #ifdef TIOCGETP
 701 /*
 702  * These are deprecated, but there is limited support..
 703  *
 704  * The "sg_flags" translation is a joke..
 705  */
 706 static int get_sgflags(struct tty_struct *tty)
 707 {
 708         int flags = 0;
 709
 710         if (!(tty->termios->c_lflag & ICANON)) {
 711                 if (tty->termios->c_lflag & ISIG)
 712                         flags |= 0x02;          /* cbreak */
 713                 else
 714                         flags |= 0x20;          /* raw */
 715         }
 716         if (tty->termios->c_lflag & ECHO)
 717                 flags |= 0x08;                  /* echo */
 718         if (tty->termios->c_oflag & OPOST)
 719                 if (tty->termios->c_oflag & ONLCR)
 720                         flags |= 0x10;          /* crmod */
 721         return flags;
 722 }
 723
 724 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 725 {
 726         struct sgttyb tmp;
 727
 728         mutex_lock(&tty->termios_mutex);
 729         tmp.sg_ispeed = tty->termios->c_ispeed;
 730         tmp.sg_ospeed = tty->termios->c_ospeed;
 731         tmp.sg_erase = tty->termios->c_cc[VERASE];
 732         tmp.sg_kill = tty->termios->c_cc[VKILL];
 733         tmp.sg_flags = get_sgflags(tty);
 734         mutex_unlock(&tty->termios_mutex);
 735
 736         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 737 }
 738
 739 static void set_sgflags(struct ktermios *termios, int flags)
 740 {
 741         termios->c_iflag = ICRNL | IXON;
 742         termios->c_oflag = 0;
 743         termios->c_lflag = ISIG | ICANON;
 744         if (flags & 0x02) {     /* cbreak */
 745                 termios->c_iflag = 0;
 746                 termios->c_lflag &= ~ICANON;
 747         }
 748         if (flags & 0x08) {             /* echo */
 749                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
 750                                     ECHOCTL | ECHOKE | IEXTEN;
 751         }
 752         if (flags & 0x10) {             /* crmod */
 753                 termios->c_oflag |= OPOST | ONLCR;
 754         }
 755         if (flags & 0x20) {     /* raw */
 756                 termios->c_iflag = 0;
 757                 termios->c_lflag &= ~(ISIG | ICANON);
 758         }
 759         if (!(termios->c_lflag & ICANON)) {
 760                 termios->c_cc[VMIN] = 1;
 761                 termios->c_cc[VTIME] = 0;
 762         }
 763 }
 764
 765 /**
 766  *      set_sgttyb              -       set legacy terminal values
 767  *      @tty: tty structure
 768  *      @sgttyb: pointer to old style terminal structure
 769  *
 770  *      Updates a terminal from the legacy BSD style terminal information
 771  *      structure.
 772  *
 773  *      Locking: termios_mutex
 774  */
 775
 776 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 777 {
 778         int retval;
 779         struct sgttyb tmp;
 780         struct ktermios termios;
 781
 782         retval = tty_check_change(tty);
 783         if (retval)
 784                 return retval;
 785
 786         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
 787                 return -EFAULT;
 788
 789         mutex_lock(&tty->termios_mutex);
 790         termios = *tty->termios;
 791         termios.c_cc[VERASE] = tmp.sg_erase;
 792         termios.c_cc[VKILL] = tmp.sg_kill;
 793         set_sgflags(&termios, tmp.sg_flags);
 794         /* Try and encode into Bfoo format */
 795 #ifdef BOTHER
 796         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
 797                                                 termios.c_ospeed);
 798 #endif
 799         mutex_unlock(&tty->termios_mutex);
 800         change_termios(tty, &termios);
 801         return 0;
 802 }
 803 #endif
 804
 805 #ifdef TIOCGETC
 806 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 807 {
 808         struct tchars tmp;
 809
 810         mutex_lock(&tty->termios_mutex);
 811         tmp.t_intrc = tty->termios->c_cc[VINTR];
 812         tmp.t_quitc = tty->termios->c_cc[VQUIT];
 813         tmp.t_startc = tty->termios->c_cc[VSTART];
 814         tmp.t_stopc = tty->termios->c_cc[VSTOP];
 815         tmp.t_eofc = tty->termios->c_cc[VEOF];
 816         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
 817         mutex_unlock(&tty->termios_mutex);
 818         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 819 }
 820
 821 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 822 {
 823         struct tchars tmp;
 824
 825         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
 826                 return -EFAULT;
 827         mutex_lock(&tty->termios_mutex);
 828         tty->termios->c_cc[VINTR] = tmp.t_intrc;
 829         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
 830         tty->termios->c_cc[VSTART] = tmp.t_startc;
 831         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
 832         tty->termios->c_cc[VEOF] = tmp.t_eofc;
 833         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
 834         mutex_unlock(&tty->termios_mutex);
 835         return 0;
 836 }
 837 #endif
 838
 839 #ifdef TIOCGLTC
 840 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 841 {
 842         struct ltchars tmp;
 843
 844         mutex_lock(&tty->termios_mutex);
 845         tmp.t_suspc = tty->termios->c_cc[VSUSP];
 846         /* what is dsuspc anyway? */
 847         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];
 848         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
 849         /* what is flushc anyway? */
 850         tmp.t_flushc = tty->termios->c_cc[VEOL2];
 851         tmp.t_werasc = tty->termios->c_cc[VWERASE];
 852         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
 853         mutex_unlock(&tty->termios_mutex);
 854         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 855 }
 856
 857 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 858 {
 859         struct ltchars tmp;
 860
 861         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
 862                 return -EFAULT;
 863
 864         mutex_lock(&tty->termios_mutex);
 865         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
 866         /* what is dsuspc anyway? */
 867         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;
 868         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
 869         /* what is flushc anyway? */
 870         tty->termios->c_cc[VEOL2] = tmp.t_flushc;
 871         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
 872         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
 873         mutex_unlock(&tty->termios_mutex);
 874         return 0;
 875 }
 876 #endif
 877
 878 /**
 879  *      send_prio_char          -       send priority character
 880  *
 881  *      Send a high priority character to the tty even if stopped
 882  *
 883  *      Locking: none for xchar method, write ordering for write method.
 884  */
 885
 886 static int send_prio_char(struct tty_struct *tty, char ch)
 887 {
 888         int     was_stopped = tty->stopped;
 889
 890         if (tty->ops->send_xchar) {
 891                 tty->ops->send_xchar(tty, ch);
 892                 return 0;
 893         }
 894
 895         if (tty_write_lock(tty, 0) < 0)
 896                 return -ERESTARTSYS;
 897
 898         if (was_stopped)
 899                 start_tty(tty);
 900         tty->ops->write(tty, &ch, 1);
 901         if (was_stopped)
 902                 stop_tty(tty);
 903         tty_write_unlock(tty);
 904         return 0;
 905 }
 906
 907 /**
 908  *      tty_change_softcar      -       carrier change ioctl helper
 909  *      @tty: tty to update
 910  *      @arg: enable/disable CLOCAL
 911  *
 912  *      Perform a change to the CLOCAL state and call into the driver
 913  *      layer to make it visible. All done with the termios mutex
 914  */
 915
 916 static int tty_change_softcar(struct tty_struct *tty, int arg)
 917 {
 918         int ret = 0;
 919         int bit = arg ? CLOCAL : 0;
 920         struct ktermios old;
 921
 922         mutex_lock(&tty->termios_mutex);
 923         old = *tty->termios;
 924         tty->termios->c_cflag &= ~CLOCAL;
 925         tty->termios->c_cflag |= bit;
 926         if (tty->ops->set_termios)
 927                 tty->ops->set_termios(tty, &old);
 928         if ((tty->termios->c_cflag & CLOCAL) != bit)
 929                 ret = -EINVAL;
 930         mutex_unlock(&tty->termios_mutex);
 931         return ret;
 932 }
 933
 934 /**
 935  *      tty_mode_ioctl          -       mode related ioctls
 936  *      @tty: tty for the ioctl
 937  *      @file: file pointer for the tty
 938  *      @cmd: command
 939  *      @arg: ioctl argument
 940  *
 941  *      Perform non line discipline specific mode control ioctls. This
 942  *      is designed to be called by line disciplines to ensure they provide
 943  *      consistent mode setting.
 944  */
 945
 946 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
 947                         unsigned int cmd, unsigned long arg)
 948 {
 949         struct tty_struct *real_tty;
 950         void __user *p = (void __user *)arg;
 951         int ret = 0;
 952         struct ktermios kterm;
 953
 954         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 955             tty->driver->subtype == PTY_TYPE_MASTER)
 956                 real_tty = tty->link;
 957         else
 958                 real_tty = tty;
 959
 960         switch (cmd) {
 961 #ifdef TIOCGETP
 962         case TIOCGETP:
 963                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
 964         case TIOCSETP:
 965         case TIOCSETN:
 966                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
 967 #endif
 968 #ifdef TIOCGETC
 969         case TIOCGETC:
 970                 return get_tchars(real_tty, p);
 971         case TIOCSETC:
 972                 return set_tchars(real_tty, p);
 973 #endif
 974 #ifdef TIOCGLTC
 975         case TIOCGLTC:
 976                 return get_ltchars(real_tty, p);
 977         case TIOCSLTC:
 978                 return set_ltchars(real_tty, p);
 979 #endif
 980         case TCSETSF:
 981                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
 982         case TCSETSW:
 983                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
 984         case TCSETS:
 985                 return set_termios(real_tty, p, TERMIOS_OLD);
 986 #ifndef TCGETS2
 987         case TCGETS:
 988                 copy_termios(real_tty, &kterm);
 989                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
 990                         ret = -EFAULT;
 991                 return ret;
 992 #else
 993         case TCGETS:
 994                 copy_termios(real_tty, &kterm);
 995                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
 996                         ret = -EFAULT;
 997                 return ret;
 998         case TCGETS2:
 999                 copy_termios(real_tty, &kterm);
1000                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
1001                         ret = -EFAULT;
1002                 return ret;
1003         case TCSETSF2:
1004                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
1005         case TCSETSW2:
1006                 return set_termios(real_tty, p, TERMIOS_WAIT);
1007         case TCSETS2:
1008                 return set_termios(real_tty, p, 0);
1009 #endif
1010         case TCGETA:
1011                 return get_termio(real_tty, p);
1012         case TCSETAF:
1013                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1014         case TCSETAW:
1015                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1016         case TCSETA:
1017                 return set_termios(real_tty, p, TERMIOS_TERMIO);
1018 #ifndef TCGETS2
1019         case TIOCGLCKTRMIOS:
1020                 copy_termios_locked(real_tty, &kterm);
1021                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1022                         ret = -EFAULT;
1023                 return ret;
1024         case TIOCSLCKTRMIOS:
1025                 if (!capable(CAP_SYS_ADMIN))
1026                         return -EPERM;
1027                 copy_termios_locked(real_tty, &kterm);
1028                 if (user_termios_to_kernel_termios(&kterm,
1029                                                (struct termios __user *) arg))
1030                         return -EFAULT;
1031                 mutex_lock(&real_tty->termios_mutex);
1032                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1033                 mutex_unlock(&real_tty->termios_mutex);
1034                 return 0;
1035 #else
1036         case TIOCGLCKTRMIOS:
1037                 copy_termios_locked(real_tty, &kterm);
1038                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1039                         ret = -EFAULT;
1040                 return ret;
1041         case TIOCSLCKTRMIOS:
1042                 if (!capable(CAP_SYS_ADMIN))
1043                         return -EPERM;
1044                 copy_termios_locked(real_tty, &kterm);
1045                 if (user_termios_to_kernel_termios_1(&kterm,
1046                                                (struct termios __user *) arg))
1047                         return -EFAULT;
1048                 mutex_lock(&real_tty->termios_mutex);
1049                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1050                 mutex_unlock(&real_tty->termios_mutex);
1051                 return ret;
1052 #endif
1053 #ifdef TCGETX
1054         case TCGETX: {
1055                 struct termiox ktermx;
1056                 if (real_tty->termiox == NULL)
1057                         return -EINVAL;
1058                 mutex_lock(&real_tty->termios_mutex);
1059                 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1060                 mutex_unlock(&real_tty->termios_mutex);
1061                 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1062                         ret = -EFAULT;
1063                 return ret;
1064         }
1065         case TCSETX:
1066                 return set_termiox(real_tty, p, 0);
1067         case TCSETXW:
1068                 return set_termiox(real_tty, p, TERMIOS_WAIT);
1069         case TCSETXF:
1070                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1071 #endif
1072         case TIOCGSOFTCAR:
1073                 copy_termios(real_tty, &kterm);
1074                 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1075                                                 (int __user *)arg);
1076                 return ret;
1077         case TIOCSSOFTCAR:
1078                 if (get_user(arg, (unsigned int __user *) arg))
1079                         return -EFAULT;
1080                 return tty_change_softcar(real_tty, arg);
1081         default:
1082                 return -ENOIOCTLCMD;
1083         }
1084 }
1085 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1086
1087 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1088 {
1089         struct tty_ldisc *ld;
1090         int retval = tty_check_change(tty);
1091         if (retval)
1092                 return retval;
1093
1094         ld = tty_ldisc_ref_wait(tty);
1095         switch (arg) {
1096         case TCIFLUSH:
1097                 if (ld && ld->ops->flush_buffer)
1098                         ld->ops->flush_buffer(tty);
1099                 break;
1100         case TCIOFLUSH:
1101                 if (ld && ld->ops->flush_buffer)
1102                         ld->ops->flush_buffer(tty);
1103                 /* fall through */
1104         case TCOFLUSH:
1105                 tty_driver_flush_buffer(tty);
1106                 break;
1107         default:
1108                 tty_ldisc_deref(ld);
1109                 return -EINVAL;
1110         }
1111         tty_ldisc_deref(ld);
1112         return 0;
1113 }
1114 EXPORT_SYMBOL_GPL(tty_perform_flush);
1115
1116 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1117                        unsigned int cmd, unsigned long arg)
1118 {
1119         unsigned long flags;
1120         int retval;
1121
1122         switch (cmd) {
1123         case TCXONC:
1124                 retval = tty_check_change(tty);
1125                 if (retval)
1126                         return retval;
1127                 switch (arg) {
1128                 case TCOOFF:
1129                         if (!tty->flow_stopped) {
1130                                 tty->flow_stopped = 1;
1131                                 stop_tty(tty);
1132                         }
1133                         break;
1134                 case TCOON:
1135                         if (tty->flow_stopped) {
1136                                 tty->flow_stopped = 0;
1137                                 start_tty(tty);
1138                         }
1139                         break;
1140                 case TCIOFF:
1141                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
1142                                 return send_prio_char(tty, STOP_CHAR(tty));
1143                         break;
1144                 case TCION:
1145                         if (START_CHAR(tty) != __DISABLED_CHAR)
1146                                 return send_prio_char(tty, START_CHAR(tty));
1147                         break;
1148                 default:
1149                         return -EINVAL;
1150                 }
1151                 return 0;
1152         case TCFLSH:
1153                 return tty_perform_flush(tty, arg);
1154         case TIOCPKT:
1155         {
1156                 int pktmode;
1157
1158                 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
1159                     tty->driver->subtype != PTY_TYPE_MASTER)
1160                         return -ENOTTY;
1161                 if (get_user(pktmode, (int __user *) arg))
1162                         return -EFAULT;
1163                 spin_lock_irqsave(&tty->ctrl_lock, flags);
1164                 if (pktmode) {
1165                         if (!tty->packet) {
1166                                 tty->packet = 1;
1167                                 tty->link->ctrl_status = 0;
1168                         }
1169                 } else
1170                         tty->packet = 0;
1171                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1172                 return 0;
1173         }
1174         default:
1175                 /* Try the mode commands */
1176                 return tty_mode_ioctl(tty, file, cmd, arg);
1177         }
1178 }
1179 EXPORT_SYMBOL(n_tty_ioctl_helper);