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