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