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