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         if (opt & (TERMIOS_FLUSH|TERMIOS_WAIT)) {
 400 retry_write_wait:
 401                 retval = wait_event_interruptible(tty->write_wait, !tty_chars_in_buffer(tty));
 402                 if (retval < 0)
 403                         return retval;
 404
 405                 if (tty_write_lock(tty, 0) < 0)
 406                         goto retry_write_wait;
 407
 408                 /* Racing writer? */
 409                 if (tty_chars_in_buffer(tty)) {
 410                         tty_write_unlock(tty);
 411                         goto retry_write_wait;
 412                 }
 413
 414                 ld = tty_ldisc_ref(tty);
 415                 if (ld != NULL) {
 416                         if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 417                                 ld->ops->flush_buffer(tty);
 418                         tty_ldisc_deref(ld);
 419                 }
 420
 421                 if ((opt & TERMIOS_WAIT) && tty->ops->wait_until_sent) {
 422                         tty->ops->wait_until_sent(tty, 0);
 423                         if (signal_pending(current)) {
 424                                 tty_write_unlock(tty);
 425                                 return -ERESTARTSYS;
 426                         }
 427                 }
 428
 429                 tty_set_termios(tty, &tmp_termios);
 430
 431                 tty_write_unlock(tty);
 432         } else {
 433                 tty_set_termios(tty, &tmp_termios);
 434         }
 435
 436         /* FIXME: Arguably if tmp_termios == tty->termios AND the
 437            actual requested termios was not tmp_termios then we may
 438            want to return an error as no user requested change has
 439            succeeded */
 440         return 0;
 441 }
 442
 443 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
 444 {
 445         down_read(&tty->termios_rwsem);
 446         *kterm = tty->termios;
 447         up_read(&tty->termios_rwsem);
 448 }
 449
 450 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
 451 {
 452         down_read(&tty->termios_rwsem);
 453         *kterm = tty->termios_locked;
 454         up_read(&tty->termios_rwsem);
 455 }
 456
 457 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
 458 {
 459         struct ktermios kterm;
 460         copy_termios(tty, &kterm);
 461         if (kernel_termios_to_user_termio(termio, &kterm))
 462                 return -EFAULT;
 463         return 0;
 464 }
 465
 466
 467 #ifdef TCGETX
 468
 469 /**
 470  *      set_termiox     -       set termiox fields if possible
 471  *      @tty: terminal
 472  *      @arg: termiox structure from user
 473  *      @opt: option flags for ioctl type
 474  *
 475  *      Implement the device calling points for the SYS5 termiox ioctl
 476  *      interface in Linux
 477  */
 478
 479 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
 480 {
 481         struct termiox tnew;
 482         struct tty_ldisc *ld;
 483
 484         if (tty->termiox == NULL)
 485                 return -EINVAL;
 486         if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
 487                 return -EFAULT;
 488
 489         ld = tty_ldisc_ref(tty);
 490         if (ld != NULL) {
 491                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
 492                         ld->ops->flush_buffer(tty);
 493                 tty_ldisc_deref(ld);
 494         }
 495         if (opt & TERMIOS_WAIT) {
 496                 tty_wait_until_sent(tty, 0);
 497                 if (signal_pending(current))
 498                         return -ERESTARTSYS;
 499         }
 500
 501         down_write(&tty->termios_rwsem);
 502         if (tty->ops->set_termiox)
 503                 tty->ops->set_termiox(tty, &tnew);
 504         up_write(&tty->termios_rwsem);
 505         return 0;
 506 }
 507
 508 #endif
 509
 510
 511 #ifdef TIOCGETP
 512 /*
 513  * These are deprecated, but there is limited support..
 514  *
 515  * The "sg_flags" translation is a joke..
 516  */
 517 static int get_sgflags(struct tty_struct *tty)
 518 {
 519         int flags = 0;
 520
 521         if (!L_ICANON(tty)) {
 522                 if (L_ISIG(tty))
 523                         flags |= 0x02;          /* cbreak */
 524                 else
 525                         flags |= 0x20;          /* raw */
 526         }
 527         if (L_ECHO(tty))
 528                 flags |= 0x08;                  /* echo */
 529         if (O_OPOST(tty))
 530                 if (O_ONLCR(tty))
 531                         flags |= 0x10;          /* crmod */
 532         return flags;
 533 }
 534
 535 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 536 {
 537         struct sgttyb tmp;
 538
 539         down_read(&tty->termios_rwsem);
 540         tmp.sg_ispeed = tty->termios.c_ispeed;
 541         tmp.sg_ospeed = tty->termios.c_ospeed;
 542         tmp.sg_erase = tty->termios.c_cc[VERASE];
 543         tmp.sg_kill = tty->termios.c_cc[VKILL];
 544         tmp.sg_flags = get_sgflags(tty);
 545         up_read(&tty->termios_rwsem);
 546
 547         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 548 }
 549
 550 static void set_sgflags(struct ktermios *termios, int flags)
 551 {
 552         termios->c_iflag = ICRNL | IXON;
 553         termios->c_oflag = 0;
 554         termios->c_lflag = ISIG | ICANON;
 555         if (flags & 0x02) {     /* cbreak */
 556                 termios->c_iflag = 0;
 557                 termios->c_lflag &= ~ICANON;
 558         }
 559         if (flags & 0x08) {             /* echo */
 560                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
 561                                     ECHOCTL | ECHOKE | IEXTEN;
 562         }
 563         if (flags & 0x10) {             /* crmod */
 564                 termios->c_oflag |= OPOST | ONLCR;
 565         }
 566         if (flags & 0x20) {     /* raw */
 567                 termios->c_iflag = 0;
 568                 termios->c_lflag &= ~(ISIG | ICANON);
 569         }
 570         if (!(termios->c_lflag & ICANON)) {
 571                 termios->c_cc[VMIN] = 1;
 572                 termios->c_cc[VTIME] = 0;
 573         }
 574 }
 575
 576 /**
 577  *      set_sgttyb              -       set legacy terminal values
 578  *      @tty: tty structure
 579  *      @sgttyb: pointer to old style terminal structure
 580  *
 581  *      Updates a terminal from the legacy BSD style terminal information
 582  *      structure.
 583  *
 584  *      Locking: termios_rwsem
 585  */
 586
 587 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
 588 {
 589         int retval;
 590         struct sgttyb tmp;
 591         struct ktermios termios;
 592
 593         retval = tty_check_change(tty);
 594         if (retval)
 595                 return retval;
 596
 597         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
 598                 return -EFAULT;
 599
 600         down_write(&tty->termios_rwsem);
 601         termios = tty->termios;
 602         termios.c_cc[VERASE] = tmp.sg_erase;
 603         termios.c_cc[VKILL] = tmp.sg_kill;
 604         set_sgflags(&termios, tmp.sg_flags);
 605         /* Try and encode into Bfoo format */
 606 #ifdef BOTHER
 607         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
 608                                                 termios.c_ospeed);
 609 #endif
 610         up_write(&tty->termios_rwsem);
 611         tty_set_termios(tty, &termios);
 612         return 0;
 613 }
 614 #endif
 615
 616 #ifdef TIOCGETC
 617 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 618 {
 619         struct tchars tmp;
 620
 621         down_read(&tty->termios_rwsem);
 622         tmp.t_intrc = tty->termios.c_cc[VINTR];
 623         tmp.t_quitc = tty->termios.c_cc[VQUIT];
 624         tmp.t_startc = tty->termios.c_cc[VSTART];
 625         tmp.t_stopc = tty->termios.c_cc[VSTOP];
 626         tmp.t_eofc = tty->termios.c_cc[VEOF];
 627         tmp.t_brkc = tty->termios.c_cc[VEOL2];  /* what is brkc anyway? */
 628         up_read(&tty->termios_rwsem);
 629         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 630 }
 631
 632 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
 633 {
 634         struct tchars tmp;
 635
 636         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
 637                 return -EFAULT;
 638         down_write(&tty->termios_rwsem);
 639         tty->termios.c_cc[VINTR] = tmp.t_intrc;
 640         tty->termios.c_cc[VQUIT] = tmp.t_quitc;
 641         tty->termios.c_cc[VSTART] = tmp.t_startc;
 642         tty->termios.c_cc[VSTOP] = tmp.t_stopc;
 643         tty->termios.c_cc[VEOF] = tmp.t_eofc;
 644         tty->termios.c_cc[VEOL2] = tmp.t_brkc;  /* what is brkc anyway? */
 645         up_write(&tty->termios_rwsem);
 646         return 0;
 647 }
 648 #endif
 649
 650 #ifdef TIOCGLTC
 651 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 652 {
 653         struct ltchars tmp;
 654
 655         down_read(&tty->termios_rwsem);
 656         tmp.t_suspc = tty->termios.c_cc[VSUSP];
 657         /* what is dsuspc anyway? */
 658         tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
 659         tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
 660         /* what is flushc anyway? */
 661         tmp.t_flushc = tty->termios.c_cc[VEOL2];
 662         tmp.t_werasc = tty->termios.c_cc[VWERASE];
 663         tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
 664         up_read(&tty->termios_rwsem);
 665         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 666 }
 667
 668 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
 669 {
 670         struct ltchars tmp;
 671
 672         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
 673                 return -EFAULT;
 674
 675         down_write(&tty->termios_rwsem);
 676         tty->termios.c_cc[VSUSP] = tmp.t_suspc;
 677         /* what is dsuspc anyway? */
 678         tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
 679         tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
 680         /* what is flushc anyway? */
 681         tty->termios.c_cc[VEOL2] = tmp.t_flushc;
 682         tty->termios.c_cc[VWERASE] = tmp.t_werasc;
 683         tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
 684         up_write(&tty->termios_rwsem);
 685         return 0;
 686 }
 687 #endif
 688
 689 /**
 690  *      tty_change_softcar      -       carrier change ioctl helper
 691  *      @tty: tty to update
 692  *      @arg: enable/disable CLOCAL
 693  *
 694  *      Perform a change to the CLOCAL state and call into the driver
 695  *      layer to make it visible. All done with the termios rwsem
 696  */
 697
 698 static int tty_change_softcar(struct tty_struct *tty, int arg)
 699 {
 700         int ret = 0;
 701         int bit = arg ? CLOCAL : 0;
 702         struct ktermios old;
 703
 704         down_write(&tty->termios_rwsem);
 705         old = tty->termios;
 706         tty->termios.c_cflag &= ~CLOCAL;
 707         tty->termios.c_cflag |= bit;
 708         if (tty->ops->set_termios)
 709                 tty->ops->set_termios(tty, &old);
 710         if (C_CLOCAL(tty) != bit)
 711                 ret = -EINVAL;
 712         up_write(&tty->termios_rwsem);
 713         return ret;
 714 }
 715
 716 /**
 717  *      tty_mode_ioctl          -       mode related ioctls
 718  *      @tty: tty for the ioctl
 719  *      @file: file pointer for the tty
 720  *      @cmd: command
 721  *      @arg: ioctl argument
 722  *
 723  *      Perform non line discipline specific mode control ioctls. This
 724  *      is designed to be called by line disciplines to ensure they provide
 725  *      consistent mode setting.
 726  */
 727
 728 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
 729                         unsigned int cmd, unsigned long arg)
 730 {
 731         struct tty_struct *real_tty;
 732         void __user *p = (void __user *)arg;
 733         int ret = 0;
 734         struct ktermios kterm;
 735
 736         BUG_ON(file == NULL);
 737
 738         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 739             tty->driver->subtype == PTY_TYPE_MASTER)
 740                 real_tty = tty->link;
 741         else
 742                 real_tty = tty;
 743
 744         switch (cmd) {
 745 #ifdef TIOCGETP
 746         case TIOCGETP:
 747                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
 748         case TIOCSETP:
 749         case TIOCSETN:
 750                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
 751 #endif
 752 #ifdef TIOCGETC
 753         case TIOCGETC:
 754                 return get_tchars(real_tty, p);
 755         case TIOCSETC:
 756                 return set_tchars(real_tty, p);
 757 #endif
 758 #ifdef TIOCGLTC
 759         case TIOCGLTC:
 760                 return get_ltchars(real_tty, p);
 761         case TIOCSLTC:
 762                 return set_ltchars(real_tty, p);
 763 #endif
 764         case TCSETSF:
 765                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
 766         case TCSETSW:
 767                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
 768         case TCSETS:
 769                 return set_termios(real_tty, p, TERMIOS_OLD);
 770 #ifndef TCGETS2
 771         case TCGETS:
 772                 copy_termios(real_tty, &kterm);
 773                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
 774                         ret = -EFAULT;
 775                 return ret;
 776 #else
 777         case TCGETS:
 778                 copy_termios(real_tty, &kterm);
 779                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
 780                         ret = -EFAULT;
 781                 return ret;
 782         case TCGETS2:
 783                 copy_termios(real_tty, &kterm);
 784                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
 785                         ret = -EFAULT;
 786                 return ret;
 787         case TCSETSF2:
 788                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
 789         case TCSETSW2:
 790                 return set_termios(real_tty, p, TERMIOS_WAIT);
 791         case TCSETS2:
 792                 return set_termios(real_tty, p, 0);
 793 #endif
 794         case TCGETA:
 795                 return get_termio(real_tty, p);
 796         case TCSETAF:
 797                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
 798         case TCSETAW:
 799                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
 800         case TCSETA:
 801                 return set_termios(real_tty, p, TERMIOS_TERMIO);
 802 #ifndef TCGETS2
 803         case TIOCGLCKTRMIOS:
 804                 copy_termios_locked(real_tty, &kterm);
 805                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
 806                         ret = -EFAULT;
 807                 return ret;
 808         case TIOCSLCKTRMIOS:
 809                 if (!capable(CAP_SYS_ADMIN))
 810                         return -EPERM;
 811                 copy_termios_locked(real_tty, &kterm);
 812                 if (user_termios_to_kernel_termios(&kterm,
 813                                                (struct termios __user *) arg))
 814                         return -EFAULT;
 815                 down_write(&real_tty->termios_rwsem);
 816                 real_tty->termios_locked = kterm;
 817                 up_write(&real_tty->termios_rwsem);
 818                 return 0;
 819 #else
 820         case TIOCGLCKTRMIOS:
 821                 copy_termios_locked(real_tty, &kterm);
 822                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
 823                         ret = -EFAULT;
 824                 return ret;
 825         case TIOCSLCKTRMIOS:
 826                 if (!capable(CAP_SYS_ADMIN))
 827                         return -EPERM;
 828                 copy_termios_locked(real_tty, &kterm);
 829                 if (user_termios_to_kernel_termios_1(&kterm,
 830                                                (struct termios __user *) arg))
 831                         return -EFAULT;
 832                 down_write(&real_tty->termios_rwsem);
 833                 real_tty->termios_locked = kterm;
 834                 up_write(&real_tty->termios_rwsem);
 835                 return ret;
 836 #endif
 837 #ifdef TCGETX
 838         case TCGETX: {
 839                 struct termiox ktermx;
 840                 if (real_tty->termiox == NULL)
 841                         return -EINVAL;
 842                 down_read(&real_tty->termios_rwsem);
 843                 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
 844                 up_read(&real_tty->termios_rwsem);
 845                 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
 846                         ret = -EFAULT;
 847                 return ret;
 848         }
 849         case TCSETX:
 850                 return set_termiox(real_tty, p, 0);
 851         case TCSETXW:
 852                 return set_termiox(real_tty, p, TERMIOS_WAIT);
 853         case TCSETXF:
 854                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
 855 #endif
 856         case TIOCGSOFTCAR:
 857                 copy_termios(real_tty, &kterm);
 858                 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
 859                                                 (int __user *)arg);
 860                 return ret;
 861         case TIOCSSOFTCAR:
 862                 if (get_user(arg, (unsigned int __user *) arg))
 863                         return -EFAULT;
 864                 return tty_change_softcar(real_tty, arg);
 865         default:
 866                 return -ENOIOCTLCMD;
 867         }
 868 }
 869 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
 870
 871
 872 /* Caller guarantees ldisc reference is held */
 873 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
 874 {
 875         struct tty_ldisc *ld = tty->ldisc;
 876
 877         switch (arg) {
 878         case TCIFLUSH:
 879                 if (ld && ld->ops->flush_buffer) {
 880                         ld->ops->flush_buffer(tty);
 881                         tty_unthrottle(tty);
 882                 }
 883                 break;
 884         case TCIOFLUSH:
 885                 if (ld && ld->ops->flush_buffer) {
 886                         ld->ops->flush_buffer(tty);
 887                         tty_unthrottle(tty);
 888                 }
 889                 /* fall through */
 890         case TCOFLUSH:
 891                 tty_driver_flush_buffer(tty);
 892                 break;
 893         default:
 894                 return -EINVAL;
 895         }
 896         return 0;
 897 }
 898
 899 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
 900 {
 901         struct tty_ldisc *ld;
 902         int retval = tty_check_change(tty);
 903         if (retval)
 904                 return retval;
 905
 906         ld = tty_ldisc_ref_wait(tty);
 907         retval = __tty_perform_flush(tty, arg);
 908         if (ld)
 909                 tty_ldisc_deref(ld);
 910         return retval;
 911 }
 912 EXPORT_SYMBOL_GPL(tty_perform_flush);
 913
 914 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
 915                        unsigned int cmd, unsigned long arg)
 916 {
 917         int retval;
 918
 919         switch (cmd) {
 920         case TCXONC:
 921                 retval = tty_check_change(tty);
 922                 if (retval)
 923                         return retval;
 924                 switch (arg) {
 925                 case TCOOFF:
 926                         spin_lock_irq(&tty->flow_lock);
 927                         if (!tty->flow_stopped) {
 928                                 tty->flow_stopped = 1;
 929                                 __stop_tty(tty);
 930                         }
 931                         spin_unlock_irq(&tty->flow_lock);
 932                         break;
 933                 case TCOON:
 934                         spin_lock_irq(&tty->flow_lock);
 935                         if (tty->flow_stopped) {
 936                                 tty->flow_stopped = 0;
 937                                 __start_tty(tty);
 938                         }
 939                         spin_unlock_irq(&tty->flow_lock);
 940                         break;
 941                 case TCIOFF:
 942                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
 943                                 retval = tty_send_xchar(tty, STOP_CHAR(tty));
 944                         break;
 945                 case TCION:
 946                         if (START_CHAR(tty) != __DISABLED_CHAR)
 947                                 retval = tty_send_xchar(tty, START_CHAR(tty));
 948                         break;
 949                 default:
 950                         return -EINVAL;
 951                 }
 952                 return retval;
 953         case TCFLSH:
 954                 retval = tty_check_change(tty);
 955                 if (retval)
 956                         return retval;
 957                 return __tty_perform_flush(tty, arg);
 958         default:
 959                 /* Try the mode commands */
 960                 return tty_mode_ioctl(tty, file, cmd, arg);
 961         }
 962 }
 963 EXPORT_SYMBOL(n_tty_ioctl_helper);
 964
 965 #ifdef CONFIG_COMPAT
 966 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
 967                                         unsigned int cmd, unsigned long arg)
 968 {
 969         switch (cmd) {
 970         case TIOCGLCKTRMIOS:
 971         case TIOCSLCKTRMIOS:
 972                 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
 973         default:
 974                 return -ENOIOCTLCMD;
 975         }
 976 }
 977 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
 978 #endif
 979