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