drivers/tty/tty_ioctl.c

   1 /*
   2  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
   3  *
   4  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
   5  * which can be dynamically activated and de-activated by the line
   6  * discipline handling modules (like SLIP).
   7  */
   8
   9 #include <linux/types.h>
  10 #include <linux/termios.h>
  11 #include <linux/errno.h>
  12 #include <linux/sched.h>
  13 #include <linux/kernel.h>
  14 #include <linux/major.h>
  15 #include <linux/tty.h>
  16 #include <linux/fcntl.h>
  17 #include <linux/string.h>
  18 #include <linux/mm.h>
  19 #include <linux/module.h>
  20 #include <linux/bitops.h>
  21 #include <linux/mutex.h>
  22 #include <linux/compat.h>
  23
  24 #include <asm/io.h>
  25 #include <asm/uaccess.h>
  26
  27 #undef TTY_DEBUG_WAIT_UNTIL_SENT
  28
  29 #undef  DEBUG
  30
  31 /*
  32  * Internal flag options for termios setting behavior
  33  */
  34 #define TERMIOS_FLUSH   1
  35 #define TERMIOS_WAIT    2
  36 #define TERMIOS_TERMIO  4
  37 #define TERMIOS_OLD     8
  38
  39
  40 /**
  41  *      tty_chars_in_buffer     -       characters pending
  42  *      @tty: terminal
  43  *
  44  *      Return the number of bytes of data in the device private
  45  *      output queue. If no private method is supplied there is assumed
  46  *      to be no queue on the device.
  47  */
  48
  49 int tty_chars_in_buffer(struct tty_struct *tty)
  50 {
  51         if (tty->ops->chars_in_buffer)
  52                 return tty->ops->chars_in_buffer(tty);
  53         else
  54                 return 0;
  55 }
  56 EXPORT_SYMBOL(tty_chars_in_buffer);
  57
  58 /**
  59  *      tty_write_room          -       write queue space
  60  *      @tty: terminal
  61  *
  62  *      Return the number of bytes that can be queued to this device
  63  *      at the present time. The result should be treated as a guarantee
  64  *      and the driver cannot offer a value it later shrinks by more than
  65  *      the number of bytes written. If no method is provided 2K is always
  66  *      returned and data may be lost as there will be no flow control.
  67  */
  68
  69 int tty_write_room(struct tty_struct *tty)
  70 {
  71         if (tty->ops->write_room)
  72                 return tty->ops->write_room(tty);
  73         return 2048;
  74 }
  75 EXPORT_SYMBOL(tty_write_room);
  76
  77 /**
  78  *      tty_driver_flush_buffer -       discard internal buffer
  79  *      @tty: terminal
  80  *
  81  *      Discard the internal output buffer for this device. If no method
  82  *      is provided then either the buffer cannot be hardware flushed or
  83  *      there is no buffer driver side.
  84  */
  85 void tty_driver_flush_buffer(struct tty_struct *tty)
  86 {
  87         if (tty->ops->flush_buffer)
  88                 tty->ops->flush_buffer(tty);
  89 }
  90 EXPORT_SYMBOL(tty_driver_flush_buffer);
  91
  92 /**
  93  *      tty_throttle            -       flow control
  94  *      @tty: terminal
  95  *
  96  *      Indicate that a tty should stop transmitting data down the stack.
  97  *      Takes the termios mutex to protect against parallel throttle/unthrottle
  98  *      and also to ensure the driver can consistently reference its own
  99  *      termios data at this point when implementing software flow control.
 100  */
 101
 102 void tty_throttle(struct tty_struct *tty)
 103 {
 104         mutex_lock(&tty->termios_mutex);
 105         /* check TTY_THROTTLED first so it indicates our state */
 106         if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
 107             tty->ops->throttle)
 108                 tty->ops->throttle(tty);
 109         mutex_unlock(&tty->termios_mutex);
 110 }
 111 EXPORT_SYMBOL(tty_throttle);
 112
 113 /**
 114  *      tty_unthrottle          -       flow control
 115  *      @tty: terminal
 116  *
 117  *      Indicate that a tty may continue transmitting data down the stack.
 118  *      Takes the termios mutex to protect against parallel throttle/unthrottle
 119  *      and also to ensure the driver can consistently reference its own
 120  *      termios data at this point when implementing software flow control.
 121  *
 122  *      Drivers should however remember that the stack can issue a throttle,
 123  *      then change flow control method, then unthrottle.
 124  */
 125
 126 void tty_unthrottle(struct tty_struct *tty)
 127 {
 128         mutex_lock(&tty->termios_mutex);
 129         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
 130             tty->ops->unthrottle)
 131                 tty->ops->unthrottle(tty);
 132         mutex_unlock(&tty->termios_mutex);
 133 }
 134 EXPORT_SYMBOL(tty_unthrottle);
 135
 136 /**
 137  *      tty_wait_until_sent     -       wait for I/O to finish
 138  *      @tty: tty we are waiting for
 139  *      @timeout: how long we will wait
 140  *
 141  *      Wait for characters pending in a tty driver to hit the wire, or
 142  *      for a timeout to occur (eg due to flow control)
 143  *
 144  *      Locking: none
 145  */
 146
 147 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
 148 {
 149 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
 150         char buf[64];
 151
 152         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
 153 #endif
 154         if (!timeout)
 155                 timeout = MAX_SCHEDULE_TIMEOUT;
 156         if (wait_event_interruptible_timeout(tty->write_wait,
 157                         !tty_chars_in_buffer(tty), timeout) >= 0) {
 158                 if (tty->ops->wait_until_sent)
 159                         tty->ops->wait_until_sent(tty, timeout);
 160         }
 161 }
 162 EXPORT_SYMBOL(tty_wait_until_sent);
 163
 164
 165 /*
 166  *              Termios Helper Methods
 167  */
 168
 169 static void unset_locked_termios(struct ktermios *termios,
 170                                  struct ktermios *old,
 171                                  struct ktermios *locked)
 172 {
 173         int     i;
 174
 175 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
 176
 177         if (!locked) {
 178                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
 179                 return;
 180         }
 181
 182         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
 183         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
 184         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
 185         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
 186         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
 187         for (i = 0; i < NCCS; i++)
 188                 termios->c_cc[i] = locked->c_cc[i] ?
 189                         old->c_cc[i] : termios->c_cc[i];
 190         /* FIXME: What should we do for i/ospeed */
 191 }
 192
 193 /*
 194  * Routine which returns the baud rate of the tty
 195  *
 196  * Note that the baud_table needs to be kept in sync with the
 197  * include/asm/termbits.h file.
 198  */
 199 static const speed_t baud_table[] = {
 200         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
 201         9600, 19200, 38400, 57600, 115200, 230400, 460800,
 202 #ifdef __sparc__
 203         76800, 153600, 307200, 614400, 921600
 204 #else
 205         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
 206         2500000, 3000000, 3500000, 4000000
 207 #endif
 208 };
 209
 210 #ifndef __sparc__
 211 static const tcflag_t baud_bits[] = {
 212         B0, B50, B75, B110, B134, B150, B200, B300, B600,
 213         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
 214         B57600, B115200, B230400, B460800, B500000, B576000,
 215         B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
 216         B3000000, B3500000, B4000000
 217 };
 218 #else
 219 static const tcflag_t baud_bits[] = {
 220         B0, B50, B75, B110, B134, B150, B200, B300, B600,
 221         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
 222         B57600, B115200, B230400, B460800, B76800, B153600,
 223         B307200, B614400, B921600
 224 };
 225 #endif
 226
 227 static int n_baud_table = ARRAY_SIZE(baud_table);
 228
 229 /**
 230  *      tty_termios_baud_rate
 231  *      @termios: termios structure
 232  *
 233  *      Convert termios baud rate data into a speed. This should be called
 234  *      with the termios lock held if this termios is a terminal termios
 235  *      structure. May change the termios data. Device drivers can call this
 236  *      function but should use ->c_[io]speed directly as they are updated.
 237  *
 238  *      Locking: none
 239  */
 240
 241 speed_t tty_termios_baud_rate(struct ktermios *termios)
 242 {
 243         unsigned int cbaud;
 244
 245         cbaud = termios->c_cflag & CBAUD;
 246
 247 #ifdef BOTHER
 248         /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
 249         if (cbaud == BOTHER)
 250                 return termios->c_ospeed;
 251 #endif
 252         if (cbaud & CBAUDEX) {
 253                 cbaud &= ~CBAUDEX;
 254
 255                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
 256                         termios->c_cflag &= ~CBAUDEX;
 257                 else
 258                         cbaud += 15;
 259         }
 260         return baud_table[cbaud];
 261 }
 262 EXPORT_SYMBOL(tty_termios_baud_rate);
 263
 264 /**
 265  *      tty_termios_input_baud_rate
 266  *      @termios: termios structure
 267  *
 268  *      Convert termios baud rate data into a speed. This should be called
 269  *      with the termios lock held if this termios is a terminal termios
 270  *      structure. May change the termios data. Device drivers can call this
 271  *      function but should use ->c_[io]speed directly as they are updated.
 272  *
 273  *      Locking: none
 274  */
 275
 276 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
 277 {
 278 #ifdef IBSHIFT
 279         unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
 280
 281         if (cbaud == B0)
 282                 return tty_termios_baud_rate(termios);
 283
 284         /* Magic token for arbitrary speed via c_ispeed*/
 285         if (cbaud == BOTHER)
 286                 return termios->c_ispeed;
 287
 288         if (cbaud & CBAUDEX) {
 289                 cbaud &= ~CBAUDEX;
 290
 291                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
 292                         termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
 293                 else
 294                         cbaud += 15;
 295         }
 296         return baud_table[cbaud];
 297 #else
 298         return tty_termios_baud_rate(termios);
 299 #endif
 300 }
 301 EXPORT_SYMBOL(tty_termios_input_baud_rate);
 302
 303 /**
 304  *      tty_termios_encode_baud_rate
 305  *      @termios: ktermios structure holding user requested state
 306  *      @ispeed: input speed
 307  *      @ospeed: output speed
 308  *
 309  *      Encode the speeds set into the passed termios structure. This is
 310  *      used as a library helper for drivers so that they can report back
 311  *      the actual speed selected when it differs from the speed requested
 312  *
 313  *      For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
 314  *      we need to carefully set the bits when the user does not get the
 315  *      desired speed. We allow small margins and preserve as much of possible
 316  *      of the input intent to keep compatibility.
 317  *
 318  *      Locking: Caller should hold termios lock. This is already held
 319  *      when calling this function from the driver termios handler.
 320  *
 321  *      The ifdefs deal with platforms whose owners have yet to update them
 322  *      and will all go away once this is done.
 323  */
 324
 325 void tty_termios_encode_baud_rate(struct ktermios *termios,
 326                                   speed_t ibaud, speed_t obaud)
 327 {
 328         int i = 0;
 329         int ifound = -1, ofound = -1;
 330         int iclose = ibaud/50, oclose = obaud/50;
 331         int ibinput = 0;
 332
 333         if (obaud == 0)                 /* CD dropped             */
 334                 ibaud = 0;              /* Clear ibaud to be sure */
 335
 336         termios->c_ispeed = ibaud;
 337         termios->c_ospeed = obaud;
 338
 339 #ifdef BOTHER
 340         /* If the user asked for a precise weird speed give a precise weird
 341            answer. If they asked for a Bfoo speed they many have problems
 342            digesting non-exact replies so fuzz a bit */
 343
 344         if ((termios->c_cflag & CBAUD) == BOTHER)
 345                 oclose = 0;
 346         if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
 347                 iclose = 0;
 348         if ((termios->c_cflag >> IBSHIFT) & CBAUD)
 349                 ibinput = 1;    /* An input speed was specified */
 350 #endif
 351         termios->c_cflag &= ~CBAUD;
 352
 353         /*
 354          *      Our goal is to find a close match to the standard baud rate
 355          *      returned. Walk the baud rate table and if we get a very close
 356          *      match then report back the speed as a POSIX Bxxxx value by
 357          *      preference
 358          */
 359
 360         do {
 361                 if (obaud - oclose <= baud_table[i] &&
 362                     obaud + oclose >= baud_table[i]) {
 363                         termios->c_cflag |= baud_bits[i];
 364                         ofound = i;
 365                 }
 366                 if (ibaud - iclose <= baud_table[i] &&
 367                     ibaud + iclose >= baud_table[i]) {
 368                         /* For the case input == output don't set IBAUD bits
 369                            if the user didn't do so */
 370                         if (ofound == i && !ibinput)
 371                                 ifound  = i;
 372 #ifdef IBSHIFT
 373                         else {
 374                                 ifound = i;
 375                                 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
 376                         }
 377 #endif
 378                 }
 379         } while (++i < n_baud_table);
 380
 381         /*
 382          *      If we found no match then use BOTHER if provided or warn
 383          *      the user their platform maintainer needs to wake up if not.
 384          */
 385 #ifdef BOTHER
 386         if (ofound == -1)
 387                 termios->c_cflag |= BOTHER;
 388         /* Set exact input bits only if the input and output differ or the
 389            user already did */
 390         if (ifound == -1 && (ibaud != obaud || ibinput))
 391                 termios->c_cflag |= (BOTHER << IBSHIFT);
 392 #else
 393         if (ifound == -1 || ofound == -1) {
 394                 printk_once(KERN_WARNING "tty: Unable to return correct "
 395                           "speed data as your architecture needs updating.\n");
 396         }
 397 #endif
 398 }
 399 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
 400
 401 /**
 402  *      tty_encode_baud_rate            -       set baud rate of the tty
 403  *      @ibaud: input baud rate
 404  *      @obad: output baud rate
 405  *
 406  *      Update the current termios data for the tty with the new speed
 407  *      settings. The caller must hold the termios_mutex for the tty in
 408  *      question.
 409  */
 410
 411 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
 412 {
 413         tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
 414 }
 415 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
 416
 417 /**
 418  *      tty_get_baud_rate       -       get tty bit rates
 419  *      @tty: tty to query
 420  *
 421  *      Returns the baud rate as an integer for this terminal. The
 422  *      termios lock must be held by the caller and the terminal bit
 423  *      flags may be updated.
 424  *
 425  *      Locking: none
 426  */
 427
 428 speed_t tty_get_baud_rate(struct tty_struct *tty)
 429 {
 430         speed_t baud = tty_termios_baud_rate(tty->termios);
 431
 432         if (baud == 38400 && tty->alt_speed) {
 433                 if (!tty->warned) {
 434                         printk(KERN_WARNING "Use of setserial/setrocket to "
 435                                             "set SPD_* flags is deprecated\n");
 436                         tty->warned = 1;
 437                 }
 438                 baud = tty->alt_speed;
 439         }
 440
 441         return baud;
 442 }
 443 EXPORT_SYMBOL(tty_get_baud_rate);
 444
 445 /**
 446  *      tty_termios_copy_hw     -       copy hardware settings
 447  *      @new: New termios
 448  *      @old: Old termios
 449  *
 450  *      Propagate the hardware specific terminal setting bits from
 451  *      the old termios structure to the new one. This is used in cases
 452  *      where the hardware does not support reconfiguration or as a helper
 453  *      in some cases where only minimal reconfiguration is supported
 454  */
 455
 456 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
 457 {
 458         /* The bits a dumb device handles in software. Smart devices need
 459            to always provide a set_termios method */
 460         new->c_cflag &= HUPCL | CREAD | CLOCAL;
 461         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
 462         new->c_ispeed = old->c_ispeed;
 463         new->c_ospeed = old->c_ospeed;
 464 }
 465 EXPORT_SYMBOL(tty_termios_copy_hw);
 466
 467 /**
 468  *      tty_termios_hw_change   -       check for setting change
 469  *      @a: termios
 470  *      @b: termios to compare
 471  *
 472  *      Check if any of the bits that affect a dumb device have changed
 473  *      between the two termios structures, or a speed change is needed.
 474  */
 475
 476 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
 477 {
 478         if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
 479                 return 1;
 480         if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
 481                 return 1;
 482         return 0;
 483 }
 484 EXPORT_SYMBOL(tty_termios_hw_change);
 485
 486 /**
 487  *      tty_set_termios         -       update termios values
 488  *      @tty: tty to update
 489  *      @new_termios: desired new value
 490  *
 491  *      Perform updates to the termios values set on this terminal. There
 492  *      is a bit of layering violation here with n_tty in terms of the
 493  *      internal knowledge of this function.
 494  *
 495  *      Locking: termios_mutex
 496  */
 497
 498 int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
 499 {
 500         struct ktermios old_termios;
 501         struct tty_ldisc *ld;
 502         unsigned long flags;
 503
 504         /*
 505          *      Perform the actual termios internal changes under lock.
 506          */
 507
 508
 509         /* FIXME: we need to decide on some locking/ordering semantics
 510            for the set_termios notification eventually */
 511         mutex_lock(&tty->termios_mutex);
 512         old_termios = *tty->termios;
 513         *tty->termios = *new_termios;
 514         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
 515
 516         /* See if packet mode change of state. */
 517         if (tty->link && tty->link->packet) {
 518                 int extproc = (old_termios.c_lflag & EXTPROC) |
 519                                 (tty->termios->c_lflag & EXTPROC);
 520                 int old_flow = ((old_termios.c_iflag & IXON) &&
 521                                 (old_termios.c_cc[VSTOP] == '\023') &&
 522                                 (old_termios.c_cc[VSTART] == '\021'));
 523                 int new_flow = (I_IXON(tty) &&
 524                                 STOP_CHAR(tty) == '\023' &&
 525                                 START_CHAR(tty) == '\021');
 526                 if ((old_flow != new_flow) || extproc) {
 527                         spin_lock_irqsave(&tty->ctrl_lock, flags);
 528                         if (old_flow != new_flow) {
 529                                 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
 530                                 if (new_flow)
 531                                         tty->ctrl_status |= TIOCPKT_DOSTOP;
 532                                 else
 533                                         tty->ctrl_status |= TIOCPKT_NOSTOP;
 534                         }
 535                         if (extproc)
 536                                 tty->ctrl_status |= TIOCPKT_IOCTL;
 537                         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 538                         wake_up_interruptible(&tty->link->read_wait);
 539                 }
 540         }
 541
 542         if (tty->ops->set_termios)
 543                 (*tty->ops->set_termios)(tty, &old_termios);
 544         else
 545                 tty_termios_copy_hw(tty->termios, &old_termios);
 546
 547         ld = tty_ldisc_ref(tty);
 548         if (ld != NULL) {
 549                 if (ld->ops->set_termios)
 550                         (ld->ops->set_termios)(tty, &old_termios);
 551                 tty_ldisc_deref(ld);
 552         }
 553         mutex_unlock(&tty->termios_mutex);
 554         return 0;
 555 }
 556 EXPORT_SYMBOL_GPL(tty_set_termios);
 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 tty_set_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         tty_set_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         tty_set_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         BUG_ON(file == NULL);
 955
 956         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 957             tty->driver->subtype == PTY_TYPE_MASTER)
 958                 real_tty = tty->link;
 959         else
 960                 real_tty = tty;
 961
 962         switch (cmd) {
 963 #ifdef TIOCGETP
 964         case TIOCGETP:
 965                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
 966         case TIOCSETP:
 967         case TIOCSETN:
 968                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
 969 #endif
 970 #ifdef TIOCGETC
 971         case TIOCGETC:
 972                 return get_tchars(real_tty, p);
 973         case TIOCSETC:
 974                 return set_tchars(real_tty, p);
 975 #endif
 976 #ifdef TIOCGLTC
 977         case TIOCGLTC:
 978                 return get_ltchars(real_tty, p);
 979         case TIOCSLTC:
 980                 return set_ltchars(real_tty, p);
 981 #endif
 982         case TCSETSF:
 983                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
 984         case TCSETSW:
 985                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
 986         case TCSETS:
 987                 return set_termios(real_tty, p, TERMIOS_OLD);
 988 #ifndef TCGETS2
 989         case TCGETS:
 990                 copy_termios(real_tty, &kterm);
 991                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
 992                         ret = -EFAULT;
 993                 return ret;
 994 #else
 995         case TCGETS:
 996                 copy_termios(real_tty, &kterm);
 997                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
 998                         ret = -EFAULT;
 999                 return ret;
1000         case TCGETS2:
1001                 copy_termios(real_tty, &kterm);
1002                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
1003                         ret = -EFAULT;
1004                 return ret;
1005         case TCSETSF2:
1006                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
1007         case TCSETSW2:
1008                 return set_termios(real_tty, p, TERMIOS_WAIT);
1009         case TCSETS2:
1010                 return set_termios(real_tty, p, 0);
1011 #endif
1012         case TCGETA:
1013                 return get_termio(real_tty, p);
1014         case TCSETAF:
1015                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1016         case TCSETAW:
1017                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1018         case TCSETA:
1019                 return set_termios(real_tty, p, TERMIOS_TERMIO);
1020 #ifndef TCGETS2
1021         case TIOCGLCKTRMIOS:
1022                 copy_termios_locked(real_tty, &kterm);
1023                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1024                         ret = -EFAULT;
1025                 return ret;
1026         case TIOCSLCKTRMIOS:
1027                 if (!capable(CAP_SYS_ADMIN))
1028                         return -EPERM;
1029                 copy_termios_locked(real_tty, &kterm);
1030                 if (user_termios_to_kernel_termios(&kterm,
1031                                                (struct termios __user *) arg))
1032                         return -EFAULT;
1033                 mutex_lock(&real_tty->termios_mutex);
1034                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1035                 mutex_unlock(&real_tty->termios_mutex);
1036                 return 0;
1037 #else
1038         case TIOCGLCKTRMIOS:
1039                 copy_termios_locked(real_tty, &kterm);
1040                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1041                         ret = -EFAULT;
1042                 return ret;
1043         case TIOCSLCKTRMIOS:
1044                 if (!capable(CAP_SYS_ADMIN))
1045                         return -EPERM;
1046                 copy_termios_locked(real_tty, &kterm);
1047                 if (user_termios_to_kernel_termios_1(&kterm,
1048                                                (struct termios __user *) arg))
1049                         return -EFAULT;
1050                 mutex_lock(&real_tty->termios_mutex);
1051                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1052                 mutex_unlock(&real_tty->termios_mutex);
1053                 return ret;
1054 #endif
1055 #ifdef TCGETX
1056         case TCGETX: {
1057                 struct termiox ktermx;
1058                 if (real_tty->termiox == NULL)
1059                         return -EINVAL;
1060                 mutex_lock(&real_tty->termios_mutex);
1061                 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1062                 mutex_unlock(&real_tty->termios_mutex);
1063                 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1064                         ret = -EFAULT;
1065                 return ret;
1066         }
1067         case TCSETX:
1068                 return set_termiox(real_tty, p, 0);
1069         case TCSETXW:
1070                 return set_termiox(real_tty, p, TERMIOS_WAIT);
1071         case TCSETXF:
1072                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1073 #endif
1074         case TIOCGSOFTCAR:
1075                 copy_termios(real_tty, &kterm);
1076                 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1077                                                 (int __user *)arg);
1078                 return ret;
1079         case TIOCSSOFTCAR:
1080                 if (get_user(arg, (unsigned int __user *) arg))
1081                         return -EFAULT;
1082                 return tty_change_softcar(real_tty, arg);
1083         default:
1084                 return -ENOIOCTLCMD;
1085         }
1086 }
1087 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1088
1089 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1090 {
1091         struct tty_ldisc *ld;
1092         int retval = tty_check_change(tty);
1093         if (retval)
1094                 return retval;
1095
1096         ld = tty_ldisc_ref_wait(tty);
1097         switch (arg) {
1098         case TCIFLUSH:
1099                 if (ld && ld->ops->flush_buffer)
1100                         ld->ops->flush_buffer(tty);
1101                 break;
1102         case TCIOFLUSH:
1103                 if (ld && ld->ops->flush_buffer)
1104                         ld->ops->flush_buffer(tty);
1105                 /* fall through */
1106         case TCOFLUSH:
1107                 tty_driver_flush_buffer(tty);
1108                 break;
1109         default:
1110                 tty_ldisc_deref(ld);
1111                 return -EINVAL;
1112         }
1113         tty_ldisc_deref(ld);
1114         return 0;
1115 }
1116 EXPORT_SYMBOL_GPL(tty_perform_flush);
1117
1118 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1119                        unsigned int cmd, unsigned long arg)
1120 {
1121         unsigned long flags;
1122         int retval;
1123
1124         switch (cmd) {
1125         case TCXONC:
1126                 retval = tty_check_change(tty);
1127                 if (retval)
1128                         return retval;
1129                 switch (arg) {
1130                 case TCOOFF:
1131                         if (!tty->flow_stopped) {
1132                                 tty->flow_stopped = 1;
1133                                 stop_tty(tty);
1134                         }
1135                         break;
1136                 case TCOON:
1137                         if (tty->flow_stopped) {
1138                                 tty->flow_stopped = 0;
1139                                 start_tty(tty);
1140                         }
1141                         break;
1142                 case TCIOFF:
1143                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
1144                                 return send_prio_char(tty, STOP_CHAR(tty));
1145                         break;
1146                 case TCION:
1147                         if (START_CHAR(tty) != __DISABLED_CHAR)
1148                                 return send_prio_char(tty, START_CHAR(tty));
1149                         break;
1150                 default:
1151                         return -EINVAL;
1152                 }
1153                 return 0;
1154         case TCFLSH:
1155                 return tty_perform_flush(tty, arg);
1156         case TIOCPKT:
1157         {
1158                 int pktmode;
1159
1160                 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
1161                     tty->driver->subtype != PTY_TYPE_MASTER)
1162                         return -ENOTTY;
1163                 if (get_user(pktmode, (int __user *) arg))
1164                         return -EFAULT;
1165                 spin_lock_irqsave(&tty->ctrl_lock, flags);
1166                 if (pktmode) {
1167                         if (!tty->packet) {
1168                                 tty->packet = 1;
1169                                 tty->link->ctrl_status = 0;
1170                         }
1171                 } else
1172                         tty->packet = 0;
1173                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1174                 return 0;
1175         }
1176         default:
1177                 /* Try the mode commands */
1178                 return tty_mode_ioctl(tty, file, cmd, arg);
1179         }
1180 }
1181 EXPORT_SYMBOL(n_tty_ioctl_helper);
1182
1183 #ifdef CONFIG_COMPAT
1184 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1185                                         unsigned int cmd, unsigned long arg)
1186 {
1187         switch (cmd) {
1188         case TIOCGLCKTRMIOS:
1189         case TIOCSLCKTRMIOS:
1190                 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1191         default:
1192                 return -ENOIOCTLCMD;
1193         }
1194 }
1195 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
1196 #endif
1197