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.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 <asm/uaccess.h> 26 27#undef TTY_DEBUG_WAIT_UNTIL_SENT 28 29#undef DEBUG 30 31/* 32 * Internal flag options for termios setting behavior 33 */ 34#define TERMIOS_FLUSH 1 35#define TERMIOS_WAIT 2 36#define TERMIOS_TERMIO 4 37#define TERMIOS_OLD 8 38 39 40/** 41 * tty_chars_in_buffer - characters pending 42 * @tty: terminal 43 * 44 * Return the number of bytes of data in the device private 45 * output queue. If no private method is supplied there is assumed 46 * to be no queue on the device. 47 */ 48 49int tty_chars_in_buffer(struct tty_struct *tty) 50{ 51 if (tty->ops->chars_in_buffer) 52 return tty->ops->chars_in_buffer(tty); 53 else 54 return 0; 55} 56EXPORT_SYMBOL(tty_chars_in_buffer); 57 58/** 59 * tty_write_room - write queue space 60 * @tty: terminal 61 * 62 * Return the number of bytes that can be queued to this device 63 * at the present time. The result should be treated as a guarantee 64 * and the driver cannot offer a value it later shrinks by more than 65 * the number of bytes written. If no method is provided 2K is always 66 * returned and data may be lost as there will be no flow control. 67 */ 68 69int tty_write_room(struct tty_struct *tty) 70{ 71 if (tty->ops->write_room) 72 return tty->ops->write_room(tty); 73 return 2048; 74} 75EXPORT_SYMBOL(tty_write_room); 76 77/** 78 * tty_driver_flush_buffer - discard internal buffer 79 * @tty: terminal 80 * 81 * Discard the internal output buffer for this device. If no method 82 * is provided then either the buffer cannot be hardware flushed or 83 * there is no buffer driver side. 84 */ 85void tty_driver_flush_buffer(struct tty_struct *tty) 86{ 87 if (tty->ops->flush_buffer) 88 tty->ops->flush_buffer(tty); 89} 90EXPORT_SYMBOL(tty_driver_flush_buffer); 91 92/** 93 * tty_throttle - flow control 94 * @tty: terminal 95 * 96 * Indicate that a tty should stop transmitting data down the stack. 97 * Takes the termios rwsem to protect against parallel throttle/unthrottle 98 * and also to ensure the driver can consistently reference its own 99 * termios data at this point when implementing software flow control. 100 */ 101 102void tty_throttle(struct tty_struct *tty) 103{ 104 down_write(&tty->termios_rwsem); 105 /* check TTY_THROTTLED first so it indicates our state */ 106 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) && 107 tty->ops->throttle) 108 tty->ops->throttle(tty); 109 tty->flow_change = 0; 110 up_write(&tty->termios_rwsem); 111} 112EXPORT_SYMBOL(tty_throttle); 113 114/** 115 * tty_unthrottle - flow control 116 * @tty: terminal 117 * 118 * Indicate that a tty may continue transmitting data down the stack. 119 * Takes the termios rwsem to protect against parallel throttle/unthrottle 120 * and also to ensure the driver can consistently reference its own 121 * termios data at this point when implementing software flow control. 122 * 123 * Drivers should however remember that the stack can issue a throttle, 124 * then change flow control method, then unthrottle. 125 */ 126 127void tty_unthrottle(struct tty_struct *tty) 128{ 129 down_write(&tty->termios_rwsem); 130 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) && 131 tty->ops->unthrottle) 132 tty->ops->unthrottle(tty); 133 tty->flow_change = 0; 134 up_write(&tty->termios_rwsem); 135} 136EXPORT_SYMBOL(tty_unthrottle); 137 138/** 139 * tty_throttle_safe - flow control 140 * @tty: terminal 141 * 142 * Similar to tty_throttle() but will only attempt throttle 143 * if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental 144 * throttle due to race conditions when throttling is conditional 145 * on factors evaluated prior to throttling. 146 * 147 * Returns 0 if tty is throttled (or was already throttled) 148 */ 149 150int tty_throttle_safe(struct tty_struct *tty) 151{ 152 int ret = 0; 153 154 mutex_lock(&tty->throttle_mutex); 155 if (!test_bit(TTY_THROTTLED, &tty->flags)) { 156 if (tty->flow_change != TTY_THROTTLE_SAFE) 157 ret = 1; 158 else { 159 set_bit(TTY_THROTTLED, &tty->flags); 160 if (tty->ops->throttle) 161 tty->ops->throttle(tty); 162 } 163 } 164 mutex_unlock(&tty->throttle_mutex); 165 166 return ret; 167} 168 169/** 170 * tty_unthrottle_safe - flow control 171 * @tty: terminal 172 * 173 * Similar to tty_unthrottle() but will only attempt unthrottle 174 * if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental 175 * unthrottle due to race conditions when unthrottling is conditional 176 * on factors evaluated prior to unthrottling. 177 * 178 * Returns 0 if tty is unthrottled (or was already unthrottled) 179 */ 180 181int tty_unthrottle_safe(struct tty_struct *tty) 182{ 183 int ret = 0; 184 185 mutex_lock(&tty->throttle_mutex); 186 if (test_bit(TTY_THROTTLED, &tty->flags)) { 187 if (tty->flow_change != TTY_UNTHROTTLE_SAFE) 188 ret = 1; 189 else { 190 clear_bit(TTY_THROTTLED, &tty->flags); 191 if (tty->ops->unthrottle) 192 tty->ops->unthrottle(tty); 193 } 194 } 195 mutex_unlock(&tty->throttle_mutex); 196 197 return ret; 198} 199 200/** 201 * tty_wait_until_sent - wait for I/O to finish 202 * @tty: tty we are waiting for 203 * @timeout: how long we will wait 204 * 205 * Wait for characters pending in a tty driver to hit the wire, or 206 * for a timeout to occur (eg due to flow control) 207 * 208 * Locking: none 209 */ 210 211void tty_wait_until_sent(struct tty_struct *tty, long timeout) 212{ 213#ifdef TTY_DEBUG_WAIT_UNTIL_SENT 214 char buf[64]; 215 216 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf)); 217#endif 218 if (!timeout) 219 timeout = MAX_SCHEDULE_TIMEOUT; 220 if (wait_event_interruptible_timeout(tty->write_wait, 221 !tty_chars_in_buffer(tty), timeout) >= 0) { 222 if (tty->ops->wait_until_sent) 223 tty->ops->wait_until_sent(tty, timeout); 224 } 225} 226EXPORT_SYMBOL(tty_wait_until_sent); 227 228 229/* 230 * Termios Helper Methods 231 */ 232 233static void unset_locked_termios(struct ktermios *termios, 234 struct ktermios *old, 235 struct ktermios *locked) 236{ 237 int i; 238 239#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z))) 240 241 if (!locked) { 242 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n"); 243 return; 244 } 245 246 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag); 247 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag); 248 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag); 249 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag); 250 termios->c_line = locked->c_line ? old->c_line : termios->c_line; 251 for (i = 0; i < NCCS; i++) 252 termios->c_cc[i] = locked->c_cc[i] ? 253 old->c_cc[i] : termios->c_cc[i]; 254 /* FIXME: What should we do for i/ospeed */ 255} 256 257/* 258 * Routine which returns the baud rate of the tty 259 * 260 * Note that the baud_table needs to be kept in sync with the 261 * include/asm/termbits.h file. 262 */ 263static const speed_t baud_table[] = { 264 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 265 9600, 19200, 38400, 57600, 115200, 230400, 460800, 266#ifdef __sparc__ 267 76800, 153600, 307200, 614400, 921600 268#else 269 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000, 270 2500000, 3000000, 3500000, 4000000 271#endif 272}; 273 274#ifndef __sparc__ 275static const tcflag_t baud_bits[] = { 276 B0, B50, B75, B110, B134, B150, B200, B300, B600, 277 B1200, B1800, B2400, B4800, B9600, B19200, B38400, 278 B57600, B115200, B230400, B460800, B500000, B576000, 279 B921600, B1000000, B1152000, B1500000, B2000000, B2500000, 280 B3000000, B3500000, B4000000 281}; 282#else 283static const tcflag_t baud_bits[] = { 284 B0, B50, B75, B110, B134, B150, B200, B300, B600, 285 B1200, B1800, B2400, B4800, B9600, B19200, B38400, 286 B57600, B115200, B230400, B460800, B76800, B153600, 287 B307200, B614400, B921600 288}; 289#endif 290 291static int n_baud_table = ARRAY_SIZE(baud_table); 292 293/** 294 * tty_termios_baud_rate 295 * @termios: termios structure 296 * 297 * Convert termios baud rate data into a speed. This should be called 298 * with the termios lock held if this termios is a terminal termios 299 * structure. May change the termios data. Device drivers can call this 300 * function but should use ->c_[io]speed directly as they are updated. 301 * 302 * Locking: none 303 */ 304 305speed_t tty_termios_baud_rate(struct ktermios *termios) 306{ 307 unsigned int cbaud; 308 309 cbaud = termios->c_cflag & CBAUD; 310 311#ifdef BOTHER 312 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */ 313 if (cbaud == BOTHER) 314 return termios->c_ospeed; 315#endif 316 if (cbaud & CBAUDEX) { 317 cbaud &= ~CBAUDEX; 318 319 if (cbaud < 1 || cbaud + 15 > n_baud_table) 320 termios->c_cflag &= ~CBAUDEX; 321 else 322 cbaud += 15; 323 } 324 return baud_table[cbaud]; 325} 326EXPORT_SYMBOL(tty_termios_baud_rate); 327 328/** 329 * tty_termios_input_baud_rate 330 * @termios: termios structure 331 * 332 * Convert termios baud rate data into a speed. This should be called 333 * with the termios lock held if this termios is a terminal termios 334 * structure. May change the termios data. Device drivers can call this 335 * function but should use ->c_[io]speed directly as they are updated. 336 * 337 * Locking: none 338 */ 339 340speed_t tty_termios_input_baud_rate(struct ktermios *termios) 341{ 342#ifdef IBSHIFT 343 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD; 344 345 if (cbaud == B0) 346 return tty_termios_baud_rate(termios); 347 348 /* Magic token for arbitrary speed via c_ispeed*/ 349 if (cbaud == BOTHER) 350 return termios->c_ispeed; 351 352 if (cbaud & CBAUDEX) { 353 cbaud &= ~CBAUDEX; 354 355 if (cbaud < 1 || cbaud + 15 > n_baud_table) 356 termios->c_cflag &= ~(CBAUDEX << IBSHIFT); 357 else 358 cbaud += 15; 359 } 360 return baud_table[cbaud]; 361#else 362 return tty_termios_baud_rate(termios); 363#endif 364} 365EXPORT_SYMBOL(tty_termios_input_baud_rate); 366 367/** 368 * tty_termios_encode_baud_rate 369 * @termios: ktermios structure holding user requested state 370 * @ispeed: input speed 371 * @ospeed: output speed 372 * 373 * Encode the speeds set into the passed termios structure. This is 374 * used as a library helper for drivers so that they can report back 375 * the actual speed selected when it differs from the speed requested 376 * 377 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour 378 * we need to carefully set the bits when the user does not get the 379 * desired speed. We allow small margins and preserve as much of possible 380 * of the input intent to keep compatibility. 381 * 382 * Locking: Caller should hold termios lock. This is already held 383 * when calling this function from the driver termios handler. 384 * 385 * The ifdefs deal with platforms whose owners have yet to update them 386 * and will all go away once this is done. 387 */ 388 389void tty_termios_encode_baud_rate(struct ktermios *termios, 390 speed_t ibaud, speed_t obaud) 391{ 392 int i = 0; 393 int ifound = -1, ofound = -1; 394 int iclose = ibaud/50, oclose = obaud/50; 395 int ibinput = 0; 396 397 if (obaud == 0) /* CD dropped */ 398 ibaud = 0; /* Clear ibaud to be sure */ 399 400 termios->c_ispeed = ibaud; 401 termios->c_ospeed = obaud; 402 403#ifdef BOTHER 404 /* If the user asked for a precise weird speed give a precise weird 405 answer. If they asked for a Bfoo speed they may have problems 406 digesting non-exact replies so fuzz a bit */ 407 408 if ((termios->c_cflag & CBAUD) == BOTHER) 409 oclose = 0; 410 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER) 411 iclose = 0; 412 if ((termios->c_cflag >> IBSHIFT) & CBAUD) 413 ibinput = 1; /* An input speed was specified */ 414#endif 415 termios->c_cflag &= ~CBAUD; 416 417 /* 418 * Our goal is to find a close match to the standard baud rate 419 * returned. Walk the baud rate table and if we get a very close 420 * match then report back the speed as a POSIX Bxxxx value by 421 * preference 422 */ 423 424 do { 425 if (obaud - oclose <= baud_table[i] && 426 obaud + oclose >= baud_table[i]) { 427 termios->c_cflag |= baud_bits[i]; 428 ofound = i; 429 } 430 if (ibaud - iclose <= baud_table[i] && 431 ibaud + iclose >= baud_table[i]) { 432 /* For the case input == output don't set IBAUD bits 433 if the user didn't do so */ 434 if (ofound == i && !ibinput) 435 ifound = i; 436#ifdef IBSHIFT 437 else { 438 ifound = i; 439 termios->c_cflag |= (baud_bits[i] << IBSHIFT); 440 } 441#endif 442 } 443 } while (++i < n_baud_table); 444 445 /* 446 * If we found no match then use BOTHER if provided or warn 447 * the user their platform maintainer needs to wake up if not. 448 */ 449#ifdef BOTHER 450 if (ofound == -1) 451 termios->c_cflag |= BOTHER; 452 /* Set exact input bits only if the input and output differ or the 453 user already did */ 454 if (ifound == -1 && (ibaud != obaud || ibinput)) 455 termios->c_cflag |= (BOTHER << IBSHIFT); 456#else 457 if (ifound == -1 || ofound == -1) { 458 printk_once(KERN_WARNING "tty: Unable to return correct " 459 "speed data as your architecture needs updating.\n"); 460 } 461#endif 462} 463EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate); 464 465/** 466 * tty_encode_baud_rate - set baud rate of the tty 467 * @ibaud: input baud rate 468 * @obad: output baud rate 469 * 470 * Update the current termios data for the tty with the new speed 471 * settings. The caller must hold the termios_rwsem for the tty in 472 * question. 473 */ 474 475void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud) 476{ 477 tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud); 478} 479EXPORT_SYMBOL_GPL(tty_encode_baud_rate); 480 481/** 482 * tty_termios_copy_hw - copy hardware settings 483 * @new: New termios 484 * @old: Old termios 485 * 486 * Propagate the hardware specific terminal setting bits from 487 * the old termios structure to the new one. This is used in cases 488 * where the hardware does not support reconfiguration or as a helper 489 * in some cases where only minimal reconfiguration is supported 490 */ 491 492void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old) 493{ 494 /* The bits a dumb device handles in software. Smart devices need 495 to always provide a set_termios method */ 496 new->c_cflag &= HUPCL | CREAD | CLOCAL; 497 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL); 498 new->c_ispeed = old->c_ispeed; 499 new->c_ospeed = old->c_ospeed; 500} 501EXPORT_SYMBOL(tty_termios_copy_hw); 502 503/** 504 * tty_termios_hw_change - check for setting change 505 * @a: termios 506 * @b: termios to compare 507 * 508 * Check if any of the bits that affect a dumb device have changed 509 * between the two termios structures, or a speed change is needed. 510 */ 511 512int tty_termios_hw_change(struct ktermios *a, struct ktermios *b) 513{ 514 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed) 515 return 1; 516 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL)) 517 return 1; 518 return 0; 519} 520EXPORT_SYMBOL(tty_termios_hw_change); 521 522/** 523 * tty_set_termios - update termios values 524 * @tty: tty to update 525 * @new_termios: desired new value 526 * 527 * Perform updates to the termios values set on this terminal. There 528 * is a bit of layering violation here with n_tty in terms of the 529 * internal knowledge of this function. 530 * 531 * Locking: termios_rwsem 532 */ 533 534int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios) 535{ 536 struct ktermios old_termios; 537 struct tty_ldisc *ld; 538 unsigned long flags; 539 540 /* 541 * Perform the actual termios internal changes under lock. 542 */ 543 544 545 /* FIXME: we need to decide on some locking/ordering semantics 546 for the set_termios notification eventually */ 547 down_write(&tty->termios_rwsem); 548 old_termios = tty->termios; 549 tty->termios = *new_termios; 550 unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked); 551 552 /* See if packet mode change of state. */ 553 if (tty->link && tty->link->packet) { 554 int extproc = (old_termios.c_lflag & EXTPROC) | 555 (tty->termios.c_lflag & EXTPROC); 556 int old_flow = ((old_termios.c_iflag & IXON) && 557 (old_termios.c_cc[VSTOP] == '\023') && 558 (old_termios.c_cc[VSTART] == '\021')); 559 int new_flow = (I_IXON(tty) && 560 STOP_CHAR(tty) == '\023' && 561 START_CHAR(tty) == '\021'); 562 if ((old_flow != new_flow) || extproc) { 563 spin_lock_irqsave(&tty->ctrl_lock, flags); 564 if (old_flow != new_flow) { 565 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP); 566 if (new_flow) 567 tty->ctrl_status |= TIOCPKT_DOSTOP; 568 else 569 tty->ctrl_status |= TIOCPKT_NOSTOP; 570 } 571 if (extproc) 572 tty->ctrl_status |= TIOCPKT_IOCTL; 573 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 574 wake_up_interruptible(&tty->link->read_wait); 575 } 576 } 577 578 if (tty->ops->set_termios) 579 (*tty->ops->set_termios)(tty, &old_termios); 580 else 581 tty_termios_copy_hw(&tty->termios, &old_termios); 582 583 ld = tty_ldisc_ref(tty); 584 if (ld != NULL) { 585 if (ld->ops->set_termios) 586 (ld->ops->set_termios)(tty, &old_termios); 587 tty_ldisc_deref(ld); 588 } 589 up_write(&tty->termios_rwsem); 590 return 0; 591} 592EXPORT_SYMBOL_GPL(tty_set_termios); 593 594/** 595 * set_termios - set termios values for a tty 596 * @tty: terminal device 597 * @arg: user data 598 * @opt: option information 599 * 600 * Helper function to prepare termios data and run necessary other 601 * functions before using tty_set_termios to do the actual changes. 602 * 603 * Locking: 604 * Called functions take ldisc and termios_rwsem locks 605 */ 606 607static int set_termios(struct tty_struct *tty, void __user *arg, int opt) 608{ 609 struct ktermios tmp_termios; 610 struct tty_ldisc *ld; 611 int retval = tty_check_change(tty); 612 613 if (retval) 614 return retval; 615 616 down_read(&tty->termios_rwsem); 617 tmp_termios = tty->termios; 618 up_read(&tty->termios_rwsem); 619 620 if (opt & TERMIOS_TERMIO) { 621 if (user_termio_to_kernel_termios(&tmp_termios, 622 (struct termio __user *)arg)) 623 return -EFAULT; 624#ifdef TCGETS2 625 } else if (opt & TERMIOS_OLD) { 626 if (user_termios_to_kernel_termios_1(&tmp_termios, 627 (struct termios __user *)arg)) 628 return -EFAULT; 629 } else { 630 if (user_termios_to_kernel_termios(&tmp_termios, 631 (struct termios2 __user *)arg)) 632 return -EFAULT; 633 } 634#else 635 } else if (user_termios_to_kernel_termios(&tmp_termios, 636 (struct termios __user *)arg)) 637 return -EFAULT; 638#endif 639 640 /* If old style Bfoo values are used then load c_ispeed/c_ospeed 641 * with the real speed so its unconditionally usable */ 642 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios); 643 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios); 644 645 ld = tty_ldisc_ref(tty); 646 647 if (ld != NULL) { 648 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer) 649 ld->ops->flush_buffer(tty); 650 tty_ldisc_deref(ld); 651 } 652 653 if (opt & TERMIOS_WAIT) { 654 tty_wait_until_sent(tty, 0); 655 if (signal_pending(current)) 656 return -ERESTARTSYS; 657 } 658 659 tty_set_termios(tty, &tmp_termios); 660 661 /* FIXME: Arguably if tmp_termios == tty->termios AND the 662 actual requested termios was not tmp_termios then we may 663 want to return an error as no user requested change has 664 succeeded */ 665 return 0; 666} 667 668static void copy_termios(struct tty_struct *tty, struct ktermios *kterm) 669{ 670 down_read(&tty->termios_rwsem); 671 *kterm = tty->termios; 672 up_read(&tty->termios_rwsem); 673} 674 675static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm) 676{ 677 down_read(&tty->termios_rwsem); 678 *kterm = tty->termios_locked; 679 up_read(&tty->termios_rwsem); 680} 681 682static int get_termio(struct tty_struct *tty, struct termio __user *termio) 683{ 684 struct ktermios kterm; 685 copy_termios(tty, &kterm); 686 if (kernel_termios_to_user_termio(termio, &kterm)) 687 return -EFAULT; 688 return 0; 689} 690 691 692#ifdef TCGETX 693 694/** 695 * set_termiox - set termiox fields if possible 696 * @tty: terminal 697 * @arg: termiox structure from user 698 * @opt: option flags for ioctl type 699 * 700 * Implement the device calling points for the SYS5 termiox ioctl 701 * interface in Linux 702 */ 703 704static int set_termiox(struct tty_struct *tty, void __user *arg, int opt) 705{ 706 struct termiox tnew; 707 struct tty_ldisc *ld; 708 709 if (tty->termiox == NULL) 710 return -EINVAL; 711 if (copy_from_user(&tnew, arg, sizeof(struct termiox))) 712 return -EFAULT; 713 714 ld = tty_ldisc_ref(tty); 715 if (ld != NULL) { 716 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer) 717 ld->ops->flush_buffer(tty); 718 tty_ldisc_deref(ld); 719 } 720 if (opt & TERMIOS_WAIT) { 721 tty_wait_until_sent(tty, 0); 722 if (signal_pending(current)) 723 return -ERESTARTSYS; 724 } 725 726 down_write(&tty->termios_rwsem); 727 if (tty->ops->set_termiox) 728 tty->ops->set_termiox(tty, &tnew); 729 up_write(&tty->termios_rwsem); 730 return 0; 731} 732 733#endif 734 735 736#ifdef TIOCGETP 737/* 738 * These are deprecated, but there is limited support.. 739 * 740 * The "sg_flags" translation is a joke.. 741 */ 742static int get_sgflags(struct tty_struct *tty) 743{ 744 int flags = 0; 745 746 if (!(tty->termios.c_lflag & ICANON)) { 747 if (tty->termios.c_lflag & ISIG) 748 flags |= 0x02; /* cbreak */ 749 else 750 flags |= 0x20; /* raw */ 751 } 752 if (tty->termios.c_lflag & ECHO) 753 flags |= 0x08; /* echo */ 754 if (tty->termios.c_oflag & OPOST) 755 if (tty->termios.c_oflag & ONLCR) 756 flags |= 0x10; /* crmod */ 757 return flags; 758} 759 760static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb) 761{ 762 struct sgttyb tmp; 763 764 down_read(&tty->termios_rwsem); 765 tmp.sg_ispeed = tty->termios.c_ispeed; 766 tmp.sg_ospeed = tty->termios.c_ospeed; 767 tmp.sg_erase = tty->termios.c_cc[VERASE]; 768 tmp.sg_kill = tty->termios.c_cc[VKILL]; 769 tmp.sg_flags = get_sgflags(tty); 770 up_read(&tty->termios_rwsem); 771 772 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0; 773} 774 775static void set_sgflags(struct ktermios *termios, int flags) 776{ 777 termios->c_iflag = ICRNL | IXON; 778 termios->c_oflag = 0; 779 termios->c_lflag = ISIG | ICANON; 780 if (flags & 0x02) { /* cbreak */ 781 termios->c_iflag = 0; 782 termios->c_lflag &= ~ICANON; 783 } 784 if (flags & 0x08) { /* echo */ 785 termios->c_lflag |= ECHO | ECHOE | ECHOK | 786 ECHOCTL | ECHOKE | IEXTEN; 787 } 788 if (flags & 0x10) { /* crmod */ 789 termios->c_oflag |= OPOST | ONLCR; 790 } 791 if (flags & 0x20) { /* raw */ 792 termios->c_iflag = 0; 793 termios->c_lflag &= ~(ISIG | ICANON); 794 } 795 if (!(termios->c_lflag & ICANON)) { 796 termios->c_cc[VMIN] = 1; 797 termios->c_cc[VTIME] = 0; 798 } 799} 800 801/** 802 * set_sgttyb - set legacy terminal values 803 * @tty: tty structure 804 * @sgttyb: pointer to old style terminal structure 805 * 806 * Updates a terminal from the legacy BSD style terminal information 807 * structure. 808 * 809 * Locking: termios_rwsem 810 */ 811 812static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb) 813{ 814 int retval; 815 struct sgttyb tmp; 816 struct ktermios termios; 817 818 retval = tty_check_change(tty); 819 if (retval) 820 return retval; 821 822 if (copy_from_user(&tmp, sgttyb, sizeof(tmp))) 823 return -EFAULT; 824 825 down_write(&tty->termios_rwsem); 826 termios = tty->termios; 827 termios.c_cc[VERASE] = tmp.sg_erase; 828 termios.c_cc[VKILL] = tmp.sg_kill; 829 set_sgflags(&termios, tmp.sg_flags); 830 /* Try and encode into Bfoo format */ 831#ifdef BOTHER 832 tty_termios_encode_baud_rate(&termios, termios.c_ispeed, 833 termios.c_ospeed); 834#endif 835 up_write(&tty->termios_rwsem); 836 tty_set_termios(tty, &termios); 837 return 0; 838} 839#endif 840 841#ifdef TIOCGETC 842static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars) 843{ 844 struct tchars tmp; 845 846 down_read(&tty->termios_rwsem); 847 tmp.t_intrc = tty->termios.c_cc[VINTR]; 848 tmp.t_quitc = tty->termios.c_cc[VQUIT]; 849 tmp.t_startc = tty->termios.c_cc[VSTART]; 850 tmp.t_stopc = tty->termios.c_cc[VSTOP]; 851 tmp.t_eofc = tty->termios.c_cc[VEOF]; 852 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */ 853 up_read(&tty->termios_rwsem); 854 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0; 855} 856 857static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars) 858{ 859 struct tchars tmp; 860 861 if (copy_from_user(&tmp, tchars, sizeof(tmp))) 862 return -EFAULT; 863 down_write(&tty->termios_rwsem); 864 tty->termios.c_cc[VINTR] = tmp.t_intrc; 865 tty->termios.c_cc[VQUIT] = tmp.t_quitc; 866 tty->termios.c_cc[VSTART] = tmp.t_startc; 867 tty->termios.c_cc[VSTOP] = tmp.t_stopc; 868 tty->termios.c_cc[VEOF] = tmp.t_eofc; 869 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */ 870 up_write(&tty->termios_rwsem); 871 return 0; 872} 873#endif 874 875#ifdef TIOCGLTC 876static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars) 877{ 878 struct ltchars tmp; 879 880 down_read(&tty->termios_rwsem); 881 tmp.t_suspc = tty->termios.c_cc[VSUSP]; 882 /* what is dsuspc anyway? */ 883 tmp.t_dsuspc = tty->termios.c_cc[VSUSP]; 884 tmp.t_rprntc = tty->termios.c_cc[VREPRINT]; 885 /* what is flushc anyway? */ 886 tmp.t_flushc = tty->termios.c_cc[VEOL2]; 887 tmp.t_werasc = tty->termios.c_cc[VWERASE]; 888 tmp.t_lnextc = tty->termios.c_cc[VLNEXT]; 889 up_read(&tty->termios_rwsem); 890 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0; 891} 892 893static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars) 894{ 895 struct ltchars tmp; 896 897 if (copy_from_user(&tmp, ltchars, sizeof(tmp))) 898 return -EFAULT; 899 900 down_write(&tty->termios_rwsem); 901 tty->termios.c_cc[VSUSP] = tmp.t_suspc; 902 /* what is dsuspc anyway? */ 903 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc; 904 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc; 905 /* what is flushc anyway? */ 906 tty->termios.c_cc[VEOL2] = tmp.t_flushc; 907 tty->termios.c_cc[VWERASE] = tmp.t_werasc; 908 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc; 909 up_write(&tty->termios_rwsem); 910 return 0; 911} 912#endif 913 914/** 915 * tty_change_softcar - carrier change ioctl helper 916 * @tty: tty to update 917 * @arg: enable/disable CLOCAL 918 * 919 * Perform a change to the CLOCAL state and call into the driver 920 * layer to make it visible. All done with the termios rwsem 921 */ 922 923static int tty_change_softcar(struct tty_struct *tty, int arg) 924{ 925 int ret = 0; 926 int bit = arg ? CLOCAL : 0; 927 struct ktermios old; 928 929 down_write(&tty->termios_rwsem); 930 old = tty->termios; 931 tty->termios.c_cflag &= ~CLOCAL; 932 tty->termios.c_cflag |= bit; 933 if (tty->ops->set_termios) 934 tty->ops->set_termios(tty, &old); 935 if ((tty->termios.c_cflag & CLOCAL) != bit) 936 ret = -EINVAL; 937 up_write(&tty->termios_rwsem); 938 return ret; 939} 940 941/** 942 * tty_mode_ioctl - mode related ioctls 943 * @tty: tty for the ioctl 944 * @file: file pointer for the tty 945 * @cmd: command 946 * @arg: ioctl argument 947 * 948 * Perform non line discipline specific mode control ioctls. This 949 * is designed to be called by line disciplines to ensure they provide 950 * consistent mode setting. 951 */ 952 953int tty_mode_ioctl(struct tty_struct *tty, struct file *file, 954 unsigned int cmd, unsigned long arg) 955{ 956 struct tty_struct *real_tty; 957 void __user *p = (void __user *)arg; 958 int ret = 0; 959 struct ktermios kterm; 960 961 BUG_ON(file == NULL); 962 963 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 964 tty->driver->subtype == PTY_TYPE_MASTER) 965 real_tty = tty->link; 966 else 967 real_tty = tty; 968 969 switch (cmd) { 970#ifdef TIOCGETP 971 case TIOCGETP: 972 return get_sgttyb(real_tty, (struct sgttyb __user *) arg); 973 case TIOCSETP: 974 case TIOCSETN: 975 return set_sgttyb(real_tty, (struct sgttyb __user *) arg); 976#endif 977#ifdef TIOCGETC 978 case TIOCGETC: 979 return get_tchars(real_tty, p); 980 case TIOCSETC: 981 return set_tchars(real_tty, p); 982#endif 983#ifdef TIOCGLTC 984 case TIOCGLTC: 985 return get_ltchars(real_tty, p); 986 case TIOCSLTC: 987 return set_ltchars(real_tty, p); 988#endif 989 case TCSETSF: 990 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD); 991 case TCSETSW: 992 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD); 993 case TCSETS: 994 return set_termios(real_tty, p, TERMIOS_OLD); 995#ifndef TCGETS2 996 case TCGETS: 997 copy_termios(real_tty, &kterm); 998 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm)) 999 ret = -EFAULT; 1000 return ret; 1001#else 1002 case TCGETS: 1003 copy_termios(real_tty, &kterm); 1004 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm)) 1005 ret = -EFAULT; 1006 return ret; 1007 case TCGETS2: 1008 copy_termios(real_tty, &kterm); 1009 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm)) 1010 ret = -EFAULT; 1011 return ret; 1012 case TCSETSF2: 1013 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT); 1014 case TCSETSW2: 1015 return set_termios(real_tty, p, TERMIOS_WAIT); 1016 case TCSETS2: 1017 return set_termios(real_tty, p, 0); 1018#endif 1019 case TCGETA: 1020 return get_termio(real_tty, p); 1021 case TCSETAF: 1022 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO); 1023 case TCSETAW: 1024 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO); 1025 case TCSETA: 1026 return set_termios(real_tty, p, TERMIOS_TERMIO); 1027#ifndef TCGETS2 1028 case TIOCGLCKTRMIOS: 1029 copy_termios_locked(real_tty, &kterm); 1030 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm)) 1031 ret = -EFAULT; 1032 return ret; 1033 case TIOCSLCKTRMIOS: 1034 if (!capable(CAP_SYS_ADMIN)) 1035 return -EPERM; 1036 copy_termios_locked(real_tty, &kterm); 1037 if (user_termios_to_kernel_termios(&kterm, 1038 (struct termios __user *) arg)) 1039 return -EFAULT; 1040 down_write(&real_tty->termios_rwsem); 1041 real_tty->termios_locked = kterm; 1042 up_write(&real_tty->termios_rwsem); 1043 return 0; 1044#else 1045 case TIOCGLCKTRMIOS: 1046 copy_termios_locked(real_tty, &kterm); 1047 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm)) 1048 ret = -EFAULT; 1049 return ret; 1050 case TIOCSLCKTRMIOS: 1051 if (!capable(CAP_SYS_ADMIN)) 1052 return -EPERM; 1053 copy_termios_locked(real_tty, &kterm); 1054 if (user_termios_to_kernel_termios_1(&kterm, 1055 (struct termios __user *) arg)) 1056 return -EFAULT; 1057 down_write(&real_tty->termios_rwsem); 1058 real_tty->termios_locked = kterm; 1059 up_write(&real_tty->termios_rwsem); 1060 return ret; 1061#endif 1062#ifdef TCGETX 1063 case TCGETX: { 1064 struct termiox ktermx; 1065 if (real_tty->termiox == NULL) 1066 return -EINVAL; 1067 down_read(&real_tty->termios_rwsem); 1068 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox)); 1069 up_read(&real_tty->termios_rwsem); 1070 if (copy_to_user(p, &ktermx, sizeof(struct termiox))) 1071 ret = -EFAULT; 1072 return ret; 1073 } 1074 case TCSETX: 1075 return set_termiox(real_tty, p, 0); 1076 case TCSETXW: 1077 return set_termiox(real_tty, p, TERMIOS_WAIT); 1078 case TCSETXF: 1079 return set_termiox(real_tty, p, TERMIOS_FLUSH); 1080#endif 1081 case TIOCGSOFTCAR: 1082 copy_termios(real_tty, &kterm); 1083 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0, 1084 (int __user *)arg); 1085 return ret; 1086 case TIOCSSOFTCAR: 1087 if (get_user(arg, (unsigned int __user *) arg)) 1088 return -EFAULT; 1089 return tty_change_softcar(real_tty, arg); 1090 default: 1091 return -ENOIOCTLCMD; 1092 } 1093} 1094EXPORT_SYMBOL_GPL(tty_mode_ioctl); 1095 1096 1097/* Caller guarantees ldisc reference is held */ 1098static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg) 1099{ 1100 struct tty_ldisc *ld = tty->ldisc; 1101 1102 switch (arg) { 1103 case TCIFLUSH: 1104 if (ld && ld->ops->flush_buffer) { 1105 ld->ops->flush_buffer(tty); 1106 tty_unthrottle(tty); 1107 } 1108 break; 1109 case TCIOFLUSH: 1110 if (ld && ld->ops->flush_buffer) { 1111 ld->ops->flush_buffer(tty); 1112 tty_unthrottle(tty); 1113 } 1114 /* fall through */ 1115 case TCOFLUSH: 1116 tty_driver_flush_buffer(tty); 1117 break; 1118 default: 1119 return -EINVAL; 1120 } 1121 return 0; 1122} 1123 1124int tty_perform_flush(struct tty_struct *tty, unsigned long arg) 1125{ 1126 struct tty_ldisc *ld; 1127 int retval = tty_check_change(tty); 1128 if (retval) 1129 return retval; 1130 1131 ld = tty_ldisc_ref_wait(tty); 1132 retval = __tty_perform_flush(tty, arg); 1133 if (ld) 1134 tty_ldisc_deref(ld); 1135 return retval; 1136} 1137EXPORT_SYMBOL_GPL(tty_perform_flush); 1138 1139int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file, 1140 unsigned int cmd, unsigned long arg) 1141{ 1142 int retval; 1143 1144 switch (cmd) { 1145 case TCXONC: 1146 retval = tty_check_change(tty); 1147 if (retval) 1148 return retval; 1149 switch (arg) { 1150 case TCOOFF: 1151 spin_lock_irq(&tty->flow_lock); 1152 if (!tty->flow_stopped) { 1153 tty->flow_stopped = 1; 1154 __stop_tty(tty); 1155 } 1156 spin_unlock_irq(&tty->flow_lock); 1157 break; 1158 case TCOON: 1159 spin_lock_irq(&tty->flow_lock); 1160 if (tty->flow_stopped) { 1161 tty->flow_stopped = 0; 1162 __start_tty(tty); 1163 } 1164 spin_unlock_irq(&tty->flow_lock); 1165 break; 1166 case TCIOFF: 1167 down_read(&tty->termios_rwsem); 1168 if (STOP_CHAR(tty) != __DISABLED_CHAR) 1169 retval = tty_send_xchar(tty, STOP_CHAR(tty)); 1170 up_read(&tty->termios_rwsem); 1171 break; 1172 case TCION: 1173 down_read(&tty->termios_rwsem); 1174 if (START_CHAR(tty) != __DISABLED_CHAR) 1175 retval = tty_send_xchar(tty, START_CHAR(tty)); 1176 up_read(&tty->termios_rwsem); 1177 break; 1178 default: 1179 return -EINVAL; 1180 } 1181 return retval; 1182 case TCFLSH: 1183 retval = tty_check_change(tty); 1184 if (retval) 1185 return retval; 1186 return __tty_perform_flush(tty, arg); 1187 default: 1188 /* Try the mode commands */ 1189 return tty_mode_ioctl(tty, file, cmd, arg); 1190 } 1191} 1192EXPORT_SYMBOL(n_tty_ioctl_helper); 1193 1194#ifdef CONFIG_COMPAT 1195long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file, 1196 unsigned int cmd, unsigned long arg) 1197{ 1198 switch (cmd) { 1199 case TIOCGLCKTRMIOS: 1200 case TIOCSLCKTRMIOS: 1201 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg)); 1202 default: 1203 return -ENOIOCTLCMD; 1204 } 1205} 1206EXPORT_SYMBOL(n_tty_compat_ioctl_helper); 1207#endif 1208 1209