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