1/* 2 * n_tty.c --- implements the N_TTY line discipline. 3 * 4 * This code used to be in tty_io.c, but things are getting hairy 5 * enough that it made sense to split things off. (The N_TTY 6 * processing has changed so much that it's hardly recognizable, 7 * anyway...) 8 * 9 * Note that the open routine for N_TTY is guaranteed never to return 10 * an error. This is because Linux will fall back to setting a line 11 * to N_TTY if it can not switch to any other line discipline. 12 * 13 * Written by Theodore Ts'o, Copyright 1994. 14 * 15 * This file also contains code originally written by Linus Torvalds, 16 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994. 17 * 18 * This file may be redistributed under the terms of the GNU General Public 19 * License. 20 * 21 * Reduced memory usage for older ARM systems - Russell King. 22 * 23 * 2000/01/20 Fixed SMP locking on put_tty_queue using bits of 24 * the patch by Andrew J. Kroll <ag784@freenet.buffalo.edu> 25 * who actually finally proved there really was a race. 26 * 27 * 2002/03/18 Implemented n_tty_wakeup to send SIGIO POLL_OUTs to 28 * waiting writing processes-Sapan Bhatia <sapan@corewars.org>. 29 * Also fixed a bug in BLOCKING mode where n_tty_write returns 30 * EAGAIN 31 */ 32 33#include <linux/types.h> 34#include <linux/major.h> 35#include <linux/errno.h> 36#include <linux/signal.h> 37#include <linux/fcntl.h> 38#include <linux/sched.h> 39#include <linux/interrupt.h> 40#include <linux/tty.h> 41#include <linux/timer.h> 42#include <linux/ctype.h> 43#include <linux/mm.h> 44#include <linux/string.h> 45#include <linux/slab.h> 46#include <linux/poll.h> 47#include <linux/bitops.h> 48#include <linux/audit.h> 49#include <linux/file.h> 50#include <linux/uaccess.h> 51#include <linux/module.h> 52 53#include <asm/system.h> 54 55/* number of characters left in xmit buffer before select has we have room */ 56#define WAKEUP_CHARS 256 57 58/* 59 * This defines the low- and high-watermarks for throttling and 60 * unthrottling the TTY driver. These watermarks are used for 61 * controlling the space in the read buffer. 62 */ 63#define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */ 64#define TTY_THRESHOLD_UNTHROTTLE 128 65 66/* 67 * Special byte codes used in the echo buffer to represent operations 68 * or special handling of characters. Bytes in the echo buffer that 69 * are not part of such special blocks are treated as normal character 70 * codes. 71 */ 72#define ECHO_OP_START 0xff 73#define ECHO_OP_MOVE_BACK_COL 0x80 74#define ECHO_OP_SET_CANON_COL 0x81 75#define ECHO_OP_ERASE_TAB 0x82 76 77static inline int tty_put_user(struct tty_struct *tty, unsigned char x, 78 unsigned char __user *ptr) 79{ 80 tty_audit_add_data(tty, &x, 1); 81 return put_user(x, ptr); 82} 83 84/** 85 * n_tty_set__room - receive space 86 * @tty: terminal 87 * 88 * Called by the driver to find out how much data it is 89 * permitted to feed to the line discipline without any being lost 90 * and thus to manage flow control. Not serialized. Answers for the 91 * "instant". 92 */ 93 94static void n_tty_set_room(struct tty_struct *tty) 95{ 96 /* tty->read_cnt is not read locked ? */ 97 int left = N_TTY_BUF_SIZE - tty->read_cnt - 1; 98 99 /* 100 * If we are doing input canonicalization, and there are no 101 * pending newlines, let characters through without limit, so 102 * that erase characters will be handled. Other excess 103 * characters will be beeped. 104 */ 105 if (left <= 0) 106 left = tty->icanon && !tty->canon_data; 107 tty->receive_room = left; 108} 109 110static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty) 111{ 112 if (tty->read_cnt < N_TTY_BUF_SIZE) { 113 tty->read_buf[tty->read_head] = c; 114 tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1); 115 tty->read_cnt++; 116 } 117} 118 119/** 120 * put_tty_queue - add character to tty 121 * @c: character 122 * @tty: tty device 123 * 124 * Add a character to the tty read_buf queue. This is done under the 125 * read_lock to serialize character addition and also to protect us 126 * against parallel reads or flushes 127 */ 128 129static void put_tty_queue(unsigned char c, struct tty_struct *tty) 130{ 131 unsigned long flags; 132 /* 133 * The problem of stomping on the buffers ends here. 134 * Why didn't anyone see this one coming? --AJK 135 */ 136 spin_lock_irqsave(&tty->read_lock, flags); 137 put_tty_queue_nolock(c, tty); 138 spin_unlock_irqrestore(&tty->read_lock, flags); 139} 140 141/** 142 * check_unthrottle - allow new receive data 143 * @tty; tty device 144 * 145 * Check whether to call the driver unthrottle functions 146 * 147 * Can sleep, may be called under the atomic_read_lock mutex but 148 * this is not guaranteed. 149 */ 150static void check_unthrottle(struct tty_struct *tty) 151{ 152 if (tty->count) 153 tty_unthrottle(tty); 154} 155 156/** 157 * reset_buffer_flags - reset buffer state 158 * @tty: terminal to reset 159 * 160 * Reset the read buffer counters, clear the flags, 161 * and make sure the driver is unthrottled. Called 162 * from n_tty_open() and n_tty_flush_buffer(). 163 * 164 * Locking: tty_read_lock for read fields. 165 */ 166 167static void reset_buffer_flags(struct tty_struct *tty) 168{ 169 unsigned long flags; 170 171 spin_lock_irqsave(&tty->read_lock, flags); 172 tty->read_head = tty->read_tail = tty->read_cnt = 0; 173 spin_unlock_irqrestore(&tty->read_lock, flags); 174 175 mutex_lock(&tty->echo_lock); 176 tty->echo_pos = tty->echo_cnt = tty->echo_overrun = 0; 177 mutex_unlock(&tty->echo_lock); 178 179 tty->canon_head = tty->canon_data = tty->erasing = 0; 180 memset(&tty->read_flags, 0, sizeof tty->read_flags); 181 n_tty_set_room(tty); 182 check_unthrottle(tty); 183} 184 185/** 186 * n_tty_flush_buffer - clean input queue 187 * @tty: terminal device 188 * 189 * Flush the input buffer. Called when the line discipline is 190 * being closed, when the tty layer wants the buffer flushed (eg 191 * at hangup) or when the N_TTY line discipline internally has to 192 * clean the pending queue (for example some signals). 193 * 194 * Locking: ctrl_lock, read_lock. 195 */ 196 197static void n_tty_flush_buffer(struct tty_struct *tty) 198{ 199 unsigned long flags; 200 /* clear everything and unthrottle the driver */ 201 reset_buffer_flags(tty); 202 203 if (!tty->link) 204 return; 205 206 spin_lock_irqsave(&tty->ctrl_lock, flags); 207 if (tty->link->packet) { 208 tty->ctrl_status |= TIOCPKT_FLUSHREAD; 209 wake_up_interruptible(&tty->link->read_wait); 210 } 211 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 212} 213 214/** 215 * n_tty_chars_in_buffer - report available bytes 216 * @tty: tty device 217 * 218 * Report the number of characters buffered to be delivered to user 219 * at this instant in time. 220 * 221 * Locking: read_lock 222 */ 223 224static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty) 225{ 226 unsigned long flags; 227 ssize_t n = 0; 228 229 spin_lock_irqsave(&tty->read_lock, flags); 230 if (!tty->icanon) { 231 n = tty->read_cnt; 232 } else if (tty->canon_data) { 233 n = (tty->canon_head > tty->read_tail) ? 234 tty->canon_head - tty->read_tail : 235 tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail); 236 } 237 spin_unlock_irqrestore(&tty->read_lock, flags); 238 return n; 239} 240 241/** 242 * is_utf8_continuation - utf8 multibyte check 243 * @c: byte to check 244 * 245 * Returns true if the utf8 character 'c' is a multibyte continuation 246 * character. We use this to correctly compute the on screen size 247 * of the character when printing 248 */ 249 250static inline int is_utf8_continuation(unsigned char c) 251{ 252 return (c & 0xc0) == 0x80; 253} 254 255/** 256 * is_continuation - multibyte check 257 * @c: byte to check 258 * 259 * Returns true if the utf8 character 'c' is a multibyte continuation 260 * character and the terminal is in unicode mode. 261 */ 262 263static inline int is_continuation(unsigned char c, struct tty_struct *tty) 264{ 265 return I_IUTF8(tty) && is_utf8_continuation(c); 266} 267 268/** 269 * do_output_char - output one character 270 * @c: character (or partial unicode symbol) 271 * @tty: terminal device 272 * @space: space available in tty driver write buffer 273 * 274 * This is a helper function that handles one output character 275 * (including special characters like TAB, CR, LF, etc.), 276 * doing OPOST processing and putting the results in the 277 * tty driver's write buffer. 278 * 279 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY 280 * and NLDLY. They simply aren't relevant in the world today. 281 * If you ever need them, add them here. 282 * 283 * Returns the number of bytes of buffer space used or -1 if 284 * no space left. 285 * 286 * Locking: should be called under the output_lock to protect 287 * the column state and space left in the buffer 288 */ 289 290static int do_output_char(unsigned char c, struct tty_struct *tty, int space) 291{ 292 int spaces; 293 294 if (!space) 295 return -1; 296 297 switch (c) { 298 case '\n': 299 if (O_ONLRET(tty)) 300 tty->column = 0; 301 if (O_ONLCR(tty)) { 302 if (space < 2) 303 return -1; 304 tty->canon_column = tty->column = 0; 305 tty->ops->write(tty, "\r\n", 2); 306 return 2; 307 } 308 tty->canon_column = tty->column; 309 break; 310 case '\r': 311 if (O_ONOCR(tty) && tty->column == 0) 312 return 0; 313 if (O_OCRNL(tty)) { 314 c = '\n'; 315 if (O_ONLRET(tty)) 316 tty->canon_column = tty->column = 0; 317 break; 318 } 319 tty->canon_column = tty->column = 0; 320 break; 321 case '\t': 322 spaces = 8 - (tty->column & 7); 323 if (O_TABDLY(tty) == XTABS) { 324 if (space < spaces) 325 return -1; 326 tty->column += spaces; 327 tty->ops->write(tty, " ", spaces); 328 return spaces; 329 } 330 tty->column += spaces; 331 break; 332 case '\b': 333 if (tty->column > 0) 334 tty->column--; 335 break; 336 default: 337 if (!iscntrl(c)) { 338 if (O_OLCUC(tty)) 339 c = toupper(c); 340 if (!is_continuation(c, tty)) 341 tty->column++; 342 } 343 break; 344 } 345 346 tty_put_char(tty, c); 347 return 1; 348} 349 350/** 351 * process_output - output post processor 352 * @c: character (or partial unicode symbol) 353 * @tty: terminal device 354 * 355 * Output one character with OPOST processing. 356 * Returns -1 when the output device is full and the character 357 * must be retried. 358 * 359 * Locking: output_lock to protect column state and space left 360 * (also, this is called from n_tty_write under the 361 * tty layer write lock) 362 */ 363 364static int process_output(unsigned char c, struct tty_struct *tty) 365{ 366 int space, retval; 367 368 mutex_lock(&tty->output_lock); 369 370 space = tty_write_room(tty); 371 retval = do_output_char(c, tty, space); 372 373 mutex_unlock(&tty->output_lock); 374 if (retval < 0) 375 return -1; 376 else 377 return 0; 378} 379 380/** 381 * process_output_block - block post processor 382 * @tty: terminal device 383 * @buf: character buffer 384 * @nr: number of bytes to output 385 * 386 * Output a block of characters with OPOST processing. 387 * Returns the number of characters output. 388 * 389 * This path is used to speed up block console writes, among other 390 * things when processing blocks of output data. It handles only 391 * the simple cases normally found and helps to generate blocks of 392 * symbols for the console driver and thus improve performance. 393 * 394 * Locking: output_lock to protect column state and space left 395 * (also, this is called from n_tty_write under the 396 * tty layer write lock) 397 */ 398 399static ssize_t process_output_block(struct tty_struct *tty, 400 const unsigned char *buf, unsigned int nr) 401{ 402 int space; 403 int i; 404 const unsigned char *cp; 405 406 mutex_lock(&tty->output_lock); 407 408 space = tty_write_room(tty); 409 if (!space) { 410 mutex_unlock(&tty->output_lock); 411 return 0; 412 } 413 if (nr > space) 414 nr = space; 415 416 for (i = 0, cp = buf; i < nr; i++, cp++) { 417 unsigned char c = *cp; 418 419 switch (c) { 420 case '\n': 421 if (O_ONLRET(tty)) 422 tty->column = 0; 423 if (O_ONLCR(tty)) 424 goto break_out; 425 tty->canon_column = tty->column; 426 break; 427 case '\r': 428 if (O_ONOCR(tty) && tty->column == 0) 429 goto break_out; 430 if (O_OCRNL(tty)) 431 goto break_out; 432 tty->canon_column = tty->column = 0; 433 break; 434 case '\t': 435 goto break_out; 436 case '\b': 437 if (tty->column > 0) 438 tty->column--; 439 break; 440 default: 441 if (!iscntrl(c)) { 442 if (O_OLCUC(tty)) 443 goto break_out; 444 if (!is_continuation(c, tty)) 445 tty->column++; 446 } 447 break; 448 } 449 } 450break_out: 451 i = tty->ops->write(tty, buf, i); 452 453 mutex_unlock(&tty->output_lock); 454 return i; 455} 456 457/** 458 * process_echoes - write pending echo characters 459 * @tty: terminal device 460 * 461 * Write previously buffered echo (and other ldisc-generated) 462 * characters to the tty. 463 * 464 * Characters generated by the ldisc (including echoes) need to 465 * be buffered because the driver's write buffer can fill during 466 * heavy program output. Echoing straight to the driver will 467 * often fail under these conditions, causing lost characters and 468 * resulting mismatches of ldisc state information. 469 * 470 * Since the ldisc state must represent the characters actually sent 471 * to the driver at the time of the write, operations like certain 472 * changes in column state are also saved in the buffer and executed 473 * here. 474 * 475 * A circular fifo buffer is used so that the most recent characters 476 * are prioritized. Also, when control characters are echoed with a 477 * prefixed "^", the pair is treated atomically and thus not separated. 478 * 479 * Locking: output_lock to protect column state and space left, 480 * echo_lock to protect the echo buffer 481 */ 482 483static void process_echoes(struct tty_struct *tty) 484{ 485 int space, nr; 486 unsigned char c; 487 unsigned char *cp, *buf_end; 488 489 if (!tty->echo_cnt) 490 return; 491 492 mutex_lock(&tty->output_lock); 493 mutex_lock(&tty->echo_lock); 494 495 space = tty_write_room(tty); 496 497 buf_end = tty->echo_buf + N_TTY_BUF_SIZE; 498 cp = tty->echo_buf + tty->echo_pos; 499 nr = tty->echo_cnt; 500 while (nr > 0) { 501 c = *cp; 502 if (c == ECHO_OP_START) { 503 unsigned char op; 504 unsigned char *opp; 505 int no_space_left = 0; 506 507 /* 508 * If the buffer byte is the start of a multi-byte 509 * operation, get the next byte, which is either the 510 * op code or a control character value. 511 */ 512 opp = cp + 1; 513 if (opp == buf_end) 514 opp -= N_TTY_BUF_SIZE; 515 op = *opp; 516 517 switch (op) { 518 unsigned int num_chars, num_bs; 519 520 case ECHO_OP_ERASE_TAB: 521 if (++opp == buf_end) 522 opp -= N_TTY_BUF_SIZE; 523 num_chars = *opp; 524 525 /* 526 * Determine how many columns to go back 527 * in order to erase the tab. 528 * This depends on the number of columns 529 * used by other characters within the tab 530 * area. If this (modulo 8) count is from 531 * the start of input rather than from a 532 * previous tab, we offset by canon column. 533 * Otherwise, tab spacing is normal. 534 */ 535 if (!(num_chars & 0x80)) 536 num_chars += tty->canon_column; 537 num_bs = 8 - (num_chars & 7); 538 539 if (num_bs > space) { 540 no_space_left = 1; 541 break; 542 } 543 space -= num_bs; 544 while (num_bs--) { 545 tty_put_char(tty, '\b'); 546 if (tty->column > 0) 547 tty->column--; 548 } 549 cp += 3; 550 nr -= 3; 551 break; 552 553 case ECHO_OP_SET_CANON_COL: 554 tty->canon_column = tty->column; 555 cp += 2; 556 nr -= 2; 557 break; 558 559 case ECHO_OP_MOVE_BACK_COL: 560 if (tty->column > 0) 561 tty->column--; 562 cp += 2; 563 nr -= 2; 564 break; 565 566 case ECHO_OP_START: 567 /* This is an escaped echo op start code */ 568 if (!space) { 569 no_space_left = 1; 570 break; 571 } 572 tty_put_char(tty, ECHO_OP_START); 573 tty->column++; 574 space--; 575 cp += 2; 576 nr -= 2; 577 break; 578 579 default: 580 /* 581 * If the op is not a special byte code, 582 * it is a ctrl char tagged to be echoed 583 * as "^X" (where X is the letter 584 * representing the control char). 585 * Note that we must ensure there is 586 * enough space for the whole ctrl pair. 587 * 588 */ 589 if (space < 2) { 590 no_space_left = 1; 591 break; 592 } 593 tty_put_char(tty, '^'); 594 tty_put_char(tty, op ^ 0100); 595 tty->column += 2; 596 space -= 2; 597 cp += 2; 598 nr -= 2; 599 } 600 601 if (no_space_left) 602 break; 603 } else { 604 if (O_OPOST(tty) && 605 !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) { 606 int retval = do_output_char(c, tty, space); 607 if (retval < 0) 608 break; 609 space -= retval; 610 } else { 611 if (!space) 612 break; 613 tty_put_char(tty, c); 614 space -= 1; 615 } 616 cp += 1; 617 nr -= 1; 618 } 619 620 /* When end of circular buffer reached, wrap around */ 621 if (cp >= buf_end) 622 cp -= N_TTY_BUF_SIZE; 623 } 624 625 if (nr == 0) { 626 tty->echo_pos = 0; 627 tty->echo_cnt = 0; 628 tty->echo_overrun = 0; 629 } else { 630 int num_processed = tty->echo_cnt - nr; 631 tty->echo_pos += num_processed; 632 tty->echo_pos &= N_TTY_BUF_SIZE - 1; 633 tty->echo_cnt = nr; 634 if (num_processed > 0) 635 tty->echo_overrun = 0; 636 } 637 638 mutex_unlock(&tty->echo_lock); 639 mutex_unlock(&tty->output_lock); 640 641 if (tty->ops->flush_chars) 642 tty->ops->flush_chars(tty); 643} 644 645/** 646 * add_echo_byte - add a byte to the echo buffer 647 * @c: unicode byte to echo 648 * @tty: terminal device 649 * 650 * Add a character or operation byte to the echo buffer. 651 * 652 * Should be called under the echo lock to protect the echo buffer. 653 */ 654 655static void add_echo_byte(unsigned char c, struct tty_struct *tty) 656{ 657 int new_byte_pos; 658 659 if (tty->echo_cnt == N_TTY_BUF_SIZE) { 660 /* Circular buffer is already at capacity */ 661 new_byte_pos = tty->echo_pos; 662 663 /* 664 * Since the buffer start position needs to be advanced, 665 * be sure to step by a whole operation byte group. 666 */ 667 if (tty->echo_buf[tty->echo_pos] == ECHO_OP_START) { 668 if (tty->echo_buf[(tty->echo_pos + 1) & 669 (N_TTY_BUF_SIZE - 1)] == 670 ECHO_OP_ERASE_TAB) { 671 tty->echo_pos += 3; 672 tty->echo_cnt -= 2; 673 } else { 674 tty->echo_pos += 2; 675 tty->echo_cnt -= 1; 676 } 677 } else { 678 tty->echo_pos++; 679 } 680 tty->echo_pos &= N_TTY_BUF_SIZE - 1; 681 682 tty->echo_overrun = 1; 683 } else { 684 new_byte_pos = tty->echo_pos + tty->echo_cnt; 685 new_byte_pos &= N_TTY_BUF_SIZE - 1; 686 tty->echo_cnt++; 687 } 688 689 tty->echo_buf[new_byte_pos] = c; 690} 691 692/** 693 * echo_move_back_col - add operation to move back a column 694 * @tty: terminal device 695 * 696 * Add an operation to the echo buffer to move back one column. 697 * 698 * Locking: echo_lock to protect the echo buffer 699 */ 700 701static void echo_move_back_col(struct tty_struct *tty) 702{ 703 mutex_lock(&tty->echo_lock); 704 705 add_echo_byte(ECHO_OP_START, tty); 706 add_echo_byte(ECHO_OP_MOVE_BACK_COL, tty); 707 708 mutex_unlock(&tty->echo_lock); 709} 710 711/** 712 * echo_set_canon_col - add operation to set the canon column 713 * @tty: terminal device 714 * 715 * Add an operation to the echo buffer to set the canon column 716 * to the current column. 717 * 718 * Locking: echo_lock to protect the echo buffer 719 */ 720 721static void echo_set_canon_col(struct tty_struct *tty) 722{ 723 mutex_lock(&tty->echo_lock); 724 725 add_echo_byte(ECHO_OP_START, tty); 726 add_echo_byte(ECHO_OP_SET_CANON_COL, tty); 727 728 mutex_unlock(&tty->echo_lock); 729} 730 731/** 732 * echo_erase_tab - add operation to erase a tab 733 * @num_chars: number of character columns already used 734 * @after_tab: true if num_chars starts after a previous tab 735 * @tty: terminal device 736 * 737 * Add an operation to the echo buffer to erase a tab. 738 * 739 * Called by the eraser function, which knows how many character 740 * columns have been used since either a previous tab or the start 741 * of input. This information will be used later, along with 742 * canon column (if applicable), to go back the correct number 743 * of columns. 744 * 745 * Locking: echo_lock to protect the echo buffer 746 */ 747 748static void echo_erase_tab(unsigned int num_chars, int after_tab, 749 struct tty_struct *tty) 750{ 751 mutex_lock(&tty->echo_lock); 752 753 add_echo_byte(ECHO_OP_START, tty); 754 add_echo_byte(ECHO_OP_ERASE_TAB, tty); 755 756 /* We only need to know this modulo 8 (tab spacing) */ 757 num_chars &= 7; 758 759 /* Set the high bit as a flag if num_chars is after a previous tab */ 760 if (after_tab) 761 num_chars |= 0x80; 762 763 add_echo_byte(num_chars, tty); 764 765 mutex_unlock(&tty->echo_lock); 766} 767 768/** 769 * echo_char_raw - echo a character raw 770 * @c: unicode byte to echo 771 * @tty: terminal device 772 * 773 * Echo user input back onto the screen. This must be called only when 774 * L_ECHO(tty) is true. Called from the driver receive_buf path. 775 * 776 * This variant does not treat control characters specially. 777 * 778 * Locking: echo_lock to protect the echo buffer 779 */ 780 781static void echo_char_raw(unsigned char c, struct tty_struct *tty) 782{ 783 mutex_lock(&tty->echo_lock); 784 785 if (c == ECHO_OP_START) { 786 add_echo_byte(ECHO_OP_START, tty); 787 add_echo_byte(ECHO_OP_START, tty); 788 } else { 789 add_echo_byte(c, tty); 790 } 791 792 mutex_unlock(&tty->echo_lock); 793} 794 795/** 796 * echo_char - echo a character 797 * @c: unicode byte to echo 798 * @tty: terminal device 799 * 800 * Echo user input back onto the screen. This must be called only when 801 * L_ECHO(tty) is true. Called from the driver receive_buf path. 802 * 803 * This variant tags control characters to be echoed as "^X" 804 * (where X is the letter representing the control char). 805 * 806 * Locking: echo_lock to protect the echo buffer 807 */ 808 809static void echo_char(unsigned char c, struct tty_struct *tty) 810{ 811 mutex_lock(&tty->echo_lock); 812 813 if (c == ECHO_OP_START) { 814 add_echo_byte(ECHO_OP_START, tty); 815 add_echo_byte(ECHO_OP_START, tty); 816 } else { 817 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t') 818 add_echo_byte(ECHO_OP_START, tty); 819 add_echo_byte(c, tty); 820 } 821 822 mutex_unlock(&tty->echo_lock); 823} 824 825/** 826 * finish_erasing - complete erase 827 * @tty: tty doing the erase 828 */ 829 830static inline void finish_erasing(struct tty_struct *tty) 831{ 832 if (tty->erasing) { 833 echo_char_raw('/', tty); 834 tty->erasing = 0; 835 } 836} 837 838/** 839 * eraser - handle erase function 840 * @c: character input 841 * @tty: terminal device 842 * 843 * Perform erase and necessary output when an erase character is 844 * present in the stream from the driver layer. Handles the complexities 845 * of UTF-8 multibyte symbols. 846 * 847 * Locking: read_lock for tty buffers 848 */ 849 850static void eraser(unsigned char c, struct tty_struct *tty) 851{ 852 enum { ERASE, WERASE, KILL } kill_type; 853 int head, seen_alnums, cnt; 854 unsigned long flags; 855 856 if (tty->read_head == tty->canon_head) { 857 /* process_output('\a', tty); */ /* what do you think? */ 858 return; 859 } 860 if (c == ERASE_CHAR(tty)) 861 kill_type = ERASE; 862 else if (c == WERASE_CHAR(tty)) 863 kill_type = WERASE; 864 else { 865 if (!L_ECHO(tty)) { 866 spin_lock_irqsave(&tty->read_lock, flags); 867 tty->read_cnt -= ((tty->read_head - tty->canon_head) & 868 (N_TTY_BUF_SIZE - 1)); 869 tty->read_head = tty->canon_head; 870 spin_unlock_irqrestore(&tty->read_lock, flags); 871 return; 872 } 873 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) { 874 spin_lock_irqsave(&tty->read_lock, flags); 875 tty->read_cnt -= ((tty->read_head - tty->canon_head) & 876 (N_TTY_BUF_SIZE - 1)); 877 tty->read_head = tty->canon_head; 878 spin_unlock_irqrestore(&tty->read_lock, flags); 879 finish_erasing(tty); 880 echo_char(KILL_CHAR(tty), tty); 881 /* Add a newline if ECHOK is on and ECHOKE is off. */ 882 if (L_ECHOK(tty)) 883 echo_char_raw('\n', tty); 884 return; 885 } 886 kill_type = KILL; 887 } 888 889 seen_alnums = 0; 890 while (tty->read_head != tty->canon_head) { 891 head = tty->read_head; 892 893 /* erase a single possibly multibyte character */ 894 do { 895 head = (head - 1) & (N_TTY_BUF_SIZE-1); 896 c = tty->read_buf[head]; 897 } while (is_continuation(c, tty) && head != tty->canon_head); 898 899 /* do not partially erase */ 900 if (is_continuation(c, tty)) 901 break; 902 903 if (kill_type == WERASE) { 904 /* Equivalent to BSD's ALTWERASE. */ 905 if (isalnum(c) || c == '_') 906 seen_alnums++; 907 else if (seen_alnums) 908 break; 909 } 910 cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1); 911 spin_lock_irqsave(&tty->read_lock, flags); 912 tty->read_head = head; 913 tty->read_cnt -= cnt; 914 spin_unlock_irqrestore(&tty->read_lock, flags); 915 if (L_ECHO(tty)) { 916 if (L_ECHOPRT(tty)) { 917 if (!tty->erasing) { 918 echo_char_raw('\\', tty); 919 tty->erasing = 1; 920 } 921 /* if cnt > 1, output a multi-byte character */ 922 echo_char(c, tty); 923 while (--cnt > 0) { 924 head = (head+1) & (N_TTY_BUF_SIZE-1); 925 echo_char_raw(tty->read_buf[head], tty); 926 echo_move_back_col(tty); 927 } 928 } else if (kill_type == ERASE && !L_ECHOE(tty)) { 929 echo_char(ERASE_CHAR(tty), tty); 930 } else if (c == '\t') { 931 unsigned int num_chars = 0; 932 int after_tab = 0; 933 unsigned long tail = tty->read_head; 934 935 /* 936 * Count the columns used for characters 937 * since the start of input or after a 938 * previous tab. 939 * This info is used to go back the correct 940 * number of columns. 941 */ 942 while (tail != tty->canon_head) { 943 tail = (tail-1) & (N_TTY_BUF_SIZE-1); 944 c = tty->read_buf[tail]; 945 if (c == '\t') { 946 after_tab = 1; 947 break; 948 } else if (iscntrl(c)) { 949 if (L_ECHOCTL(tty)) 950 num_chars += 2; 951 } else if (!is_continuation(c, tty)) { 952 num_chars++; 953 } 954 } 955 echo_erase_tab(num_chars, after_tab, tty); 956 } else { 957 if (iscntrl(c) && L_ECHOCTL(tty)) { 958 echo_char_raw('\b', tty); 959 echo_char_raw(' ', tty); 960 echo_char_raw('\b', tty); 961 } 962 if (!iscntrl(c) || L_ECHOCTL(tty)) { 963 echo_char_raw('\b', tty); 964 echo_char_raw(' ', tty); 965 echo_char_raw('\b', tty); 966 } 967 } 968 } 969 if (kill_type == ERASE) 970 break; 971 } 972 if (tty->read_head == tty->canon_head && L_ECHO(tty)) 973 finish_erasing(tty); 974} 975 976/** 977 * isig - handle the ISIG optio 978 * @sig: signal 979 * @tty: terminal 980 * @flush: force flush 981 * 982 * Called when a signal is being sent due to terminal input. This 983 * may caus terminal flushing to take place according to the termios 984 * settings and character used. Called from the driver receive_buf 985 * path so serialized. 986 * 987 * Locking: ctrl_lock, read_lock (both via flush buffer) 988 */ 989 990static inline void isig(int sig, struct tty_struct *tty, int flush) 991{ 992 if (tty->pgrp) 993 kill_pgrp(tty->pgrp, sig, 1); 994 if (flush || !L_NOFLSH(tty)) { 995 n_tty_flush_buffer(tty); 996 tty_driver_flush_buffer(tty); 997 } 998} 999 1000/** 1001 * n_tty_receive_break - handle break 1002 * @tty: terminal 1003 * 1004 * An RS232 break event has been hit in the incoming bitstream. This 1005 * can cause a variety of events depending upon the termios settings. 1006 * 1007 * Called from the receive_buf path so single threaded. 1008 */ 1009 1010static inline void n_tty_receive_break(struct tty_struct *tty) 1011{ 1012 if (I_IGNBRK(tty)) 1013 return; 1014 if (I_BRKINT(tty)) { 1015 isig(SIGINT, tty, 1); 1016 return; 1017 } 1018 if (I_PARMRK(tty)) { 1019 put_tty_queue('\377', tty); 1020 put_tty_queue('\0', tty); 1021 } 1022 put_tty_queue('\0', tty); 1023 wake_up_interruptible(&tty->read_wait); 1024} 1025 1026/** 1027 * n_tty_receive_overrun - handle overrun reporting 1028 * @tty: terminal 1029 * 1030 * Data arrived faster than we could process it. While the tty 1031 * driver has flagged this the bits that were missed are gone 1032 * forever. 1033 * 1034 * Called from the receive_buf path so single threaded. Does not 1035 * need locking as num_overrun and overrun_time are function 1036 * private. 1037 */ 1038 1039static inline void n_tty_receive_overrun(struct tty_struct *tty) 1040{ 1041 char buf[64]; 1042 1043 tty->num_overrun++; 1044 if (time_before(tty->overrun_time, jiffies - HZ) || 1045 time_after(tty->overrun_time, jiffies)) { 1046 printk(KERN_WARNING "%s: %d input overrun(s)\n", 1047 tty_name(tty, buf), 1048 tty->num_overrun); 1049 tty->overrun_time = jiffies; 1050 tty->num_overrun = 0; 1051 } 1052} 1053 1054/** 1055 * n_tty_receive_parity_error - error notifier 1056 * @tty: terminal device 1057 * @c: character 1058 * 1059 * Process a parity error and queue the right data to indicate 1060 * the error case if necessary. Locking as per n_tty_receive_buf. 1061 */ 1062static inline void n_tty_receive_parity_error(struct tty_struct *tty, 1063 unsigned char c) 1064{ 1065 if (I_IGNPAR(tty)) 1066 return; 1067 if (I_PARMRK(tty)) { 1068 put_tty_queue('\377', tty); 1069 put_tty_queue('\0', tty); 1070 put_tty_queue(c, tty); 1071 } else if (I_INPCK(tty)) 1072 put_tty_queue('\0', tty); 1073 else 1074 put_tty_queue(c, tty); 1075 wake_up_interruptible(&tty->read_wait); 1076} 1077 1078/** 1079 * n_tty_receive_char - perform processing 1080 * @tty: terminal device 1081 * @c: character 1082 * 1083 * Process an individual character of input received from the driver. 1084 * This is serialized with respect to itself by the rules for the 1085 * driver above. 1086 */ 1087 1088static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c) 1089{ 1090 unsigned long flags; 1091 int parmrk; 1092 1093 if (tty->raw) { 1094 put_tty_queue(c, tty); 1095 return; 1096 } 1097 1098 if (I_ISTRIP(tty)) 1099 c &= 0x7f; 1100 if (I_IUCLC(tty) && L_IEXTEN(tty)) 1101 c = tolower(c); 1102 1103 if (L_EXTPROC(tty)) { 1104 put_tty_queue(c, tty); 1105 return; 1106 } 1107 1108 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && 1109 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) && 1110 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) { 1111 start_tty(tty); 1112 process_echoes(tty); 1113 } 1114 1115 if (tty->closing) { 1116 if (I_IXON(tty)) { 1117 if (c == START_CHAR(tty)) { 1118 start_tty(tty); 1119 process_echoes(tty); 1120 } else if (c == STOP_CHAR(tty)) 1121 stop_tty(tty); 1122 } 1123 return; 1124 } 1125 1126 /* 1127 * If the previous character was LNEXT, or we know that this 1128 * character is not one of the characters that we'll have to 1129 * handle specially, do shortcut processing to speed things 1130 * up. 1131 */ 1132 if (!test_bit(c, tty->process_char_map) || tty->lnext) { 1133 tty->lnext = 0; 1134 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0; 1135 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) { 1136 /* beep if no space */ 1137 if (L_ECHO(tty)) 1138 process_output('\a', tty); 1139 return; 1140 } 1141 if (L_ECHO(tty)) { 1142 finish_erasing(tty); 1143 /* Record the column of first canon char. */ 1144 if (tty->canon_head == tty->read_head) 1145 echo_set_canon_col(tty); 1146 echo_char(c, tty); 1147 process_echoes(tty); 1148 } 1149 if (parmrk) 1150 put_tty_queue(c, tty); 1151 put_tty_queue(c, tty); 1152 return; 1153 } 1154 1155 if (I_IXON(tty)) { 1156 if (c == START_CHAR(tty)) { 1157 start_tty(tty); 1158 process_echoes(tty); 1159 return; 1160 } 1161 if (c == STOP_CHAR(tty)) { 1162 stop_tty(tty); 1163 return; 1164 } 1165 } 1166 1167 if (L_ISIG(tty)) { 1168 int signal; 1169 signal = SIGINT; 1170 if (c == INTR_CHAR(tty)) 1171 goto send_signal; 1172 signal = SIGQUIT; 1173 if (c == QUIT_CHAR(tty)) 1174 goto send_signal; 1175 signal = SIGTSTP; 1176 if (c == SUSP_CHAR(tty)) { 1177send_signal: 1178 /* 1179 * Note that we do not use isig() here because we want 1180 * the order to be: 1181 * 1) flush, 2) echo, 3) signal 1182 */ 1183 if (!L_NOFLSH(tty)) { 1184 n_tty_flush_buffer(tty); 1185 tty_driver_flush_buffer(tty); 1186 } 1187 if (I_IXON(tty)) 1188 start_tty(tty); 1189 if (L_ECHO(tty)) { 1190 echo_char(c, tty); 1191 process_echoes(tty); 1192 } 1193 if (tty->pgrp) 1194 kill_pgrp(tty->pgrp, signal, 1); 1195 return; 1196 } 1197 } 1198 1199 if (c == '\r') { 1200 if (I_IGNCR(tty)) 1201 return; 1202 if (I_ICRNL(tty)) 1203 c = '\n'; 1204 } else if (c == '\n' && I_INLCR(tty)) 1205 c = '\r'; 1206 1207 if (tty->icanon) { 1208 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) || 1209 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) { 1210 eraser(c, tty); 1211 process_echoes(tty); 1212 return; 1213 } 1214 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) { 1215 tty->lnext = 1; 1216 if (L_ECHO(tty)) { 1217 finish_erasing(tty); 1218 if (L_ECHOCTL(tty)) { 1219 echo_char_raw('^', tty); 1220 echo_char_raw('\b', tty); 1221 process_echoes(tty); 1222 } 1223 } 1224 return; 1225 } 1226 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && 1227 L_IEXTEN(tty)) { 1228 unsigned long tail = tty->canon_head; 1229 1230 finish_erasing(tty); 1231 echo_char(c, tty); 1232 echo_char_raw('\n', tty); 1233 while (tail != tty->read_head) { 1234 echo_char(tty->read_buf[tail], tty); 1235 tail = (tail+1) & (N_TTY_BUF_SIZE-1); 1236 } 1237 process_echoes(tty); 1238 return; 1239 } 1240 if (c == '\n') { 1241 if (tty->read_cnt >= N_TTY_BUF_SIZE) { 1242 if (L_ECHO(tty)) 1243 process_output('\a', tty); 1244 return; 1245 } 1246 if (L_ECHO(tty) || L_ECHONL(tty)) { 1247 echo_char_raw('\n', tty); 1248 process_echoes(tty); 1249 } 1250 goto handle_newline; 1251 } 1252 if (c == EOF_CHAR(tty)) { 1253 if (tty->read_cnt >= N_TTY_BUF_SIZE) 1254 return; 1255 if (tty->canon_head != tty->read_head) 1256 set_bit(TTY_PUSH, &tty->flags); 1257 c = __DISABLED_CHAR; 1258 goto handle_newline; 1259 } 1260 if ((c == EOL_CHAR(tty)) || 1261 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) { 1262 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) 1263 ? 1 : 0; 1264 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) { 1265 if (L_ECHO(tty)) 1266 process_output('\a', tty); 1267 return; 1268 } 1269 if (L_ECHO(tty)) { 1270 /* Record the column of first canon char. */ 1271 if (tty->canon_head == tty->read_head) 1272 echo_set_canon_col(tty); 1273 echo_char(c, tty); 1274 process_echoes(tty); 1275 } 1276 if (parmrk) 1277 put_tty_queue(c, tty); 1278 1279handle_newline: 1280 spin_lock_irqsave(&tty->read_lock, flags); 1281 set_bit(tty->read_head, tty->read_flags); 1282 put_tty_queue_nolock(c, tty); 1283 tty->canon_head = tty->read_head; 1284 tty->canon_data++; 1285 spin_unlock_irqrestore(&tty->read_lock, flags); 1286 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 1287 if (waitqueue_active(&tty->read_wait)) 1288 wake_up_interruptible(&tty->read_wait); 1289 return; 1290 } 1291 } 1292 1293 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0; 1294 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) { 1295 /* beep if no space */ 1296 if (L_ECHO(tty)) 1297 process_output('\a', tty); 1298 return; 1299 } 1300 if (L_ECHO(tty)) { 1301 finish_erasing(tty); 1302 if (c == '\n') 1303 echo_char_raw('\n', tty); 1304 else { 1305 /* Record the column of first canon char. */ 1306 if (tty->canon_head == tty->read_head) 1307 echo_set_canon_col(tty); 1308 echo_char(c, tty); 1309 } 1310 process_echoes(tty); 1311 } 1312 1313 if (parmrk) 1314 put_tty_queue(c, tty); 1315 1316 put_tty_queue(c, tty); 1317} 1318 1319 1320/** 1321 * n_tty_write_wakeup - asynchronous I/O notifier 1322 * @tty: tty device 1323 * 1324 * Required for the ptys, serial driver etc. since processes 1325 * that attach themselves to the master and rely on ASYNC 1326 * IO must be woken up 1327 */ 1328 1329static void n_tty_write_wakeup(struct tty_struct *tty) 1330{ 1331 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) 1332 kill_fasync(&tty->fasync, SIGIO, POLL_OUT); 1333} 1334 1335/** 1336 * n_tty_receive_buf - data receive 1337 * @tty: terminal device 1338 * @cp: buffer 1339 * @fp: flag buffer 1340 * @count: characters 1341 * 1342 * Called by the terminal driver when a block of characters has 1343 * been received. This function must be called from soft contexts 1344 * not from interrupt context. The driver is responsible for making 1345 * calls one at a time and in order (or using flush_to_ldisc) 1346 */ 1347 1348static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp, 1349 char *fp, int count) 1350{ 1351 const unsigned char *p; 1352 char *f, flags = TTY_NORMAL; 1353 int i; 1354 char buf[64]; 1355 unsigned long cpuflags; 1356 1357 if (!tty->read_buf) 1358 return; 1359 1360 if (tty->real_raw) { 1361 spin_lock_irqsave(&tty->read_lock, cpuflags); 1362 i = min(N_TTY_BUF_SIZE - tty->read_cnt, 1363 N_TTY_BUF_SIZE - tty->read_head); 1364 i = min(count, i); 1365 memcpy(tty->read_buf + tty->read_head, cp, i); 1366 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1); 1367 tty->read_cnt += i; 1368 cp += i; 1369 count -= i; 1370 1371 i = min(N_TTY_BUF_SIZE - tty->read_cnt, 1372 N_TTY_BUF_SIZE - tty->read_head); 1373 i = min(count, i); 1374 memcpy(tty->read_buf + tty->read_head, cp, i); 1375 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1); 1376 tty->read_cnt += i; 1377 spin_unlock_irqrestore(&tty->read_lock, cpuflags); 1378 } else { 1379 for (i = count, p = cp, f = fp; i; i--, p++) { 1380 if (f) 1381 flags = *f++; 1382 switch (flags) { 1383 case TTY_NORMAL: 1384 n_tty_receive_char(tty, *p); 1385 break; 1386 case TTY_BREAK: 1387 n_tty_receive_break(tty); 1388 break; 1389 case TTY_PARITY: 1390 case TTY_FRAME: 1391 n_tty_receive_parity_error(tty, *p); 1392 break; 1393 case TTY_OVERRUN: 1394 n_tty_receive_overrun(tty); 1395 break; 1396 default: 1397 printk(KERN_ERR "%s: unknown flag %d\n", 1398 tty_name(tty, buf), flags); 1399 break; 1400 } 1401 } 1402 if (tty->ops->flush_chars) 1403 tty->ops->flush_chars(tty); 1404 } 1405 1406 n_tty_set_room(tty); 1407 1408 if ((!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) || 1409 L_EXTPROC(tty)) { 1410 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 1411 if (waitqueue_active(&tty->read_wait)) 1412 wake_up_interruptible(&tty->read_wait); 1413 } 1414 1415 /* 1416 * Check the remaining room for the input canonicalization 1417 * mode. We don't want to throttle the driver if we're in 1418 * canonical mode and don't have a newline yet! 1419 */ 1420 if (tty->receive_room < TTY_THRESHOLD_THROTTLE) 1421 tty_throttle(tty); 1422} 1423 1424int is_ignored(int sig) 1425{ 1426 return (sigismember(¤t->blocked, sig) || 1427 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN); 1428} 1429 1430/** 1431 * n_tty_set_termios - termios data changed 1432 * @tty: terminal 1433 * @old: previous data 1434 * 1435 * Called by the tty layer when the user changes termios flags so 1436 * that the line discipline can plan ahead. This function cannot sleep 1437 * and is protected from re-entry by the tty layer. The user is 1438 * guaranteed that this function will not be re-entered or in progress 1439 * when the ldisc is closed. 1440 * 1441 * Locking: Caller holds tty->termios_mutex 1442 */ 1443 1444static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old) 1445{ 1446 int canon_change = 1; 1447 BUG_ON(!tty); 1448 1449 if (old) 1450 canon_change = (old->c_lflag ^ tty->termios->c_lflag) & ICANON; 1451 if (canon_change) { 1452 memset(&tty->read_flags, 0, sizeof tty->read_flags); 1453 tty->canon_head = tty->read_tail; 1454 tty->canon_data = 0; 1455 tty->erasing = 0; 1456 } 1457 1458 if (canon_change && !L_ICANON(tty) && tty->read_cnt) 1459 wake_up_interruptible(&tty->read_wait); 1460 1461 tty->icanon = (L_ICANON(tty) != 0); 1462 if (test_bit(TTY_HW_COOK_IN, &tty->flags)) { 1463 tty->raw = 1; 1464 tty->real_raw = 1; 1465 n_tty_set_room(tty); 1466 return; 1467 } 1468 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) || 1469 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) || 1470 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) || 1471 I_PARMRK(tty)) { 1472 memset(tty->process_char_map, 0, 256/8); 1473 1474 if (I_IGNCR(tty) || I_ICRNL(tty)) 1475 set_bit('\r', tty->process_char_map); 1476 if (I_INLCR(tty)) 1477 set_bit('\n', tty->process_char_map); 1478 1479 if (L_ICANON(tty)) { 1480 set_bit(ERASE_CHAR(tty), tty->process_char_map); 1481 set_bit(KILL_CHAR(tty), tty->process_char_map); 1482 set_bit(EOF_CHAR(tty), tty->process_char_map); 1483 set_bit('\n', tty->process_char_map); 1484 set_bit(EOL_CHAR(tty), tty->process_char_map); 1485 if (L_IEXTEN(tty)) { 1486 set_bit(WERASE_CHAR(tty), 1487 tty->process_char_map); 1488 set_bit(LNEXT_CHAR(tty), 1489 tty->process_char_map); 1490 set_bit(EOL2_CHAR(tty), 1491 tty->process_char_map); 1492 if (L_ECHO(tty)) 1493 set_bit(REPRINT_CHAR(tty), 1494 tty->process_char_map); 1495 } 1496 } 1497 if (I_IXON(tty)) { 1498 set_bit(START_CHAR(tty), tty->process_char_map); 1499 set_bit(STOP_CHAR(tty), tty->process_char_map); 1500 } 1501 if (L_ISIG(tty)) { 1502 set_bit(INTR_CHAR(tty), tty->process_char_map); 1503 set_bit(QUIT_CHAR(tty), tty->process_char_map); 1504 set_bit(SUSP_CHAR(tty), tty->process_char_map); 1505 } 1506 clear_bit(__DISABLED_CHAR, tty->process_char_map); 1507 tty->raw = 0; 1508 tty->real_raw = 0; 1509 } else { 1510 tty->raw = 1; 1511 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) && 1512 (I_IGNPAR(tty) || !I_INPCK(tty)) && 1513 (tty->driver->flags & TTY_DRIVER_REAL_RAW)) 1514 tty->real_raw = 1; 1515 else 1516 tty->real_raw = 0; 1517 } 1518 n_tty_set_room(tty); 1519 /* The termios change make the tty ready for I/O */ 1520 wake_up_interruptible(&tty->write_wait); 1521 wake_up_interruptible(&tty->read_wait); 1522} 1523 1524/** 1525 * n_tty_close - close the ldisc for this tty 1526 * @tty: device 1527 * 1528 * Called from the terminal layer when this line discipline is 1529 * being shut down, either because of a close or becsuse of a 1530 * discipline change. The function will not be called while other 1531 * ldisc methods are in progress. 1532 */ 1533 1534static void n_tty_close(struct tty_struct *tty) 1535{ 1536 n_tty_flush_buffer(tty); 1537 if (tty->read_buf) { 1538 kfree(tty->read_buf); 1539 tty->read_buf = NULL; 1540 } 1541 if (tty->echo_buf) { 1542 kfree(tty->echo_buf); 1543 tty->echo_buf = NULL; 1544 } 1545} 1546 1547/** 1548 * n_tty_open - open an ldisc 1549 * @tty: terminal to open 1550 * 1551 * Called when this line discipline is being attached to the 1552 * terminal device. Can sleep. Called serialized so that no 1553 * other events will occur in parallel. No further open will occur 1554 * until a close. 1555 */ 1556 1557static int n_tty_open(struct tty_struct *tty) 1558{ 1559 if (!tty) 1560 return -EINVAL; 1561 1562 /* These are ugly. Currently a malloc failure here can panic */ 1563 if (!tty->read_buf) { 1564 tty->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL); 1565 if (!tty->read_buf) 1566 return -ENOMEM; 1567 } 1568 if (!tty->echo_buf) { 1569 tty->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL); 1570 1571 if (!tty->echo_buf) 1572 return -ENOMEM; 1573 } 1574 reset_buffer_flags(tty); 1575 tty->column = 0; 1576 n_tty_set_termios(tty, NULL); 1577 tty->minimum_to_wake = 1; 1578 tty->closing = 0; 1579 return 0; 1580} 1581 1582static inline int input_available_p(struct tty_struct *tty, int amt) 1583{ 1584 tty_flush_to_ldisc(tty); 1585 if (tty->icanon && !L_EXTPROC(tty)) { 1586 if (tty->canon_data) 1587 return 1; 1588 } else if (tty->read_cnt >= (amt ? amt : 1)) 1589 return 1; 1590 1591 return 0; 1592} 1593 1594/** 1595 * copy_from_read_buf - copy read data directly 1596 * @tty: terminal device 1597 * @b: user data 1598 * @nr: size of data 1599 * 1600 * Helper function to speed up n_tty_read. It is only called when 1601 * ICANON is off; it copies characters straight from the tty queue to 1602 * user space directly. It can be profitably called twice; once to 1603 * drain the space from the tail pointer to the (physical) end of the 1604 * buffer, and once to drain the space from the (physical) beginning of 1605 * the buffer to head pointer. 1606 * 1607 * Called under the tty->atomic_read_lock sem 1608 * 1609 */ 1610 1611static int copy_from_read_buf(struct tty_struct *tty, 1612 unsigned char __user **b, 1613 size_t *nr) 1614 1615{ 1616 int retval; 1617 size_t n; 1618 unsigned long flags; 1619 1620 retval = 0; 1621 spin_lock_irqsave(&tty->read_lock, flags); 1622 n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail); 1623 n = min(*nr, n); 1624 spin_unlock_irqrestore(&tty->read_lock, flags); 1625 if (n) { 1626 retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n); 1627 n -= retval; 1628 tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n); 1629 spin_lock_irqsave(&tty->read_lock, flags); 1630 tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1); 1631 tty->read_cnt -= n; 1632 /* Turn single EOF into zero-length read */ 1633 if (L_EXTPROC(tty) && tty->icanon && n == 1) { 1634 if (!tty->read_cnt && (*b)[n-1] == EOF_CHAR(tty)) 1635 n--; 1636 } 1637 spin_unlock_irqrestore(&tty->read_lock, flags); 1638 *b += n; 1639 *nr -= n; 1640 } 1641 return retval; 1642} 1643 1644extern ssize_t redirected_tty_write(struct file *, const char __user *, 1645 size_t, loff_t *); 1646 1647 1648static int job_control(struct tty_struct *tty, struct file *file) 1649{ 1650 /* Job control check -- must be done at start and after 1651 every sleep (POSIX.1 7.1.1.4). */ 1652 /* NOTE: not yet done after every sleep pending a thorough 1653 check of the logic of this change. -- jlc */ 1654 /* don't stop on /dev/console */ 1655 if (file->f_op->write != redirected_tty_write && 1656 current->signal->tty == tty) { 1657 if (!tty->pgrp) 1658 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n"); 1659 else if (task_pgrp(current) != tty->pgrp) { 1660 if (is_ignored(SIGTTIN) || 1661 is_current_pgrp_orphaned()) 1662 return -EIO; 1663 kill_pgrp(task_pgrp(current), SIGTTIN, 1); 1664 set_thread_flag(TIF_SIGPENDING); 1665 return -ERESTARTSYS; 1666 } 1667 } 1668 return 0; 1669} 1670 1671 1672/** 1673 * n_tty_read - read function for tty 1674 * @tty: tty device 1675 * @file: file object 1676 * @buf: userspace buffer pointer 1677 * @nr: size of I/O 1678 * 1679 * Perform reads for the line discipline. We are guaranteed that the 1680 * line discipline will not be closed under us but we may get multiple 1681 * parallel readers and must handle this ourselves. We may also get 1682 * a hangup. Always called in user context, may sleep. 1683 * 1684 * This code must be sure never to sleep through a hangup. 1685 */ 1686 1687static ssize_t n_tty_read(struct tty_struct *tty, struct file *file, 1688 unsigned char __user *buf, size_t nr) 1689{ 1690 unsigned char __user *b = buf; 1691 DEFINE_WAIT_FUNC(wait, woken_wake_function); 1692 int c; 1693 int minimum, time; 1694 ssize_t retval = 0; 1695 ssize_t size; 1696 long timeout; 1697 unsigned long flags; 1698 int packet; 1699 1700do_it_again: 1701 1702 BUG_ON(!tty->read_buf); 1703 1704 c = job_control(tty, file); 1705 if (c < 0) 1706 return c; 1707 1708 minimum = time = 0; 1709 timeout = MAX_SCHEDULE_TIMEOUT; 1710 if (!tty->icanon) { 1711 time = (HZ / 10) * TIME_CHAR(tty); 1712 minimum = MIN_CHAR(tty); 1713 if (minimum) { 1714 if (time) 1715 tty->minimum_to_wake = 1; 1716 else if (!waitqueue_active(&tty->read_wait) || 1717 (tty->minimum_to_wake > minimum)) 1718 tty->minimum_to_wake = minimum; 1719 } else { 1720 timeout = 0; 1721 if (time) { 1722 timeout = time; 1723 time = 0; 1724 } 1725 tty->minimum_to_wake = minimum = 1; 1726 } 1727 } 1728 1729 /* 1730 * Internal serialization of reads. 1731 */ 1732 if (file->f_flags & O_NONBLOCK) { 1733 if (!mutex_trylock(&tty->atomic_read_lock)) 1734 return -EAGAIN; 1735 } else { 1736 if (mutex_lock_interruptible(&tty->atomic_read_lock)) 1737 return -ERESTARTSYS; 1738 } 1739 packet = tty->packet; 1740 1741 add_wait_queue(&tty->read_wait, &wait); 1742 while (nr) { 1743 /* First test for status change. */ 1744 if (packet && tty->link->ctrl_status) { 1745 unsigned char cs; 1746 if (b != buf) 1747 break; 1748 spin_lock_irqsave(&tty->link->ctrl_lock, flags); 1749 cs = tty->link->ctrl_status; 1750 tty->link->ctrl_status = 0; 1751 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags); 1752 if (tty_put_user(tty, cs, b++)) { 1753 retval = -EFAULT; 1754 b--; 1755 break; 1756 } 1757 nr--; 1758 break; 1759 } 1760 1761 if (((minimum - (b - buf)) < tty->minimum_to_wake) && 1762 ((minimum - (b - buf)) >= 1)) 1763 tty->minimum_to_wake = (minimum - (b - buf)); 1764 1765 if (!input_available_p(tty, 0)) { 1766 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) { 1767 retval = -EIO; 1768 break; 1769 } 1770 if (tty_hung_up_p(file)) 1771 break; 1772 if (!timeout) 1773 break; 1774 if (file->f_flags & O_NONBLOCK) { 1775 retval = -EAGAIN; 1776 break; 1777 } 1778 if (signal_pending(current)) { 1779 retval = -ERESTARTSYS; 1780 break; 1781 } 1782 n_tty_set_room(tty); 1783 timeout = wait_woken(&wait, TASK_INTERRUPTIBLE, timeout); 1784 continue; 1785 } 1786 1787 /* Deal with packet mode. */ 1788 if (packet && b == buf) { 1789 if (tty_put_user(tty, TIOCPKT_DATA, b++)) { 1790 retval = -EFAULT; 1791 b--; 1792 break; 1793 } 1794 nr--; 1795 } 1796 1797 if (tty->icanon && !L_EXTPROC(tty)) { 1798 /* N.B. avoid overrun if nr == 0 */ 1799 while (nr && tty->read_cnt) { 1800 int eol; 1801 1802 eol = test_and_clear_bit(tty->read_tail, 1803 tty->read_flags); 1804 c = tty->read_buf[tty->read_tail]; 1805 spin_lock_irqsave(&tty->read_lock, flags); 1806 tty->read_tail = ((tty->read_tail+1) & 1807 (N_TTY_BUF_SIZE-1)); 1808 tty->read_cnt--; 1809 if (eol) { 1810 /* this test should be redundant: 1811 * we shouldn't be reading data if 1812 * canon_data is 0 1813 */ 1814 if (--tty->canon_data < 0) 1815 tty->canon_data = 0; 1816 } 1817 spin_unlock_irqrestore(&tty->read_lock, flags); 1818 1819 if (!eol || (c != __DISABLED_CHAR)) { 1820 if (tty_put_user(tty, c, b++)) { 1821 retval = -EFAULT; 1822 b--; 1823 break; 1824 } 1825 nr--; 1826 } 1827 if (eol) { 1828 tty_audit_push(tty); 1829 break; 1830 } 1831 } 1832 if (retval) 1833 break; 1834 } else { 1835 int uncopied; 1836 /* The copy function takes the read lock and handles 1837 locking internally for this case */ 1838 uncopied = copy_from_read_buf(tty, &b, &nr); 1839 uncopied += copy_from_read_buf(tty, &b, &nr); 1840 if (uncopied) { 1841 retval = -EFAULT; 1842 break; 1843 } 1844 } 1845 1846 /* If there is enough space in the read buffer now, let the 1847 * low-level driver know. We use n_tty_chars_in_buffer() to 1848 * check the buffer, as it now knows about canonical mode. 1849 * Otherwise, if the driver is throttled and the line is 1850 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode, 1851 * we won't get any more characters. 1852 */ 1853 if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) { 1854 n_tty_set_room(tty); 1855 check_unthrottle(tty); 1856 } 1857 1858 if (b - buf >= minimum) 1859 break; 1860 if (time) 1861 timeout = time; 1862 } 1863 mutex_unlock(&tty->atomic_read_lock); 1864 remove_wait_queue(&tty->read_wait, &wait); 1865 1866 if (!waitqueue_active(&tty->read_wait)) 1867 tty->minimum_to_wake = minimum; 1868 1869 size = b - buf; 1870 if (size) { 1871 retval = size; 1872 if (nr) 1873 clear_bit(TTY_PUSH, &tty->flags); 1874 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags)) 1875 goto do_it_again; 1876 1877 n_tty_set_room(tty); 1878 return retval; 1879} 1880 1881/** 1882 * n_tty_write - write function for tty 1883 * @tty: tty device 1884 * @file: file object 1885 * @buf: userspace buffer pointer 1886 * @nr: size of I/O 1887 * 1888 * Write function of the terminal device. This is serialized with 1889 * respect to other write callers but not to termios changes, reads 1890 * and other such events. Since the receive code will echo characters, 1891 * thus calling driver write methods, the output_lock is used in 1892 * the output processing functions called here as well as in the 1893 * echo processing function to protect the column state and space 1894 * left in the buffer. 1895 * 1896 * This code must be sure never to sleep through a hangup. 1897 * 1898 * Locking: output_lock to protect column state and space left 1899 * (note that the process_output*() functions take this 1900 * lock themselves) 1901 */ 1902 1903static ssize_t n_tty_write(struct tty_struct *tty, struct file *file, 1904 const unsigned char *buf, size_t nr) 1905{ 1906 const unsigned char *b = buf; 1907 DEFINE_WAIT_FUNC(wait, woken_wake_function); 1908 int c; 1909 ssize_t retval = 0; 1910 1911 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */ 1912 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) { 1913 retval = tty_check_change(tty); 1914 if (retval) 1915 return retval; 1916 } 1917 1918 /* Write out any echoed characters that are still pending */ 1919 process_echoes(tty); 1920 1921 add_wait_queue(&tty->write_wait, &wait); 1922 while (1) { 1923 if (signal_pending(current)) { 1924 retval = -ERESTARTSYS; 1925 break; 1926 } 1927 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) { 1928 retval = -EIO; 1929 break; 1930 } 1931 if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) { 1932 while (nr > 0) { 1933 ssize_t num = process_output_block(tty, b, nr); 1934 if (num < 0) { 1935 if (num == -EAGAIN) 1936 break; 1937 retval = num; 1938 goto break_out; 1939 } 1940 b += num; 1941 nr -= num; 1942 if (nr == 0) 1943 break; 1944 c = *b; 1945 if (process_output(c, tty) < 0) 1946 break; 1947 b++; nr--; 1948 } 1949 if (tty->ops->flush_chars) 1950 tty->ops->flush_chars(tty); 1951 } else { 1952 while (nr > 0) { 1953 c = tty->ops->write(tty, b, nr); 1954 if (c < 0) { 1955 retval = c; 1956 goto break_out; 1957 } 1958 if (!c) 1959 break; 1960 b += c; 1961 nr -= c; 1962 } 1963 } 1964 if (!nr) 1965 break; 1966 if (file->f_flags & O_NONBLOCK) { 1967 retval = -EAGAIN; 1968 break; 1969 } 1970 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT); 1971 } 1972break_out: 1973 remove_wait_queue(&tty->write_wait, &wait); 1974 if (b - buf != nr && tty->fasync) 1975 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 1976 return (b - buf) ? b - buf : retval; 1977} 1978 1979/** 1980 * n_tty_poll - poll method for N_TTY 1981 * @tty: terminal device 1982 * @file: file accessing it 1983 * @wait: poll table 1984 * 1985 * Called when the line discipline is asked to poll() for data or 1986 * for special events. This code is not serialized with respect to 1987 * other events save open/close. 1988 * 1989 * This code must be sure never to sleep through a hangup. 1990 * Called without the kernel lock held - fine 1991 */ 1992 1993static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file, 1994 poll_table *wait) 1995{ 1996 unsigned int mask = 0; 1997 1998 poll_wait(file, &tty->read_wait, wait); 1999 poll_wait(file, &tty->write_wait, wait); 2000 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty))) 2001 mask |= POLLIN | POLLRDNORM; 2002 if (tty->packet && tty->link->ctrl_status) 2003 mask |= POLLPRI | POLLIN | POLLRDNORM; 2004 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) 2005 mask |= POLLHUP; 2006 if (tty_hung_up_p(file)) 2007 mask |= POLLHUP; 2008 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) { 2009 if (MIN_CHAR(tty) && !TIME_CHAR(tty)) 2010 tty->minimum_to_wake = MIN_CHAR(tty); 2011 else 2012 tty->minimum_to_wake = 1; 2013 } 2014 if (tty->ops->write && !tty_is_writelocked(tty) && 2015 tty_chars_in_buffer(tty) < WAKEUP_CHARS && 2016 tty_write_room(tty) > 0) 2017 mask |= POLLOUT | POLLWRNORM; 2018 return mask; 2019} 2020 2021static unsigned long inq_canon(struct tty_struct *tty) 2022{ 2023 int nr, head, tail; 2024 2025 if (!tty->canon_data) 2026 return 0; 2027 head = tty->canon_head; 2028 tail = tty->read_tail; 2029 nr = (head - tail) & (N_TTY_BUF_SIZE-1); 2030 /* Skip EOF-chars.. */ 2031 while (head != tail) { 2032 if (test_bit(tail, tty->read_flags) && 2033 tty->read_buf[tail] == __DISABLED_CHAR) 2034 nr--; 2035 tail = (tail+1) & (N_TTY_BUF_SIZE-1); 2036 } 2037 return nr; 2038} 2039 2040static int n_tty_ioctl(struct tty_struct *tty, struct file *file, 2041 unsigned int cmd, unsigned long arg) 2042{ 2043 int retval; 2044 2045 switch (cmd) { 2046 case TIOCOUTQ: 2047 return put_user(tty_chars_in_buffer(tty), (int __user *) arg); 2048 case TIOCINQ: 2049 retval = tty->read_cnt; 2050 if (L_ICANON(tty)) 2051 retval = inq_canon(tty); 2052 return put_user(retval, (unsigned int __user *) arg); 2053 default: 2054 return n_tty_ioctl_helper(tty, file, cmd, arg); 2055 } 2056} 2057 2058struct tty_ldisc_ops tty_ldisc_N_TTY = { 2059 .magic = TTY_LDISC_MAGIC, 2060 .name = "n_tty", 2061 .open = n_tty_open, 2062 .close = n_tty_close, 2063 .flush_buffer = n_tty_flush_buffer, 2064 .chars_in_buffer = n_tty_chars_in_buffer, 2065 .read = n_tty_read, 2066 .write = n_tty_write, 2067 .ioctl = n_tty_ioctl, 2068 .set_termios = n_tty_set_termios, 2069 .poll = n_tty_poll, 2070 .receive_buf = n_tty_receive_buf, 2071 .write_wakeup = n_tty_write_wakeup 2072}; 2073 2074/** 2075 * n_tty_inherit_ops - inherit N_TTY methods 2076 * @ops: struct tty_ldisc_ops where to save N_TTY methods 2077 * 2078 * Used by a generic struct tty_ldisc_ops to easily inherit N_TTY 2079 * methods. 2080 */ 2081 2082void n_tty_inherit_ops(struct tty_ldisc_ops *ops) 2083{ 2084 *ops = tty_ldisc_N_TTY; 2085 ops->owner = NULL; 2086 ops->refcount = ops->flags = 0; 2087} 2088EXPORT_SYMBOL_GPL(n_tty_inherit_ops); 2089