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); 984