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