git.oblomov.eu Git - linux-2.6/blob - drivers/char/tty_ioctl.c

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