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