drivers/tty/tty_ioctl.c

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