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 rwsem 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         down_write(&tty->termios_rwsem);
 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         up_write(&tty->termios_rwsem);
 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 rwsem 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         down_write(&tty->termios_rwsem);
 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         up_write(&tty->termios_rwsem);
 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->throttle_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->throttle_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->throttle_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->throttle_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         timeout = wait_event_interruptible_timeout(tty->write_wait,
 222                         !tty_chars_in_buffer(tty), timeout);
 223         if (timeout <= 0)
 224                 return;
 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 may 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_rwsem 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.
 534  *      A master pty's termios should never be set.
 535  *
 536  *      Locking: termios_rwsem
 537  */
 538
 539 static int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
 540 {
 541         struct ktermios old_termios;
 542         struct tty_ldisc *ld;
 543
 544         WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 545                 tty->driver->subtype == PTY_TYPE_MASTER);
 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         down_write(&tty->termios_rwsem);
 554         old_termios = tty->termios;
 555         tty->termios = *new_termios;
 556         unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked);
 557
 558         if (tty->ops->set_termios)
 559                 tty->ops->set_termios(tty, &old_termios);
 560         else
 561                 tty_termios_copy_hw(&tty->termios, &old_termios);
 562
 563         ld = tty_ldisc_ref(tty);
 564         if (ld != NULL) {
 565                 if (ld->ops->set_termios)
 566                         ld->ops->set_termios(tty, &old_termios);
 567                 tty_ldisc_deref(ld);
 568         }
 569         up_write(&tty->termios_rwsem);
 570         return 0;
 571 }
 572
 573 /**
 574  *      set_termios             -       set termios values for a tty
 575  *      @tty: terminal device
 576  *      @arg: user data
 577  *      @opt: option information
 578  *
 579  *      Helper function to prepare termios data and run necessary other
 580  *      functions before using tty_set_termios to do the actual changes.
 581  *
 582  *      Locking:
 583  *              Called functions take ldisc and termios_rwsem locks
 584  */
 585
 586 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
 587 {
 588         struct ktermios tmp_termios;
 589         struct tty_ldisc *ld;
 590         int retval = tty_check_change(tty);
 591
 592         if (retval)
 593                 return retval;
 594
 595         down_read(&tty->termios_rwsem);
 596         tmp_termios = tty->termios;
 597         up_read(&tty->termios_rwsem);
 598
 599         if (opt & TERMIOS_TERMIO) {
 600                 if (user_termio_to_kernel_termios(&tmp_termios,
 601                                                 (struct termio __user *)arg))
 602                         return -EFAULT;
 603 #ifdef TCGETS2
 604         } else if (opt & TERMIOS_OLD) {
 605                 if (user_termios_to_kernel_termios_1(&tmp_termios,
 606                                                 (struct termios __user *)arg))
 607                         return -EFAULT;
 608         } else {
 609                 if (user_termios_to_kernel_termios(&tmp_termios,
 610                                                 (struct termios2 __user *)arg))
 611                         return -EFAULT;
 612         }
 613 #else
 614         } else if (user_termios_to_kernel_termios(&tmp_termios,
 615                                         (struct termios __user *)arg))
 616                 return -EFAULT;
 617 #endif
 618
 619         /* If old style Bfoo values are used then load c_ispeed/c_ospeed
 620          * with the real speed so its unconditionally usable */
 621         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
 622         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
 623
 624         ld = tty_ldisc_ref(tty);
 625
 626         if (ld != NULL) {
 627                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 628                         ld->ops->flush_buffer(tty);
 629                 tty_ldisc_deref(ld);
 630         }
 631
 632         if (opt & TERMIOS_WAIT) {
 633                 tty_wait_until_sent(tty, 0);
 634                 if (signal_pending(current))
 635                         return -ERESTARTSYS;
 636         }
 637
 638         tty_set_termios(tty, &tmp_termios);
 639
 640         /* FIXME: Arguably if tmp_termios == tty->termios AND the
 641            actual requested termios was not tmp_termios then we may
 642            want to return an error as no user requested change has
 643            succeeded */
 644         return 0;
 645 }
 646
 647 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
 648 {
 649         down_read(&tty->termios_rwsem);
 650         *kterm = tty->termios;
 651         up_read(&tty->termios_rwsem);
 652 }
 653
 654 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
 655 {
 656         down_read(&tty->termios_rwsem);
 657         *kterm = tty->termios_locked;
 658         up_read(&tty->termios_rwsem);
 659 }
 660
 661 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
 662 {
 663         struct ktermios kterm;
 664         copy_termios(tty, &kterm);
 665         if (kernel_termios_to_user_termio(termio, &kterm))
 666                 return -EFAULT;
 667         return 0;
 668 }
 669
 670
 671 #ifdef TCGETX
 672
 673 /**
 674  *      set_termiox     -       set termiox fields if possible
 675  *      @tty: terminal
 676  *      @arg: termiox structure from user
 677  *      @opt: option flags for ioctl type
 678  *
 679  *      Implement the device calling points for the SYS5 termiox ioctl
 680  *      interface in Linux
 681  */
 682
 683 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
 684 {
 685         struct termiox tnew;
 686         struct tty_ldisc *ld;
 687
 688         if (tty->termiox == NULL)
 689                 return -EINVAL;
 690         if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
 691                 return -EFAULT;
 692
 693         ld = tty_ldisc_ref(tty);
 694         if (ld != NULL) {
 695                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 696                         ld->ops->flush_buffer(tty);
 697                 tty_ldisc_deref(ld);
 698         }
 699         if (opt & TERMIOS_WAIT) {
 700                 tty_wait_until_sent(tty, 0);
 701                 if (signal_pending(current))
 702                         return -ERESTARTSYS;
 703         }
 704
 705         down_write(&tty->termios_rwsem);
 706         if (tty->ops->set_termiox)
 707                 tty->ops->set_termiox(tty, &tnew);
 708         up_write(&tty->termios_rwsem);
 709         return 0;
 710 }
 711
 712 #endif
 713
 714
 715 #ifdef TIOCGETP
 716 /*
 717  * These are deprecated, but there is limited support..
 718  *
 719  * The "sg_flags" translation is a joke..
 720  */
 721 static int get_sgflags(struct tty_struct *tty)
 722 {
 723         int flags = 0;
 724
 725         if (!(tty->termios.c_lflag & ICANON)) {
 726                 if (tty->termios.c_lflag & ISIG)
 727                         flags |= 0x02;          /* cbreak */
 728                 else
 729                         flags |= 0x20;          /* raw */
 730         }
 731         if (tty->termios.c_lflag & ECHO)
 732                 flags |= 0x08;                  /* echo */
 733         if (tty->termios.c_oflag & OPOST)
 734                 if (tty->termios.c_oflag & ONLCR)
 735                         flags |= 0x10;          /* crmod */
 736         return flags;
 737 }
 738
 739 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 740 {
 741         struct sgttyb tmp;
 742
 743         down_read(&tty->termios_rwsem);
 744         tmp.sg_ispeed = tty->termios.c_ispeed;
 745         tmp.sg_ospeed = tty->termios.c_ospeed;
 746         tmp.sg_erase = tty->termios.c_cc[VERASE];
 747         tmp.sg_kill = tty->termios.c_cc[VKILL];
 748         tmp.sg_flags = get_sgflags(tty);
 749         up_read(&tty->termios_rwsem);
 750
 751         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 752 }
 753
 754 static void set_sgflags(struct ktermios *termios, int flags)
 755 {
 756         termios->c_iflag = ICRNL | IXON;
 757         termios->c_oflag = 0;
 758         termios->c_lflag = ISIG | ICANON;
 759         if (flags & 0x02) {     /* cbreak */
 760                 termios->c_iflag = 0;
 761                 termios->c_lflag &= ~ICANON;
 762         }
 763         if (flags & 0x08) {             /* echo */
 764                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
 765                                     ECHOCTL | ECHOKE | IEXTEN;
 766         }
 767         if (flags & 0x10) {             /* crmod */
 768                 termios->c_oflag |= OPOST | ONLCR;
 769         }
 770         if (flags & 0x20) {     /* raw */
 771                 termios->c_iflag = 0;
 772                 termios->c_lflag &= ~(ISIG | ICANON);
 773         }
 774         if (!(termios->c_lflag & ICANON)) {
 775                 termios->c_cc[VMIN] = 1;
 776                 termios->c_cc[VTIME] = 0;
 777         }
 778 }
 779
 780 /**
 781  *      set_sgttyb              -       set legacy terminal values
 782  *      @tty: tty structure
 783  *      @sgttyb: pointer to old style terminal structure
 784  *
 785  *      Updates a terminal from the legacy BSD style terminal information
 786  *      structure.
 787  *
 788  *      Locking: termios_rwsem
 789  */
 790
 791 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 792 {
 793         int retval;
 794         struct sgttyb tmp;
 795         struct ktermios termios;
 796
 797         retval = tty_check_change(tty);
 798         if (retval)
 799                 return retval;
 800
 801         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
 802                 return -EFAULT;
 803
 804         down_write(&tty->termios_rwsem);
 805         termios = tty->termios;
 806         termios.c_cc[VERASE] = tmp.sg_erase;
 807         termios.c_cc[VKILL] = tmp.sg_kill;
 808         set_sgflags(&termios, tmp.sg_flags);
 809         /* Try and encode into Bfoo format */
 810 #ifdef BOTHER
 811         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
 812                                                 termios.c_ospeed);
 813 #endif
 814         up_write(&tty->termios_rwsem);
 815         tty_set_termios(tty, &termios);
 816         return 0;
 817 }
 818 #endif
 819
 820 #ifdef TIOCGETC
 821 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 822 {
 823         struct tchars tmp;
 824
 825         down_read(&tty->termios_rwsem);
 826         tmp.t_intrc = tty->termios.c_cc[VINTR];
 827         tmp.t_quitc = tty->termios.c_cc[VQUIT];
 828         tmp.t_startc = tty->termios.c_cc[VSTART];
 829         tmp.t_stopc = tty->termios.c_cc[VSTOP];
 830         tmp.t_eofc = tty->termios.c_cc[VEOF];
 831         tmp.t_brkc = tty->termios.c_cc[VEOL2];  /* what is brkc anyway? */
 832         up_read(&tty->termios_rwsem);
 833         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 834 }
 835
 836 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 837 {
 838         struct tchars tmp;
 839
 840         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
 841                 return -EFAULT;
 842         down_write(&tty->termios_rwsem);
 843         tty->termios.c_cc[VINTR] = tmp.t_intrc;
 844         tty->termios.c_cc[VQUIT] = tmp.t_quitc;
 845         tty->termios.c_cc[VSTART] = tmp.t_startc;
 846         tty->termios.c_cc[VSTOP] = tmp.t_stopc;
 847         tty->termios.c_cc[VEOF] = tmp.t_eofc;
 848         tty->termios.c_cc[VEOL2] = tmp.t_brkc;  /* what is brkc anyway? */
 849         up_write(&tty->termios_rwsem);
 850         return 0;
 851 }
 852 #endif
 853
 854 #ifdef TIOCGLTC
 855 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 856 {
 857         struct ltchars tmp;
 858
 859         down_read(&tty->termios_rwsem);
 860         tmp.t_suspc = tty->termios.c_cc[VSUSP];
 861         /* what is dsuspc anyway? */
 862         tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
 863         tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
 864         /* what is flushc anyway? */
 865         tmp.t_flushc = tty->termios.c_cc[VEOL2];
 866         tmp.t_werasc = tty->termios.c_cc[VWERASE];
 867         tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
 868         up_read(&tty->termios_rwsem);
 869         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 870 }
 871
 872 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 873 {
 874         struct ltchars tmp;
 875
 876         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
 877                 return -EFAULT;
 878
 879         down_write(&tty->termios_rwsem);
 880         tty->termios.c_cc[VSUSP] = tmp.t_suspc;
 881         /* what is dsuspc anyway? */
 882         tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
 883         tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
 884         /* what is flushc anyway? */
 885         tty->termios.c_cc[VEOL2] = tmp.t_flushc;
 886         tty->termios.c_cc[VWERASE] = tmp.t_werasc;
 887         tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
 888         up_write(&tty->termios_rwsem);
 889         return 0;
 890 }
 891 #endif
 892
 893 /**
 894  *      tty_change_softcar      -       carrier change ioctl helper
 895  *      @tty: tty to update
 896  *      @arg: enable/disable CLOCAL
 897  *
 898  *      Perform a change to the CLOCAL state and call into the driver
 899  *      layer to make it visible. All done with the termios rwsem
 900  */
 901
 902 static int tty_change_softcar(struct tty_struct *tty, int arg)
 903 {
 904         int ret = 0;
 905         int bit = arg ? CLOCAL : 0;
 906         struct ktermios old;
 907
 908         down_write(&tty->termios_rwsem);
 909         old = tty->termios;
 910         tty->termios.c_cflag &= ~CLOCAL;
 911         tty->termios.c_cflag |= bit;
 912         if (tty->ops->set_termios)
 913                 tty->ops->set_termios(tty, &old);
 914         if ((tty->termios.c_cflag & CLOCAL) != bit)
 915                 ret = -EINVAL;
 916         up_write(&tty->termios_rwsem);
 917         return ret;
 918 }
 919
 920 /**
 921  *      tty_mode_ioctl          -       mode related ioctls
 922  *      @tty: tty for the ioctl
 923  *      @file: file pointer for the tty
 924  *      @cmd: command
 925  *      @arg: ioctl argument
 926  *
 927  *      Perform non line discipline specific mode control ioctls. This
 928  *      is designed to be called by line disciplines to ensure they provide
 929  *      consistent mode setting.
 930  */
 931
 932 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
 933                         unsigned int cmd, unsigned long arg)
 934 {
 935         struct tty_struct *real_tty;
 936         void __user *p = (void __user *)arg;
 937         int ret = 0;
 938         struct ktermios kterm;
 939
 940         BUG_ON(file == NULL);
 941
 942         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 943             tty->driver->subtype == PTY_TYPE_MASTER)
 944                 real_tty = tty->link;
 945         else
 946                 real_tty = tty;
 947
 948         switch (cmd) {
 949 #ifdef TIOCGETP
 950         case TIOCGETP:
 951                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
 952         case TIOCSETP:
 953         case TIOCSETN:
 954                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
 955 #endif
 956 #ifdef TIOCGETC
 957         case TIOCGETC:
 958                 return get_tchars(real_tty, p);
 959         case TIOCSETC:
 960                 return set_tchars(real_tty, p);
 961 #endif
 962 #ifdef TIOCGLTC
 963         case TIOCGLTC:
 964                 return get_ltchars(real_tty, p);
 965         case TIOCSLTC:
 966                 return set_ltchars(real_tty, p);
 967 #endif
 968         case TCSETSF:
 969                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
 970         case TCSETSW:
 971                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
 972         case TCSETS:
 973                 return set_termios(real_tty, p, TERMIOS_OLD);
 974 #ifndef TCGETS2
 975         case TCGETS:
 976                 copy_termios(real_tty, &kterm);
 977                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
 978                         ret = -EFAULT;
 979                 return ret;
 980 #else
 981         case TCGETS:
 982                 copy_termios(real_tty, &kterm);
 983                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
 984                         ret = -EFAULT;
 985                 return ret;
 986         case TCGETS2:
 987                 copy_termios(real_tty, &kterm);
 988                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
 989                         ret = -EFAULT;
 990                 return ret;
 991         case TCSETSF2:
 992                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
 993         case TCSETSW2:
 994                 return set_termios(real_tty, p, TERMIOS_WAIT);
 995         case TCSETS2:
 996                 return set_termios(real_tty, p, 0);
 997 #endif
 998         case TCGETA:
 999                 return get_termio(real_tty, p);
1000         case TCSETAF:
1001                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1002         case TCSETAW:
1003                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1004         case TCSETA:
1005                 return set_termios(real_tty, p, TERMIOS_TERMIO);
1006 #ifndef TCGETS2
1007         case TIOCGLCKTRMIOS:
1008                 copy_termios_locked(real_tty, &kterm);
1009                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1010                         ret = -EFAULT;
1011                 return ret;
1012         case TIOCSLCKTRMIOS:
1013                 if (!capable(CAP_SYS_ADMIN))
1014                         return -EPERM;
1015                 copy_termios_locked(real_tty, &kterm);
1016                 if (user_termios_to_kernel_termios(&kterm,
1017                                                (struct termios __user *) arg))
1018                         return -EFAULT;
1019                 down_write(&real_tty->termios_rwsem);
1020                 real_tty->termios_locked = kterm;
1021                 up_write(&real_tty->termios_rwsem);
1022                 return 0;
1023 #else
1024         case TIOCGLCKTRMIOS:
1025                 copy_termios_locked(real_tty, &kterm);
1026                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1027                         ret = -EFAULT;
1028                 return ret;
1029         case TIOCSLCKTRMIOS:
1030                 if (!capable(CAP_SYS_ADMIN))
1031                         return -EPERM;
1032                 copy_termios_locked(real_tty, &kterm);
1033                 if (user_termios_to_kernel_termios_1(&kterm,
1034                                                (struct termios __user *) arg))
1035                         return -EFAULT;
1036                 down_write(&real_tty->termios_rwsem);
1037                 real_tty->termios_locked = kterm;
1038                 up_write(&real_tty->termios_rwsem);
1039                 return ret;
1040 #endif
1041 #ifdef TCGETX
1042         case TCGETX: {
1043                 struct termiox ktermx;
1044                 if (real_tty->termiox == NULL)
1045                         return -EINVAL;
1046                 down_read(&real_tty->termios_rwsem);
1047                 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1048                 up_read(&real_tty->termios_rwsem);
1049                 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1050                         ret = -EFAULT;
1051                 return ret;
1052         }
1053         case TCSETX:
1054                 return set_termiox(real_tty, p, 0);
1055         case TCSETXW:
1056                 return set_termiox(real_tty, p, TERMIOS_WAIT);
1057         case TCSETXF:
1058                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1059 #endif
1060         case TIOCGSOFTCAR:
1061                 copy_termios(real_tty, &kterm);
1062                 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1063                                                 (int __user *)arg);
1064                 return ret;
1065         case TIOCSSOFTCAR:
1066                 if (get_user(arg, (unsigned int __user *) arg))
1067                         return -EFAULT;
1068                 return tty_change_softcar(real_tty, arg);
1069         default:
1070                 return -ENOIOCTLCMD;
1071         }
1072 }
1073 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1074
1075
1076 /* Caller guarantees ldisc reference is held */
1077 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1078 {
1079         struct tty_ldisc *ld = tty->ldisc;
1080
1081         switch (arg) {
1082         case TCIFLUSH:
1083                 if (ld && ld->ops->flush_buffer) {
1084                         ld->ops->flush_buffer(tty);
1085                         tty_unthrottle(tty);
1086                 }
1087                 break;
1088         case TCIOFLUSH:
1089                 if (ld && ld->ops->flush_buffer) {
1090                         ld->ops->flush_buffer(tty);
1091                         tty_unthrottle(tty);
1092                 }
1093                 /* fall through */
1094         case TCOFLUSH:
1095                 tty_driver_flush_buffer(tty);
1096                 break;
1097         default:
1098                 return -EINVAL;
1099         }
1100         return 0;
1101 }
1102
1103 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1104 {
1105         struct tty_ldisc *ld;
1106         int retval = tty_check_change(tty);
1107         if (retval)
1108                 return retval;
1109
1110         ld = tty_ldisc_ref_wait(tty);
1111         retval = __tty_perform_flush(tty, arg);
1112         if (ld)
1113                 tty_ldisc_deref(ld);
1114         return retval;
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         int retval;
1122
1123         switch (cmd) {
1124         case TCXONC:
1125                 retval = tty_check_change(tty);
1126                 if (retval)
1127                         return retval;
1128                 switch (arg) {
1129                 case TCOOFF:
1130                         spin_lock_irq(&tty->flow_lock);
1131                         if (!tty->flow_stopped) {
1132                                 tty->flow_stopped = 1;
1133                                 __stop_tty(tty);
1134                         }
1135                         spin_unlock_irq(&tty->flow_lock);
1136                         break;
1137                 case TCOON:
1138                         spin_lock_irq(&tty->flow_lock);
1139                         if (tty->flow_stopped) {
1140                                 tty->flow_stopped = 0;
1141                                 __start_tty(tty);
1142                         }
1143                         spin_unlock_irq(&tty->flow_lock);
1144                         break;
1145                 case TCIOFF:
1146                         down_read(&tty->termios_rwsem);
1147                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
1148                                 retval = tty_send_xchar(tty, STOP_CHAR(tty));
1149                         up_read(&tty->termios_rwsem);
1150                         break;
1151                 case TCION:
1152                         down_read(&tty->termios_rwsem);
1153                         if (START_CHAR(tty) != __DISABLED_CHAR)
1154                                 retval = tty_send_xchar(tty, START_CHAR(tty));
1155                         up_read(&tty->termios_rwsem);
1156                         break;
1157                 default:
1158                         return -EINVAL;
1159                 }
1160                 return retval;
1161         case TCFLSH:
1162                 retval = tty_check_change(tty);
1163                 if (retval)
1164                         return retval;
1165                 return __tty_perform_flush(tty, arg);
1166         default:
1167                 /* Try the mode commands */
1168                 return tty_mode_ioctl(tty, file, cmd, arg);
1169         }
1170 }
1171 EXPORT_SYMBOL(n_tty_ioctl_helper);
1172
1173 #ifdef CONFIG_COMPAT
1174 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1175                                         unsigned int cmd, unsigned long arg)
1176 {
1177         switch (cmd) {
1178         case TIOCGLCKTRMIOS:
1179         case TIOCSLCKTRMIOS:
1180                 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1181         default:
1182                 return -ENOIOCTLCMD;
1183         }
1184 }
1185 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
1186 #endif
1187