drivers/tty/tty_ioctl.c

   1 /*
   2  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
   3  *
   4  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
   5  * which can be dynamically activated and de-activated by the line
   6  * discipline handling modules (like SLIP).
   7  */
   8
   9 #include <linux/types.h>
  10 #include <linux/termios.h>
  11 #include <linux/errno.h>
  12 #include <linux/sched/signal.h>
  13 #include <linux/kernel.h>
  14 #include <linux/major.h>
  15 #include <linux/tty.h>
  16 #include <linux/fcntl.h>
  17 #include <linux/string.h>
  18 #include <linux/mm.h>
  19 #include <linux/module.h>
  20 #include <linux/bitops.h>
  21 #include <linux/mutex.h>
  22 #include <linux/compat.h>
  23
  24 #include <asm/io.h>
  25 #include <linux/uaccess.h>
  26
  27 #undef TTY_DEBUG_WAIT_UNTIL_SENT
  28
  29 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  30 # define tty_debug_wait_until_sent(tty, f, args...)    tty_debug(tty, f, ##args)
  31 #else
  32 # define tty_debug_wait_until_sent(tty, f, args...)    do {} while (0)
  33 #endif
  34
  35 #undef  DEBUG
  36
  37 /*
  38  * Internal flag options for termios setting behavior
  39  */
  40 #define TERMIOS_FLUSH   1
  41 #define TERMIOS_WAIT    2
  42 #define TERMIOS_TERMIO  4
  43 #define TERMIOS_OLD     8
  44
  45
  46 /**
  47  *      tty_chars_in_buffer     -       characters pending
  48  *      @tty: terminal
  49  *
  50  *      Return the number of bytes of data in the device private
  51  *      output queue. If no private method is supplied there is assumed
  52  *      to be no queue on the device.
  53  */
  54
  55 int tty_chars_in_buffer(struct tty_struct *tty)
  56 {
  57         if (tty->ops->chars_in_buffer)
  58                 return tty->ops->chars_in_buffer(tty);
  59         else
  60                 return 0;
  61 }
  62 EXPORT_SYMBOL(tty_chars_in_buffer);
  63
  64 /**
  65  *      tty_write_room          -       write queue space
  66  *      @tty: terminal
  67  *
  68  *      Return the number of bytes that can be queued to this device
  69  *      at the present time. The result should be treated as a guarantee
  70  *      and the driver cannot offer a value it later shrinks by more than
  71  *      the number of bytes written. If no method is provided 2K is always
  72  *      returned and data may be lost as there will be no flow control.
  73  */
  74
  75 int tty_write_room(struct tty_struct *tty)
  76 {
  77         if (tty->ops->write_room)
  78                 return tty->ops->write_room(tty);
  79         return 2048;
  80 }
  81 EXPORT_SYMBOL(tty_write_room);
  82
  83 /**
  84  *      tty_driver_flush_buffer -       discard internal buffer
  85  *      @tty: terminal
  86  *
  87  *      Discard the internal output buffer for this device. If no method
  88  *      is provided then either the buffer cannot be hardware flushed or
  89  *      there is no buffer driver side.
  90  */
  91 void tty_driver_flush_buffer(struct tty_struct *tty)
  92 {
  93         if (tty->ops->flush_buffer)
  94                 tty->ops->flush_buffer(tty);
  95 }
  96 EXPORT_SYMBOL(tty_driver_flush_buffer);
  97
  98 /**
  99  *      tty_throttle            -       flow control
 100  *      @tty: terminal
 101  *
 102  *      Indicate that a tty should stop transmitting data down the stack.
 103  *      Takes the termios rwsem to protect against parallel throttle/unthrottle
 104  *      and also to ensure the driver can consistently reference its own
 105  *      termios data at this point when implementing software flow control.
 106  */
 107
 108 void tty_throttle(struct tty_struct *tty)
 109 {
 110         down_write(&tty->termios_rwsem);
 111         /* check TTY_THROTTLED first so it indicates our state */
 112         if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
 113             tty->ops->throttle)
 114                 tty->ops->throttle(tty);
 115         tty->flow_change = 0;
 116         up_write(&tty->termios_rwsem);
 117 }
 118 EXPORT_SYMBOL(tty_throttle);
 119
 120 /**
 121  *      tty_unthrottle          -       flow control
 122  *      @tty: terminal
 123  *
 124  *      Indicate that a tty may continue transmitting data down the stack.
 125  *      Takes the termios rwsem to protect against parallel throttle/unthrottle
 126  *      and also to ensure the driver can consistently reference its own
 127  *      termios data at this point when implementing software flow control.
 128  *
 129  *      Drivers should however remember that the stack can issue a throttle,
 130  *      then change flow control method, then unthrottle.
 131  */
 132
 133 void tty_unthrottle(struct tty_struct *tty)
 134 {
 135         down_write(&tty->termios_rwsem);
 136         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
 137             tty->ops->unthrottle)
 138                 tty->ops->unthrottle(tty);
 139         tty->flow_change = 0;
 140         up_write(&tty->termios_rwsem);
 141 }
 142 EXPORT_SYMBOL(tty_unthrottle);
 143
 144 /**
 145  *      tty_throttle_safe       -       flow control
 146  *      @tty: terminal
 147  *
 148  *      Similar to tty_throttle() but will only attempt throttle
 149  *      if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
 150  *      throttle due to race conditions when throttling is conditional
 151  *      on factors evaluated prior to throttling.
 152  *
 153  *      Returns 0 if tty is throttled (or was already throttled)
 154  */
 155
 156 int tty_throttle_safe(struct tty_struct *tty)
 157 {
 158         int ret = 0;
 159
 160         mutex_lock(&tty->throttle_mutex);
 161         if (!tty_throttled(tty)) {
 162                 if (tty->flow_change != TTY_THROTTLE_SAFE)
 163                         ret = 1;
 164                 else {
 165                         set_bit(TTY_THROTTLED, &tty->flags);
 166                         if (tty->ops->throttle)
 167                                 tty->ops->throttle(tty);
 168                 }
 169         }
 170         mutex_unlock(&tty->throttle_mutex);
 171
 172         return ret;
 173 }
 174
 175 /**
 176  *      tty_unthrottle_safe     -       flow control
 177  *      @tty: terminal
 178  *
 179  *      Similar to tty_unthrottle() but will only attempt unthrottle
 180  *      if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
 181  *      unthrottle due to race conditions when unthrottling is conditional
 182  *      on factors evaluated prior to unthrottling.
 183  *
 184  *      Returns 0 if tty is unthrottled (or was already unthrottled)
 185  */
 186
 187 int tty_unthrottle_safe(struct tty_struct *tty)
 188 {
 189         int ret = 0;
 190
 191         mutex_lock(&tty->throttle_mutex);
 192         if (tty_throttled(tty)) {
 193                 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
 194                         ret = 1;
 195                 else {
 196                         clear_bit(TTY_THROTTLED, &tty->flags);
 197                         if (tty->ops->unthrottle)
 198                                 tty->ops->unthrottle(tty);
 199                 }
 200         }
 201         mutex_unlock(&tty->throttle_mutex);
 202
 203         return ret;
 204 }
 205
 206 /**
 207  *      tty_wait_until_sent     -       wait for I/O to finish
 208  *      @tty: tty we are waiting for
 209  *      @timeout: how long we will wait
 210  *
 211  *      Wait for characters pending in a tty driver to hit the wire, or
 212  *      for a timeout to occur (eg due to flow control)
 213  *
 214  *      Locking: none
 215  */
 216
 217 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
 218 {
 219         tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
 220
 221         if (!timeout)
 222                 timeout = MAX_SCHEDULE_TIMEOUT;
 223
 224         timeout = wait_event_interruptible_timeout(tty->write_wait,
 225                         !tty_chars_in_buffer(tty), timeout);
 226         if (timeout <= 0)
 227                 return;
 228
 229         if (timeout == MAX_SCHEDULE_TIMEOUT)
 230                 timeout = 0;
 231
 232         if (tty->ops->wait_until_sent)
 233                 tty->ops->wait_until_sent(tty, timeout);
 234 }
 235 EXPORT_SYMBOL(tty_wait_until_sent);
 236
 237
 238 /*
 239  *              Termios Helper Methods
 240  */
 241
 242 static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
 243 {
 244         struct ktermios *termios = &tty->termios;
 245         struct ktermios *locked  = &tty->termios_locked;
 246         int     i;
 247
 248 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
 249
 250         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
 251         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
 252         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
 253         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
 254         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
 255         for (i = 0; i < NCCS; i++)
 256                 termios->c_cc[i] = locked->c_cc[i] ?
 257                         old->c_cc[i] : termios->c_cc[i];
 258         /* FIXME: What should we do for i/ospeed */
 259 }
 260
 261 /**
 262  *      tty_termios_copy_hw     -       copy hardware settings
 263  *      @new: New termios
 264  *      @old: Old termios
 265  *
 266  *      Propagate the hardware specific terminal setting bits from
 267  *      the old termios structure to the new one. This is used in cases
 268  *      where the hardware does not support reconfiguration or as a helper
 269  *      in some cases where only minimal reconfiguration is supported
 270  */
 271
 272 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
 273 {
 274         /* The bits a dumb device handles in software. Smart devices need
 275            to always provide a set_termios method */
 276         new->c_cflag &= HUPCL | CREAD | CLOCAL;
 277         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
 278         new->c_ispeed = old->c_ispeed;
 279         new->c_ospeed = old->c_ospeed;
 280 }
 281 EXPORT_SYMBOL(tty_termios_copy_hw);
 282
 283 /**
 284  *      tty_termios_hw_change   -       check for setting change
 285  *      @a: termios
 286  *      @b: termios to compare
 287  *
 288  *      Check if any of the bits that affect a dumb device have changed
 289  *      between the two termios structures, or a speed change is needed.
 290  */
 291
 292 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
 293 {
 294         if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
 295                 return 1;
 296         if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
 297                 return 1;
 298         return 0;
 299 }
 300 EXPORT_SYMBOL(tty_termios_hw_change);
 301
 302 /**
 303  *      tty_set_termios         -       update termios values
 304  *      @tty: tty to update
 305  *      @new_termios: desired new value
 306  *
 307  *      Perform updates to the termios values set on this terminal.
 308  *      A master pty's termios should never be set.
 309  *
 310  *      Locking: termios_rwsem
 311  */
 312
 313 int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
 314 {
 315         struct ktermios old_termios;
 316         struct tty_ldisc *ld;
 317
 318         WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 319                 tty->driver->subtype == PTY_TYPE_MASTER);
 320         /*
 321          *      Perform the actual termios internal changes under lock.
 322          */
 323
 324
 325         /* FIXME: we need to decide on some locking/ordering semantics
 326            for the set_termios notification eventually */
 327         down_write(&tty->termios_rwsem);
 328         old_termios = tty->termios;
 329         tty->termios = *new_termios;
 330         unset_locked_termios(tty, &old_termios);
 331
 332         if (tty->ops->set_termios)
 333                 tty->ops->set_termios(tty, &old_termios);
 334         else
 335                 tty_termios_copy_hw(&tty->termios, &old_termios);
 336
 337         ld = tty_ldisc_ref(tty);
 338         if (ld != NULL) {
 339                 if (ld->ops->set_termios)
 340                         ld->ops->set_termios(tty, &old_termios);
 341                 tty_ldisc_deref(ld);
 342         }
 343         up_write(&tty->termios_rwsem);
 344         return 0;
 345 }
 346 EXPORT_SYMBOL_GPL(tty_set_termios);
 347
 348 /**
 349  *      set_termios             -       set termios values for a tty
 350  *      @tty: terminal device
 351  *      @arg: user data
 352  *      @opt: option information
 353  *
 354  *      Helper function to prepare termios data and run necessary other
 355  *      functions before using tty_set_termios to do the actual changes.
 356  *
 357  *      Locking:
 358  *              Called functions take ldisc and termios_rwsem locks
 359  */
 360
 361 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
 362 {
 363         struct ktermios tmp_termios;
 364         struct tty_ldisc *ld;
 365         int retval = tty_check_change(tty);
 366
 367         if (retval)
 368                 return retval;
 369
 370         down_read(&tty->termios_rwsem);
 371         tmp_termios = tty->termios;
 372         up_read(&tty->termios_rwsem);
 373
 374         if (opt & TERMIOS_TERMIO) {
 375                 if (user_termio_to_kernel_termios(&tmp_termios,
 376                                                 (struct termio __user *)arg))
 377                         return -EFAULT;
 378 #ifdef TCGETS2
 379         } else if (opt & TERMIOS_OLD) {
 380                 if (user_termios_to_kernel_termios_1(&tmp_termios,
 381                                                 (struct termios __user *)arg))
 382                         return -EFAULT;
 383         } else {
 384                 if (user_termios_to_kernel_termios(&tmp_termios,
 385                                                 (struct termios2 __user *)arg))
 386                         return -EFAULT;
 387         }
 388 #else
 389         } else if (user_termios_to_kernel_termios(&tmp_termios,
 390                                         (struct termios __user *)arg))
 391                 return -EFAULT;
 392 #endif
 393
 394         /* If old style Bfoo values are used then load c_ispeed/c_ospeed
 395          * with the real speed so its unconditionally usable */
 396         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
 397         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
 398
 399         ld = tty_ldisc_ref(tty);
 400
 401         if (ld != NULL) {
 402                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 403                         ld->ops->flush_buffer(tty);
 404                 tty_ldisc_deref(ld);
 405         }
 406
 407         if (opt & TERMIOS_WAIT) {
 408                 tty_wait_until_sent(tty, 0);
 409                 if (signal_pending(current))
 410                         return -ERESTARTSYS;
 411         }
 412
 413         tty_set_termios(tty, &tmp_termios);
 414
 415         /* FIXME: Arguably if tmp_termios == tty->termios AND the
 416            actual requested termios was not tmp_termios then we may
 417            want to return an error as no user requested change has
 418            succeeded */
 419         return 0;
 420 }
 421
 422 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
 423 {
 424         down_read(&tty->termios_rwsem);
 425         *kterm = tty->termios;
 426         up_read(&tty->termios_rwsem);
 427 }
 428
 429 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
 430 {
 431         down_read(&tty->termios_rwsem);
 432         *kterm = tty->termios_locked;
 433         up_read(&tty->termios_rwsem);
 434 }
 435
 436 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
 437 {
 438         struct ktermios kterm;
 439         copy_termios(tty, &kterm);
 440         if (kernel_termios_to_user_termio(termio, &kterm))
 441                 return -EFAULT;
 442         return 0;
 443 }
 444
 445
 446 #ifdef TCGETX
 447
 448 /**
 449  *      set_termiox     -       set termiox fields if possible
 450  *      @tty: terminal
 451  *      @arg: termiox structure from user
 452  *      @opt: option flags for ioctl type
 453  *
 454  *      Implement the device calling points for the SYS5 termiox ioctl
 455  *      interface in Linux
 456  */
 457
 458 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
 459 {
 460         struct termiox tnew;
 461         struct tty_ldisc *ld;
 462
 463         if (tty->termiox == NULL)
 464                 return -EINVAL;
 465         if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
 466                 return -EFAULT;
 467
 468         ld = tty_ldisc_ref(tty);
 469         if (ld != NULL) {
 470                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 471                         ld->ops->flush_buffer(tty);
 472                 tty_ldisc_deref(ld);
 473         }
 474         if (opt & TERMIOS_WAIT) {
 475                 tty_wait_until_sent(tty, 0);
 476                 if (signal_pending(current))
 477                         return -ERESTARTSYS;
 478         }
 479
 480         down_write(&tty->termios_rwsem);
 481         if (tty->ops->set_termiox)
 482                 tty->ops->set_termiox(tty, &tnew);
 483         up_write(&tty->termios_rwsem);
 484         return 0;
 485 }
 486
 487 #endif
 488
 489
 490 #ifdef TIOCGETP
 491 /*
 492  * These are deprecated, but there is limited support..
 493  *
 494  * The "sg_flags" translation is a joke..
 495  */
 496 static int get_sgflags(struct tty_struct *tty)
 497 {
 498         int flags = 0;
 499
 500         if (!L_ICANON(tty)) {
 501                 if (L_ISIG(tty))
 502                         flags |= 0x02;          /* cbreak */
 503                 else
 504                         flags |= 0x20;          /* raw */
 505         }
 506         if (L_ECHO(tty))
 507                 flags |= 0x08;                  /* echo */
 508         if (O_OPOST(tty))
 509                 if (O_ONLCR(tty))
 510                         flags |= 0x10;          /* crmod */
 511         return flags;
 512 }
 513
 514 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 515 {
 516         struct sgttyb tmp;
 517
 518         down_read(&tty->termios_rwsem);
 519         tmp.sg_ispeed = tty->termios.c_ispeed;
 520         tmp.sg_ospeed = tty->termios.c_ospeed;
 521         tmp.sg_erase = tty->termios.c_cc[VERASE];
 522         tmp.sg_kill = tty->termios.c_cc[VKILL];
 523         tmp.sg_flags = get_sgflags(tty);
 524         up_read(&tty->termios_rwsem);
 525
 526         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 527 }
 528
 529 static void set_sgflags(struct ktermios *termios, int flags)
 530 {
 531         termios->c_iflag = ICRNL | IXON;
 532         termios->c_oflag = 0;
 533         termios->c_lflag = ISIG | ICANON;
 534         if (flags & 0x02) {     /* cbreak */
 535                 termios->c_iflag = 0;
 536                 termios->c_lflag &= ~ICANON;
 537         }
 538         if (flags & 0x08) {             /* echo */
 539                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
 540                                     ECHOCTL | ECHOKE | IEXTEN;
 541         }
 542         if (flags & 0x10) {             /* crmod */
 543                 termios->c_oflag |= OPOST | ONLCR;
 544         }
 545         if (flags & 0x20) {     /* raw */
 546                 termios->c_iflag = 0;
 547                 termios->c_lflag &= ~(ISIG | ICANON);
 548         }
 549         if (!(termios->c_lflag & ICANON)) {
 550                 termios->c_cc[VMIN] = 1;
 551                 termios->c_cc[VTIME] = 0;
 552         }
 553 }
 554
 555 /**
 556  *      set_sgttyb              -       set legacy terminal values
 557  *      @tty: tty structure
 558  *      @sgttyb: pointer to old style terminal structure
 559  *
 560  *      Updates a terminal from the legacy BSD style terminal information
 561  *      structure.
 562  *
 563  *      Locking: termios_rwsem
 564  */
 565
 566 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 567 {
 568         int retval;
 569         struct sgttyb tmp;
 570         struct ktermios termios;
 571
 572         retval = tty_check_change(tty);
 573         if (retval)
 574                 return retval;
 575
 576         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
 577                 return -EFAULT;
 578
 579         down_write(&tty->termios_rwsem);
 580         termios = tty->termios;
 581         termios.c_cc[VERASE] = tmp.sg_erase;
 582         termios.c_cc[VKILL] = tmp.sg_kill;
 583         set_sgflags(&termios, tmp.sg_flags);
 584         /* Try and encode into Bfoo format */
 585 #ifdef BOTHER
 586         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
 587                                                 termios.c_ospeed);
 588 #endif
 589         up_write(&tty->termios_rwsem);
 590         tty_set_termios(tty, &termios);
 591         return 0;
 592 }
 593 #endif
 594
 595 #ifdef TIOCGETC
 596 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 597 {
 598         struct tchars tmp;
 599
 600         down_read(&tty->termios_rwsem);
 601         tmp.t_intrc = tty->termios.c_cc[VINTR];
 602         tmp.t_quitc = tty->termios.c_cc[VQUIT];
 603         tmp.t_startc = tty->termios.c_cc[VSTART];
 604         tmp.t_stopc = tty->termios.c_cc[VSTOP];
 605         tmp.t_eofc = tty->termios.c_cc[VEOF];
 606         tmp.t_brkc = tty->termios.c_cc[VEOL2];  /* what is brkc anyway? */
 607         up_read(&tty->termios_rwsem);
 608         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 609 }
 610
 611 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 612 {
 613         struct tchars tmp;
 614
 615         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
 616                 return -EFAULT;
 617         down_write(&tty->termios_rwsem);
 618         tty->termios.c_cc[VINTR] = tmp.t_intrc;
 619         tty->termios.c_cc[VQUIT] = tmp.t_quitc;
 620         tty->termios.c_cc[VSTART] = tmp.t_startc;
 621         tty->termios.c_cc[VSTOP] = tmp.t_stopc;
 622         tty->termios.c_cc[VEOF] = tmp.t_eofc;
 623         tty->termios.c_cc[VEOL2] = tmp.t_brkc;  /* what is brkc anyway? */
 624         up_write(&tty->termios_rwsem);
 625         return 0;
 626 }
 627 #endif
 628
 629 #ifdef TIOCGLTC
 630 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 631 {
 632         struct ltchars tmp;
 633
 634         down_read(&tty->termios_rwsem);
 635         tmp.t_suspc = tty->termios.c_cc[VSUSP];
 636         /* what is dsuspc anyway? */
 637         tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
 638         tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
 639         /* what is flushc anyway? */
 640         tmp.t_flushc = tty->termios.c_cc[VEOL2];
 641         tmp.t_werasc = tty->termios.c_cc[VWERASE];
 642         tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
 643         up_read(&tty->termios_rwsem);
 644         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 645 }
 646
 647 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 648 {
 649         struct ltchars tmp;
 650
 651         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
 652                 return -EFAULT;
 653
 654         down_write(&tty->termios_rwsem);
 655         tty->termios.c_cc[VSUSP] = tmp.t_suspc;
 656         /* what is dsuspc anyway? */
 657         tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
 658         tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
 659         /* what is flushc anyway? */
 660         tty->termios.c_cc[VEOL2] = tmp.t_flushc;
 661         tty->termios.c_cc[VWERASE] = tmp.t_werasc;
 662         tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
 663         up_write(&tty->termios_rwsem);
 664         return 0;
 665 }
 666 #endif
 667
 668 /**
 669  *      tty_change_softcar      -       carrier change ioctl helper
 670  *      @tty: tty to update
 671  *      @arg: enable/disable CLOCAL
 672  *
 673  *      Perform a change to the CLOCAL state and call into the driver
 674  *      layer to make it visible. All done with the termios rwsem
 675  */
 676
 677 static int tty_change_softcar(struct tty_struct *tty, int arg)
 678 {
 679         int ret = 0;
 680         int bit = arg ? CLOCAL : 0;
 681         struct ktermios old;
 682
 683         down_write(&tty->termios_rwsem);
 684         old = tty->termios;
 685         tty->termios.c_cflag &= ~CLOCAL;
 686         tty->termios.c_cflag |= bit;
 687         if (tty->ops->set_termios)
 688                 tty->ops->set_termios(tty, &old);
 689         if (C_CLOCAL(tty) != bit)
 690                 ret = -EINVAL;
 691         up_write(&tty->termios_rwsem);
 692         return ret;
 693 }
 694
 695 /**
 696  *      tty_mode_ioctl          -       mode related ioctls
 697  *      @tty: tty for the ioctl
 698  *      @file: file pointer for the tty
 699  *      @cmd: command
 700  *      @arg: ioctl argument
 701  *
 702  *      Perform non line discipline specific mode control ioctls. This
 703  *      is designed to be called by line disciplines to ensure they provide
 704  *      consistent mode setting.
 705  */
 706
 707 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
 708                         unsigned int cmd, unsigned long arg)
 709 {
 710         struct tty_struct *real_tty;
 711         void __user *p = (void __user *)arg;
 712         int ret = 0;
 713         struct ktermios kterm;
 714
 715         BUG_ON(file == NULL);
 716
 717         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 718             tty->driver->subtype == PTY_TYPE_MASTER)
 719                 real_tty = tty->link;
 720         else
 721                 real_tty = tty;
 722
 723         switch (cmd) {
 724 #ifdef TIOCGETP
 725         case TIOCGETP:
 726                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
 727         case TIOCSETP:
 728         case TIOCSETN:
 729                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
 730 #endif
 731 #ifdef TIOCGETC
 732         case TIOCGETC:
 733                 return get_tchars(real_tty, p);
 734         case TIOCSETC:
 735                 return set_tchars(real_tty, p);
 736 #endif
 737 #ifdef TIOCGLTC
 738         case TIOCGLTC:
 739                 return get_ltchars(real_tty, p);
 740         case TIOCSLTC:
 741                 return set_ltchars(real_tty, p);
 742 #endif
 743         case TCSETSF:
 744                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
 745         case TCSETSW:
 746                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
 747         case TCSETS:
 748                 return set_termios(real_tty, p, TERMIOS_OLD);
 749 #ifndef TCGETS2
 750         case TCGETS:
 751                 copy_termios(real_tty, &kterm);
 752                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
 753                         ret = -EFAULT;
 754                 return ret;
 755 #else
 756         case TCGETS:
 757                 copy_termios(real_tty, &kterm);
 758                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
 759                         ret = -EFAULT;
 760                 return ret;
 761         case TCGETS2:
 762                 copy_termios(real_tty, &kterm);
 763                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
 764                         ret = -EFAULT;
 765                 return ret;
 766         case TCSETSF2:
 767                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
 768         case TCSETSW2:
 769                 return set_termios(real_tty, p, TERMIOS_WAIT);
 770         case TCSETS2:
 771                 return set_termios(real_tty, p, 0);
 772 #endif
 773         case TCGETA:
 774                 return get_termio(real_tty, p);
 775         case TCSETAF:
 776                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
 777         case TCSETAW:
 778                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
 779         case TCSETA:
 780                 return set_termios(real_tty, p, TERMIOS_TERMIO);
 781 #ifndef TCGETS2
 782         case TIOCGLCKTRMIOS:
 783                 copy_termios_locked(real_tty, &kterm);
 784                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
 785                         ret = -EFAULT;
 786                 return ret;
 787         case TIOCSLCKTRMIOS:
 788                 if (!capable(CAP_SYS_ADMIN))
 789                         return -EPERM;
 790                 copy_termios_locked(real_tty, &kterm);
 791                 if (user_termios_to_kernel_termios(&kterm,
 792                                                (struct termios __user *) arg))
 793                         return -EFAULT;
 794                 down_write(&real_tty->termios_rwsem);
 795                 real_tty->termios_locked = kterm;
 796                 up_write(&real_tty->termios_rwsem);
 797                 return 0;
 798 #else
 799         case TIOCGLCKTRMIOS:
 800                 copy_termios_locked(real_tty, &kterm);
 801                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
 802                         ret = -EFAULT;
 803                 return ret;
 804         case TIOCSLCKTRMIOS:
 805                 if (!capable(CAP_SYS_ADMIN))
 806                         return -EPERM;
 807                 copy_termios_locked(real_tty, &kterm);
 808                 if (user_termios_to_kernel_termios_1(&kterm,
 809                                                (struct termios __user *) arg))
 810                         return -EFAULT;
 811                 down_write(&real_tty->termios_rwsem);
 812                 real_tty->termios_locked = kterm;
 813                 up_write(&real_tty->termios_rwsem);
 814                 return ret;
 815 #endif
 816 #ifdef TCGETX
 817         case TCGETX: {
 818                 struct termiox ktermx;
 819                 if (real_tty->termiox == NULL)
 820                         return -EINVAL;
 821                 down_read(&real_tty->termios_rwsem);
 822                 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
 823                 up_read(&real_tty->termios_rwsem);
 824                 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
 825                         ret = -EFAULT;
 826                 return ret;
 827         }
 828         case TCSETX:
 829                 return set_termiox(real_tty, p, 0);
 830         case TCSETXW:
 831                 return set_termiox(real_tty, p, TERMIOS_WAIT);
 832         case TCSETXF:
 833                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
 834 #endif
 835         case TIOCGSOFTCAR:
 836                 copy_termios(real_tty, &kterm);
 837                 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
 838                                                 (int __user *)arg);
 839                 return ret;
 840         case TIOCSSOFTCAR:
 841                 if (get_user(arg, (unsigned int __user *) arg))
 842                         return -EFAULT;
 843                 return tty_change_softcar(real_tty, arg);
 844         default:
 845                 return -ENOIOCTLCMD;
 846         }
 847 }
 848 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
 849
 850
 851 /* Caller guarantees ldisc reference is held */
 852 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
 853 {
 854         struct tty_ldisc *ld = tty->ldisc;
 855
 856         switch (arg) {
 857         case TCIFLUSH:
 858                 if (ld && ld->ops->flush_buffer) {
 859                         ld->ops->flush_buffer(tty);
 860                         tty_unthrottle(tty);
 861                 }
 862                 break;
 863         case TCIOFLUSH:
 864                 if (ld && ld->ops->flush_buffer) {
 865                         ld->ops->flush_buffer(tty);
 866                         tty_unthrottle(tty);
 867                 }
 868                 /* fall through */
 869         case TCOFLUSH:
 870                 tty_driver_flush_buffer(tty);
 871                 break;
 872         default:
 873                 return -EINVAL;
 874         }
 875         return 0;
 876 }
 877
 878 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
 879 {
 880         struct tty_ldisc *ld;
 881         int retval = tty_check_change(tty);
 882         if (retval)
 883                 return retval;
 884
 885         ld = tty_ldisc_ref_wait(tty);
 886         retval = __tty_perform_flush(tty, arg);
 887         if (ld)
 888                 tty_ldisc_deref(ld);
 889         return retval;
 890 }
 891 EXPORT_SYMBOL_GPL(tty_perform_flush);
 892
 893 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
 894                        unsigned int cmd, unsigned long arg)
 895 {
 896         int retval;
 897
 898         switch (cmd) {
 899         case TCXONC:
 900                 retval = tty_check_change(tty);
 901                 if (retval)
 902                         return retval;
 903                 switch (arg) {
 904                 case TCOOFF:
 905                         spin_lock_irq(&tty->flow_lock);
 906                         if (!tty->flow_stopped) {
 907                                 tty->flow_stopped = 1;
 908                                 __stop_tty(tty);
 909                         }
 910                         spin_unlock_irq(&tty->flow_lock);
 911                         break;
 912                 case TCOON:
 913                         spin_lock_irq(&tty->flow_lock);
 914                         if (tty->flow_stopped) {
 915                                 tty->flow_stopped = 0;
 916                                 __start_tty(tty);
 917                         }
 918                         spin_unlock_irq(&tty->flow_lock);
 919                         break;
 920                 case TCIOFF:
 921                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
 922                                 retval = tty_send_xchar(tty, STOP_CHAR(tty));
 923                         break;
 924                 case TCION:
 925                         if (START_CHAR(tty) != __DISABLED_CHAR)
 926                                 retval = tty_send_xchar(tty, START_CHAR(tty));
 927                         break;
 928                 default:
 929                         return -EINVAL;
 930                 }
 931                 return retval;
 932         case TCFLSH:
 933                 retval = tty_check_change(tty);
 934                 if (retval)
 935                         return retval;
 936                 return __tty_perform_flush(tty, arg);
 937         default:
 938                 /* Try the mode commands */
 939                 return tty_mode_ioctl(tty, file, cmd, arg);
 940         }
 941 }
 942 EXPORT_SYMBOL(n_tty_ioctl_helper);
 943
 944 #ifdef CONFIG_COMPAT
 945 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
 946                                         unsigned int cmd, unsigned long arg)
 947 {
 948         switch (cmd) {
 949         case TIOCGLCKTRMIOS:
 950         case TIOCSLCKTRMIOS:
 951                 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
 952         default:
 953                 return -ENOIOCTLCMD;
 954         }
 955 }
 956 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
 957 #endif
 958