1 /* 2 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds 3 * 4 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines 5 * which can be dynamically activated and de-activated by the line 6 * discipline handling modules (like SLIP). 7 */ 8 9 #include <linux/types.h> 10 #include <linux/termios.h> 11 #include <linux/errno.h> 12 #include <linux/sched/signal.h> 13 #include <linux/kernel.h> 14 #include <linux/major.h> 15 #include <linux/tty.h> 16 #include <linux/fcntl.h> 17 #include <linux/string.h> 18 #include <linux/mm.h> 19 #include <linux/module.h> 20 #include <linux/bitops.h> 21 #include <linux/mutex.h> 22 #include <linux/compat.h> 23 24 #include <asm/io.h> 25 #include <linux/uaccess.h> 26 27 #undef TTY_DEBUG_WAIT_UNTIL_SENT 28 29 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT 30 # define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args) 31 #else 32 # define tty_debug_wait_until_sent(tty, f, args...) do {} while (0) 33 #endif 34 35 #undef DEBUG 36 37 /* 38 * Internal flag options for termios setting behavior 39 */ 40 #define TERMIOS_FLUSH 1 41 #define TERMIOS_WAIT 2 42 #define TERMIOS_TERMIO 4 43 #define TERMIOS_OLD 8 44 45 46 /** 47 * tty_chars_in_buffer - characters pending 48 * @tty: terminal 49 * 50 * Return the number of bytes of data in the device private 51 * output queue. If no private method is supplied there is assumed 52 * to be no queue on the device. 53 */ 54 55 int tty_chars_in_buffer(struct tty_struct *tty) 56 { 57 if (tty->ops->chars_in_buffer) 58 return tty->ops->chars_in_buffer(tty); 59 else 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(struct ktermios *a, 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 446 #ifdef TCGETX 447 448 /** 449 * set_termiox - set termiox fields if possible 450 * @tty: terminal 451 * @arg: termiox structure from user 452 * @opt: option flags for ioctl type 453 * 454 * Implement the device calling points for the SYS5 termiox ioctl 455 * interface in Linux 456 */ 457 458 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt) 459 { 460 struct termiox tnew; 461 struct tty_ldisc *ld; 462 463 if (tty->termiox == NULL) 464 return -EINVAL; 465 if (copy_from_user(&tnew, arg, sizeof(struct termiox))) 466 return -EFAULT; 467 468 ld = tty_ldisc_ref(tty); 469 if (ld != NULL) { 470 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer) 471 ld->ops->flush_buffer(tty); 472 tty_ldisc_deref(ld); 473 } 474 if (opt & TERMIOS_WAIT) { 475 tty_wait_until_sent(tty, 0); 476 if (signal_pending(current)) 477 return -ERESTARTSYS; 478 } 479 480 down_write(&tty->termios_rwsem); 481 if (tty->ops->set_termiox) 482 tty->ops->set_termiox(tty, &tnew); 483 up_write(&tty->termios_rwsem); 484 return 0; 485 } 486 487 #endif 488 489 490 #ifdef TIOCGETP 491 /* 492 * These are deprecated, but there is limited support.. 493 * 494 * The "sg_flags" translation is a joke.. 495 */ 496 static int get_sgflags(struct tty_struct *tty) 497 { 498 int flags = 0; 499 500 if (!L_ICANON(tty)) { 501 if (L_ISIG(tty)) 502 flags |= 0x02; /* cbreak */ 503 else 504 flags |= 0x20; /* raw */ 505 } 506 if (L_ECHO(tty)) 507 flags |= 0x08; /* echo */ 508 if (O_OPOST(tty)) 509 if (O_ONLCR(tty)) 510 flags |= 0x10; /* crmod */ 511 return flags; 512 } 513 514 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb) 515 { 516 struct sgttyb tmp; 517 518 down_read(&tty->termios_rwsem); 519 tmp.sg_ispeed = tty->termios.c_ispeed; 520 tmp.sg_ospeed = tty->termios.c_ospeed; 521 tmp.sg_erase = tty->termios.c_cc[VERASE]; 522 tmp.sg_kill = tty->termios.c_cc[VKILL]; 523 tmp.sg_flags = get_sgflags(tty); 524 up_read(&tty->termios_rwsem); 525 526 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0; 527 } 528 529 static void set_sgflags(struct ktermios *termios, int flags) 530 { 531 termios->c_iflag = ICRNL | IXON; 532 termios->c_oflag = 0; 533 termios->c_lflag = ISIG | ICANON; 534 if (flags & 0x02) { /* cbreak */ 535 termios->c_iflag = 0; 536 termios->c_lflag &= ~ICANON; 537 } 538 if (flags & 0x08) { /* echo */ 539 termios->c_lflag |= ECHO | ECHOE | ECHOK | 540 ECHOCTL | ECHOKE | IEXTEN; 541 } 542 if (flags & 0x10) { /* crmod */ 543 termios->c_oflag |= OPOST | ONLCR; 544 } 545 if (flags & 0x20) { /* raw */ 546 termios->c_iflag = 0; 547 termios->c_lflag &= ~(ISIG | ICANON); 548 } 549 if (!(termios->c_lflag & ICANON)) { 550 termios->c_cc[VMIN] = 1; 551 termios->c_cc[VTIME] = 0; 552 } 553 } 554 555 /** 556 * set_sgttyb - set legacy terminal values 557 * @tty: tty structure 558 * @sgttyb: pointer to old style terminal structure 559 * 560 * Updates a terminal from the legacy BSD style terminal information 561 * structure. 562 * 563 * Locking: termios_rwsem 564 */ 565 566 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb) 567 { 568 int retval; 569 struct sgttyb tmp; 570 struct ktermios termios; 571 572 retval = tty_check_change(tty); 573 if (retval) 574 return retval; 575 576 if (copy_from_user(&tmp, sgttyb, sizeof(tmp))) 577 return -EFAULT; 578 579 down_write(&tty->termios_rwsem); 580 termios = tty->termios; 581 termios.c_cc[VERASE] = tmp.sg_erase; 582 termios.c_cc[VKILL] = tmp.sg_kill; 583 set_sgflags(&termios, tmp.sg_flags); 584 /* Try and encode into Bfoo format */ 585 #ifdef BOTHER 586 tty_termios_encode_baud_rate(&termios, termios.c_ispeed, 587 termios.c_ospeed); 588 #endif 589 up_write(&tty->termios_rwsem); 590 tty_set_termios(tty, &termios); 591 return 0; 592 } 593 #endif 594 595 #ifdef TIOCGETC 596 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars) 597 { 598 struct tchars tmp; 599 600 down_read(&tty->termios_rwsem); 601 tmp.t_intrc = tty->termios.c_cc[VINTR]; 602 tmp.t_quitc = tty->termios.c_cc[VQUIT]; 603 tmp.t_startc = tty->termios.c_cc[VSTART]; 604 tmp.t_stopc = tty->termios.c_cc[VSTOP]; 605 tmp.t_eofc = tty->termios.c_cc[VEOF]; 606 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */ 607 up_read(&tty->termios_rwsem); 608 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0; 609 } 610 611 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars) 612 { 613 struct tchars tmp; 614 615 if (copy_from_user(&tmp, tchars, sizeof(tmp))) 616 return -EFAULT; 617 down_write(&tty->termios_rwsem); 618 tty->termios.c_cc[VINTR] = tmp.t_intrc; 619 tty->termios.c_cc[VQUIT] = tmp.t_quitc; 620 tty->termios.c_cc[VSTART] = tmp.t_startc; 621 tty->termios.c_cc[VSTOP] = tmp.t_stopc; 622 tty->termios.c_cc[VEOF] = tmp.t_eofc; 623 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */ 624 up_write(&tty->termios_rwsem); 625 return 0; 626 } 627 #endif 628 629 #ifdef TIOCGLTC 630 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars) 631 { 632 struct ltchars tmp; 633 634 down_read(&tty->termios_rwsem); 635 tmp.t_suspc = tty->termios.c_cc[VSUSP]; 636 /* what is dsuspc anyway? */ 637 tmp.t_dsuspc = tty->termios.c_cc[VSUSP]; 638 tmp.t_rprntc = tty->termios.c_cc[VREPRINT]; 639 /* what is flushc anyway? */ 640 tmp.t_flushc = tty->termios.c_cc[VEOL2]; 641 tmp.t_werasc = tty->termios.c_cc[VWERASE]; 642 tmp.t_lnextc = tty->termios.c_cc[VLNEXT]; 643 up_read(&tty->termios_rwsem); 644 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0; 645 } 646 647 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars) 648 { 649 struct ltchars tmp; 650 651 if (copy_from_user(&tmp, ltchars, sizeof(tmp))) 652 return -EFAULT; 653 654 down_write(&tty->termios_rwsem); 655 tty->termios.c_cc[VSUSP] = tmp.t_suspc; 656 /* what is dsuspc anyway? */ 657 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc; 658 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc; 659 /* what is flushc anyway? */ 660 tty->termios.c_cc[VEOL2] = tmp.t_flushc; 661 tty->termios.c_cc[VWERASE] = tmp.t_werasc; 662 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc; 663 up_write(&tty->termios_rwsem); 664 return 0; 665 } 666 #endif 667 668 /** 669 * tty_change_softcar - carrier change ioctl helper 670 * @tty: tty to update 671 * @arg: enable/disable CLOCAL 672 * 673 * Perform a change to the CLOCAL state and call into the driver 674 * layer to make it visible. All done with the termios rwsem 675 */ 676 677 static int tty_change_softcar(struct tty_struct *tty, int arg) 678 { 679 int ret = 0; 680 int bit = arg ? CLOCAL : 0; 681 struct ktermios old; 682 683 down_write(&tty->termios_rwsem); 684 old = tty->termios; 685 tty->termios.c_cflag &= ~CLOCAL; 686 tty->termios.c_cflag |= bit; 687 if (tty->ops->set_termios) 688 tty->ops->set_termios(tty, &old); 689 if (C_CLOCAL(tty) != bit) 690 ret = -EINVAL; 691 up_write(&tty->termios_rwsem); 692 return ret; 693 } 694 695 /** 696 * tty_mode_ioctl - mode related ioctls 697 * @tty: tty for the ioctl 698 * @file: file pointer for the tty 699 * @cmd: command 700 * @arg: ioctl argument 701 * 702 * Perform non line discipline specific mode control ioctls. This 703 * is designed to be called by line disciplines to ensure they provide 704 * consistent mode setting. 705 */ 706 707 int tty_mode_ioctl(struct tty_struct *tty, struct file *file, 708 unsigned int cmd, unsigned long arg) 709 { 710 struct tty_struct *real_tty; 711 void __user *p = (void __user *)arg; 712 int ret = 0; 713 struct ktermios kterm; 714 715 BUG_ON(file == NULL); 716 717 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 718 tty->driver->subtype == PTY_TYPE_MASTER) 719 real_tty = tty->link; 720 else 721 real_tty = tty; 722 723 switch (cmd) { 724 #ifdef TIOCGETP 725 case TIOCGETP: 726 return get_sgttyb(real_tty, (struct sgttyb __user *) arg); 727 case TIOCSETP: 728 case TIOCSETN: 729 return set_sgttyb(real_tty, (struct sgttyb __user *) arg); 730 #endif 731 #ifdef TIOCGETC 732 case TIOCGETC: 733 return get_tchars(real_tty, p); 734 case TIOCSETC: 735 return set_tchars(real_tty, p); 736 #endif 737 #ifdef TIOCGLTC 738 case TIOCGLTC: 739 return get_ltchars(real_tty, p); 740 case TIOCSLTC: 741 return set_ltchars(real_tty, p); 742 #endif 743 case TCSETSF: 744 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD); 745 case TCSETSW: 746 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD); 747 case TCSETS: 748 return set_termios(real_tty, p, TERMIOS_OLD); 749 #ifndef TCGETS2 750 case TCGETS: 751 copy_termios(real_tty, &kterm); 752 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm)) 753 ret = -EFAULT; 754 return ret; 755 #else 756 case TCGETS: 757 copy_termios(real_tty, &kterm); 758 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm)) 759 ret = -EFAULT; 760 return ret; 761 case TCGETS2: 762 copy_termios(real_tty, &kterm); 763 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm)) 764 ret = -EFAULT; 765 return ret; 766 case TCSETSF2: 767 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT); 768 case TCSETSW2: 769 return set_termios(real_tty, p, TERMIOS_WAIT); 770 case TCSETS2: 771 return set_termios(real_tty, p, 0); 772 #endif 773 case TCGETA: 774 return get_termio(real_tty, p); 775 case TCSETAF: 776 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO); 777 case TCSETAW: 778 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO); 779 case TCSETA: 780 return set_termios(real_tty, p, TERMIOS_TERMIO); 781 #ifndef TCGETS2 782 case TIOCGLCKTRMIOS: 783 copy_termios_locked(real_tty, &kterm); 784 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm)) 785 ret = -EFAULT; 786 return ret; 787 case TIOCSLCKTRMIOS: 788 if (!capable(CAP_SYS_ADMIN)) 789 return -EPERM; 790 copy_termios_locked(real_tty, &kterm); 791 if (user_termios_to_kernel_termios(&kterm, 792 (struct termios __user *) arg)) 793 return -EFAULT; 794 down_write(&real_tty->termios_rwsem); 795 real_tty->termios_locked = kterm; 796 up_write(&real_tty->termios_rwsem); 797 return 0; 798 #else 799 case TIOCGLCKTRMIOS: 800 copy_termios_locked(real_tty, &kterm); 801 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm)) 802 ret = -EFAULT; 803 return ret; 804 case TIOCSLCKTRMIOS: 805 if (!capable(CAP_SYS_ADMIN)) 806 return -EPERM; 807 copy_termios_locked(real_tty, &kterm); 808 if (user_termios_to_kernel_termios_1(&kterm, 809 (struct termios __user *) arg)) 810 return -EFAULT; 811 down_write(&real_tty->termios_rwsem); 812 real_tty->termios_locked = kterm; 813 up_write(&real_tty->termios_rwsem); 814 return ret; 815 #endif 816 #ifdef TCGETX 817 case TCGETX: { 818 struct termiox ktermx; 819 if (real_tty->termiox == NULL) 820 return -EINVAL; 821 down_read(&real_tty->termios_rwsem); 822 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox)); 823 up_read(&real_tty->termios_rwsem); 824 if (copy_to_user(p, &ktermx, sizeof(struct termiox))) 825 ret = -EFAULT; 826 return ret; 827 } 828 case TCSETX: 829 return set_termiox(real_tty, p, 0); 830 case TCSETXW: 831 return set_termiox(real_tty, p, TERMIOS_WAIT); 832 case TCSETXF: 833 return set_termiox(real_tty, p, TERMIOS_FLUSH); 834 #endif 835 case TIOCGSOFTCAR: 836 copy_termios(real_tty, &kterm); 837 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0, 838 (int __user *)arg); 839 return ret; 840 case TIOCSSOFTCAR: 841 if (get_user(arg, (unsigned int __user *) arg)) 842 return -EFAULT; 843 return tty_change_softcar(real_tty, arg); 844 default: 845 return -ENOIOCTLCMD; 846 } 847 } 848 EXPORT_SYMBOL_GPL(tty_mode_ioctl); 849 850 851 /* Caller guarantees ldisc reference is held */ 852 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg) 853 { 854 struct tty_ldisc *ld = tty->ldisc; 855 856 switch (arg) { 857 case TCIFLUSH: 858 if (ld && ld->ops->flush_buffer) { 859 ld->ops->flush_buffer(tty); 860 tty_unthrottle(tty); 861 } 862 break; 863 case TCIOFLUSH: 864 if (ld && ld->ops->flush_buffer) { 865 ld->ops->flush_buffer(tty); 866 tty_unthrottle(tty); 867 } 868 /* fall through */ 869 case TCOFLUSH: 870 tty_driver_flush_buffer(tty); 871 break; 872 default: 873 return -EINVAL; 874 } 875 return 0; 876 } 877 878 int tty_perform_flush(struct tty_struct *tty, unsigned long arg) 879 { 880 struct tty_ldisc *ld; 881 int retval = tty_check_change(tty); 882 if (retval) 883 return retval; 884 885 ld = tty_ldisc_ref_wait(tty); 886 retval = __tty_perform_flush(tty, arg); 887 if (ld) 888 tty_ldisc_deref(ld); 889 return retval; 890 } 891 EXPORT_SYMBOL_GPL(tty_perform_flush); 892 893 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file, 894 unsigned int cmd, unsigned long arg) 895 { 896 int retval; 897 898 switch (cmd) { 899 case TCXONC: 900 retval = tty_check_change(tty); 901 if (retval) 902 return retval; 903 switch (arg) { 904 case TCOOFF: 905 spin_lock_irq(&tty->flow_lock); 906 if (!tty->flow_stopped) { 907 tty->flow_stopped = 1; 908 __stop_tty(tty); 909 } 910 spin_unlock_irq(&tty->flow_lock); 911 break; 912 case TCOON: 913 spin_lock_irq(&tty->flow_lock); 914 if (tty->flow_stopped) { 915 tty->flow_stopped = 0; 916 __start_tty(tty); 917 } 918 spin_unlock_irq(&tty->flow_lock); 919 break; 920 case TCIOFF: 921 if (STOP_CHAR(tty) != __DISABLED_CHAR) 922 retval = tty_send_xchar(tty, STOP_CHAR(tty)); 923 break; 924 case TCION: 925 if (START_CHAR(tty) != __DISABLED_CHAR) 926 retval = tty_send_xchar(tty, START_CHAR(tty)); 927 break; 928 default: 929 return -EINVAL; 930 } 931 return retval; 932 case TCFLSH: 933 retval = tty_check_change(tty); 934 if (retval) 935 return retval; 936 return __tty_perform_flush(tty, arg); 937 default: 938 /* Try the mode commands */ 939 return tty_mode_ioctl(tty, file, cmd, arg); 940 } 941 } 942 EXPORT_SYMBOL(n_tty_ioctl_helper); 943 944 #ifdef CONFIG_COMPAT 945 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file, 946 unsigned int cmd, unsigned long arg) 947 { 948 switch (cmd) { 949 case TIOCGLCKTRMIOS: 950 case TIOCSLCKTRMIOS: 951 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg)); 952 default: 953 return -ENOIOCTLCMD; 954 } 955 } 956 EXPORT_SYMBOL(n_tty_compat_ioctl_helper); 957 #endif 958 959