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