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