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