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 #include <linux/ratelimit.h> 53 #include <linux/vmalloc.h> 54 55 56 /* number of characters left in xmit buffer before select has we have room */ 57 #define WAKEUP_CHARS 256 58 59 /* 60 * This defines the low- and high-watermarks for throttling and 61 * unthrottling the TTY driver. These watermarks are used for 62 * controlling the space in the read buffer. 63 */ 64 #define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */ 65 #define TTY_THRESHOLD_UNTHROTTLE 128 66 67 /* 68 * Special byte codes used in the echo buffer to represent operations 69 * or special handling of characters. Bytes in the echo buffer that 70 * are not part of such special blocks are treated as normal character 71 * codes. 72 */ 73 #define ECHO_OP_START 0xff 74 #define ECHO_OP_MOVE_BACK_COL 0x80 75 #define ECHO_OP_SET_CANON_COL 0x81 76 #define ECHO_OP_ERASE_TAB 0x82 77 78 #define ECHO_COMMIT_WATERMARK 256 79 #define ECHO_BLOCK 256 80 #define ECHO_DISCARD_WATERMARK N_TTY_BUF_SIZE - (ECHO_BLOCK + 32) 81 82 83 #undef N_TTY_TRACE 84 #ifdef N_TTY_TRACE 85 # define n_tty_trace(f, args...) trace_printk(f, ##args) 86 #else 87 # define n_tty_trace(f, args...) 88 #endif 89 90 struct n_tty_data { 91 /* producer-published */ 92 size_t read_head; 93 size_t commit_head; 94 size_t canon_head; 95 size_t echo_head; 96 size_t echo_commit; 97 size_t echo_mark; 98 DECLARE_BITMAP(char_map, 256); 99 100 /* private to n_tty_receive_overrun (single-threaded) */ 101 unsigned long overrun_time; 102 int num_overrun; 103 104 /* non-atomic */ 105 bool no_room; 106 107 /* must hold exclusive termios_rwsem to reset these */ 108 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1; 109 unsigned char push:1; 110 111 /* shared by producer and consumer */ 112 char read_buf[N_TTY_BUF_SIZE]; 113 DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE); 114 unsigned char echo_buf[N_TTY_BUF_SIZE]; 115 116 int minimum_to_wake; 117 118 /* consumer-published */ 119 size_t read_tail; 120 size_t line_start; 121 122 /* protected by output lock */ 123 unsigned int column; 124 unsigned int canon_column; 125 size_t echo_tail; 126 127 struct mutex atomic_read_lock; 128 struct mutex output_lock; 129 }; 130 131 static inline size_t read_cnt(struct n_tty_data *ldata) 132 { 133 return ldata->read_head - ldata->read_tail; 134 } 135 136 static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i) 137 { 138 return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)]; 139 } 140 141 static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i) 142 { 143 return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)]; 144 } 145 146 static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i) 147 { 148 return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)]; 149 } 150 151 static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i) 152 { 153 return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)]; 154 } 155 156 static inline int tty_put_user(struct tty_struct *tty, unsigned char x, 157 unsigned char __user *ptr) 158 { 159 struct n_tty_data *ldata = tty->disc_data; 160 161 tty_audit_add_data(tty, &x, 1, ldata->icanon); 162 return put_user(x, ptr); 163 } 164 165 static int tty_copy_to_user(struct tty_struct *tty, void __user *to, 166 size_t tail, size_t n) 167 { 168 struct n_tty_data *ldata = tty->disc_data; 169 size_t size = N_TTY_BUF_SIZE - tail; 170 const void *from = read_buf_addr(ldata, tail); 171 int uncopied; 172 173 if (n > size) { 174 tty_audit_add_data(tty, from, size, ldata->icanon); 175 uncopied = copy_to_user(to, from, size); 176 if (uncopied) 177 return uncopied; 178 to += size; 179 n -= size; 180 from = ldata->read_buf; 181 } 182 183 tty_audit_add_data(tty, from, n, ldata->icanon); 184 return copy_to_user(to, from, n); 185 } 186 187 /** 188 * n_tty_kick_worker - start input worker (if required) 189 * @tty: terminal 190 * 191 * Re-schedules the flip buffer work if it may have stopped 192 * 193 * Caller holds exclusive termios_rwsem 194 * or 195 * n_tty_read()/consumer path: 196 * holds non-exclusive termios_rwsem 197 */ 198 199 static void n_tty_kick_worker(struct tty_struct *tty) 200 { 201 struct n_tty_data *ldata = tty->disc_data; 202 203 /* Did the input worker stop? Restart it */ 204 if (unlikely(ldata->no_room)) { 205 ldata->no_room = 0; 206 207 WARN_RATELIMIT(tty->port->itty == NULL, 208 "scheduling with invalid itty\n"); 209 /* see if ldisc has been killed - if so, this means that 210 * even though the ldisc has been halted and ->buf.work 211 * cancelled, ->buf.work is about to be rescheduled 212 */ 213 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags), 214 "scheduling buffer work for halted ldisc\n"); 215 tty_buffer_restart_work(tty->port); 216 } 217 } 218 219 static ssize_t chars_in_buffer(struct tty_struct *tty) 220 { 221 struct n_tty_data *ldata = tty->disc_data; 222 ssize_t n = 0; 223 224 if (!ldata->icanon) 225 n = ldata->commit_head - ldata->read_tail; 226 else 227 n = ldata->canon_head - ldata->read_tail; 228 return n; 229 } 230 231 /** 232 * n_tty_write_wakeup - asynchronous I/O notifier 233 * @tty: tty device 234 * 235 * Required for the ptys, serial driver etc. since processes 236 * that attach themselves to the master and rely on ASYNC 237 * IO must be woken up 238 */ 239 240 static void n_tty_write_wakeup(struct tty_struct *tty) 241 { 242 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) 243 kill_fasync(&tty->fasync, SIGIO, POLL_OUT); 244 } 245 246 static void n_tty_check_throttle(struct tty_struct *tty) 247 { 248 struct n_tty_data *ldata = tty->disc_data; 249 250 /* 251 * Check the remaining room for the input canonicalization 252 * mode. We don't want to throttle the driver if we're in 253 * canonical mode and don't have a newline yet! 254 */ 255 if (ldata->icanon && ldata->canon_head == ldata->read_tail) 256 return; 257 258 while (1) { 259 int throttled; 260 tty_set_flow_change(tty, TTY_THROTTLE_SAFE); 261 if (N_TTY_BUF_SIZE - read_cnt(ldata) >= TTY_THRESHOLD_THROTTLE) 262 break; 263 throttled = tty_throttle_safe(tty); 264 if (!throttled) 265 break; 266 } 267 __tty_set_flow_change(tty, 0); 268 } 269 270 static void n_tty_check_unthrottle(struct tty_struct *tty) 271 { 272 if (tty->driver->type == TTY_DRIVER_TYPE_PTY) { 273 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE) 274 return; 275 if (!tty->count) 276 return; 277 n_tty_kick_worker(tty); 278 tty_wakeup(tty->link); 279 return; 280 } 281 282 /* If there is enough space in the read buffer now, let the 283 * low-level driver know. We use chars_in_buffer() to 284 * check the buffer, as it now knows about canonical mode. 285 * Otherwise, if the driver is throttled and the line is 286 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode, 287 * we won't get any more characters. 288 */ 289 290 while (1) { 291 int unthrottled; 292 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE); 293 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE) 294 break; 295 if (!tty->count) 296 break; 297 n_tty_kick_worker(tty); 298 unthrottled = tty_unthrottle_safe(tty); 299 if (!unthrottled) 300 break; 301 } 302 __tty_set_flow_change(tty, 0); 303 } 304 305 /** 306 * put_tty_queue - add character to tty 307 * @c: character 308 * @ldata: n_tty data 309 * 310 * Add a character to the tty read_buf queue. 311 * 312 * n_tty_receive_buf()/producer path: 313 * caller holds non-exclusive termios_rwsem 314 */ 315 316 static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata) 317 { 318 *read_buf_addr(ldata, ldata->read_head) = c; 319 ldata->read_head++; 320 } 321 322 /** 323 * reset_buffer_flags - reset buffer state 324 * @tty: terminal to reset 325 * 326 * Reset the read buffer counters and clear the flags. 327 * Called from n_tty_open() and n_tty_flush_buffer(). 328 * 329 * Locking: caller holds exclusive termios_rwsem 330 * (or locking is not required) 331 */ 332 333 static void reset_buffer_flags(struct n_tty_data *ldata) 334 { 335 ldata->read_head = ldata->canon_head = ldata->read_tail = 0; 336 ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0; 337 ldata->commit_head = 0; 338 ldata->echo_mark = 0; 339 ldata->line_start = 0; 340 341 ldata->erasing = 0; 342 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE); 343 ldata->push = 0; 344 } 345 346 static void n_tty_packet_mode_flush(struct tty_struct *tty) 347 { 348 unsigned long flags; 349 350 if (tty->link->packet) { 351 spin_lock_irqsave(&tty->ctrl_lock, flags); 352 tty->ctrl_status |= TIOCPKT_FLUSHREAD; 353 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 354 wake_up_interruptible(&tty->link->read_wait); 355 } 356 } 357 358 /** 359 * n_tty_flush_buffer - clean input queue 360 * @tty: terminal device 361 * 362 * Flush the input buffer. Called when the tty layer wants the 363 * buffer flushed (eg at hangup) or when the N_TTY line discipline 364 * internally has to clean the pending queue (for example some signals). 365 * 366 * Holds termios_rwsem to exclude producer/consumer while 367 * buffer indices are reset. 368 * 369 * Locking: ctrl_lock, exclusive termios_rwsem 370 */ 371 372 static void n_tty_flush_buffer(struct tty_struct *tty) 373 { 374 down_write(&tty->termios_rwsem); 375 reset_buffer_flags(tty->disc_data); 376 n_tty_kick_worker(tty); 377 378 if (tty->link) 379 n_tty_packet_mode_flush(tty); 380 up_write(&tty->termios_rwsem); 381 } 382 383 /** 384 * n_tty_chars_in_buffer - report available bytes 385 * @tty: tty device 386 * 387 * Report the number of characters buffered to be delivered to user 388 * at this instant in time. 389 * 390 * Locking: exclusive termios_rwsem 391 */ 392 393 static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty) 394 { 395 ssize_t n; 396 397 WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__); 398 399 down_write(&tty->termios_rwsem); 400 n = chars_in_buffer(tty); 401 up_write(&tty->termios_rwsem); 402 return n; 403 } 404 405 /** 406 * is_utf8_continuation - utf8 multibyte check 407 * @c: byte to check 408 * 409 * Returns true if the utf8 character 'c' is a multibyte continuation 410 * character. We use this to correctly compute the on screen size 411 * of the character when printing 412 */ 413 414 static inline int is_utf8_continuation(unsigned char c) 415 { 416 return (c & 0xc0) == 0x80; 417 } 418 419 /** 420 * is_continuation - multibyte check 421 * @c: byte to check 422 * 423 * Returns true if the utf8 character 'c' is a multibyte continuation 424 * character and the terminal is in unicode mode. 425 */ 426 427 static inline int is_continuation(unsigned char c, struct tty_struct *tty) 428 { 429 return I_IUTF8(tty) && is_utf8_continuation(c); 430 } 431 432 /** 433 * do_output_char - output one character 434 * @c: character (or partial unicode symbol) 435 * @tty: terminal device 436 * @space: space available in tty driver write buffer 437 * 438 * This is a helper function that handles one output character 439 * (including special characters like TAB, CR, LF, etc.), 440 * doing OPOST processing and putting the results in the 441 * tty driver's write buffer. 442 * 443 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY 444 * and NLDLY. They simply aren't relevant in the world today. 445 * If you ever need them, add them here. 446 * 447 * Returns the number of bytes of buffer space used or -1 if 448 * no space left. 449 * 450 * Locking: should be called under the output_lock to protect 451 * the column state and space left in the buffer 452 */ 453 454 static int do_output_char(unsigned char c, struct tty_struct *tty, int space) 455 { 456 struct n_tty_data *ldata = tty->disc_data; 457 int spaces; 458 459 if (!space) 460 return -1; 461 462 switch (c) { 463 case '\n': 464 if (O_ONLRET(tty)) 465 ldata->column = 0; 466 if (O_ONLCR(tty)) { 467 if (space < 2) 468 return -1; 469 ldata->canon_column = ldata->column = 0; 470 tty->ops->write(tty, "\r\n", 2); 471 return 2; 472 } 473 ldata->canon_column = ldata->column; 474 break; 475 case '\r': 476 if (O_ONOCR(tty) && ldata->column == 0) 477 return 0; 478 if (O_OCRNL(tty)) { 479 c = '\n'; 480 if (O_ONLRET(tty)) 481 ldata->canon_column = ldata->column = 0; 482 break; 483 } 484 ldata->canon_column = ldata->column = 0; 485 break; 486 case '\t': 487 spaces = 8 - (ldata->column & 7); 488 if (O_TABDLY(tty) == XTABS) { 489 if (space < spaces) 490 return -1; 491 ldata->column += spaces; 492 tty->ops->write(tty, " ", spaces); 493 return spaces; 494 } 495 ldata->column += spaces; 496 break; 497 case '\b': 498 if (ldata->column > 0) 499 ldata->column--; 500 break; 501 default: 502 if (!iscntrl(c)) { 503 if (O_OLCUC(tty)) 504 c = toupper(c); 505 if (!is_continuation(c, tty)) 506 ldata->column++; 507 } 508 break; 509 } 510 511 tty_put_char(tty, c); 512 return 1; 513 } 514 515 /** 516 * process_output - output post processor 517 * @c: character (or partial unicode symbol) 518 * @tty: terminal device 519 * 520 * Output one character with OPOST processing. 521 * Returns -1 when the output device is full and the character 522 * must be retried. 523 * 524 * Locking: output_lock to protect column state and space left 525 * (also, this is called from n_tty_write under the 526 * tty layer write lock) 527 */ 528 529 static int process_output(unsigned char c, struct tty_struct *tty) 530 { 531 struct n_tty_data *ldata = tty->disc_data; 532 int space, retval; 533 534 mutex_lock(&ldata->output_lock); 535 536 space = tty_write_room(tty); 537 retval = do_output_char(c, tty, space); 538 539 mutex_unlock(&ldata->output_lock); 540 if (retval < 0) 541 return -1; 542 else 543 return 0; 544 } 545 546 /** 547 * process_output_block - block post processor 548 * @tty: terminal device 549 * @buf: character buffer 550 * @nr: number of bytes to output 551 * 552 * Output a block of characters with OPOST processing. 553 * Returns the number of characters output. 554 * 555 * This path is used to speed up block console writes, among other 556 * things when processing blocks of output data. It handles only 557 * the simple cases normally found and helps to generate blocks of 558 * symbols for the console driver and thus improve performance. 559 * 560 * Locking: output_lock to protect column state and space left 561 * (also, this is called from n_tty_write under the 562 * tty layer write lock) 563 */ 564 565 static ssize_t process_output_block(struct tty_struct *tty, 566 const unsigned char *buf, unsigned int nr) 567 { 568 struct n_tty_data *ldata = tty->disc_data; 569 int space; 570 int i; 571 const unsigned char *cp; 572 573 mutex_lock(&ldata->output_lock); 574 575 space = tty_write_room(tty); 576 if (!space) { 577 mutex_unlock(&ldata->output_lock); 578 return 0; 579 } 580 if (nr > space) 581 nr = space; 582 583 for (i = 0, cp = buf; i < nr; i++, cp++) { 584 unsigned char c = *cp; 585 586 switch (c) { 587 case '\n': 588 if (O_ONLRET(tty)) 589 ldata->column = 0; 590 if (O_ONLCR(tty)) 591 goto break_out; 592 ldata->canon_column = ldata->column; 593 break; 594 case '\r': 595 if (O_ONOCR(tty) && ldata->column == 0) 596 goto break_out; 597 if (O_OCRNL(tty)) 598 goto break_out; 599 ldata->canon_column = ldata->column = 0; 600 break; 601 case '\t': 602 goto break_out; 603 case '\b': 604 if (ldata->column > 0) 605 ldata->column--; 606 break; 607 default: 608 if (!iscntrl(c)) { 609 if (O_OLCUC(tty)) 610 goto break_out; 611 if (!is_continuation(c, tty)) 612 ldata->column++; 613 } 614 break; 615 } 616 } 617 break_out: 618 i = tty->ops->write(tty, buf, i); 619 620 mutex_unlock(&ldata->output_lock); 621 return i; 622 } 623 624 /** 625 * process_echoes - write pending echo characters 626 * @tty: terminal device 627 * 628 * Write previously buffered echo (and other ldisc-generated) 629 * characters to the tty. 630 * 631 * Characters generated by the ldisc (including echoes) need to 632 * be buffered because the driver's write buffer can fill during 633 * heavy program output. Echoing straight to the driver will 634 * often fail under these conditions, causing lost characters and 635 * resulting mismatches of ldisc state information. 636 * 637 * Since the ldisc state must represent the characters actually sent 638 * to the driver at the time of the write, operations like certain 639 * changes in column state are also saved in the buffer and executed 640 * here. 641 * 642 * A circular fifo buffer is used so that the most recent characters 643 * are prioritized. Also, when control characters are echoed with a 644 * prefixed "^", the pair is treated atomically and thus not separated. 645 * 646 * Locking: callers must hold output_lock 647 */ 648 649 static size_t __process_echoes(struct tty_struct *tty) 650 { 651 struct n_tty_data *ldata = tty->disc_data; 652 int space, old_space; 653 size_t tail; 654 unsigned char c; 655 656 old_space = space = tty_write_room(tty); 657 658 tail = ldata->echo_tail; 659 while (ldata->echo_commit != tail) { 660 c = echo_buf(ldata, tail); 661 if (c == ECHO_OP_START) { 662 unsigned char op; 663 int no_space_left = 0; 664 665 /* 666 * If the buffer byte is the start of a multi-byte 667 * operation, get the next byte, which is either the 668 * op code or a control character value. 669 */ 670 op = echo_buf(ldata, tail + 1); 671 672 switch (op) { 673 unsigned int num_chars, num_bs; 674 675 case ECHO_OP_ERASE_TAB: 676 num_chars = echo_buf(ldata, tail + 2); 677 678 /* 679 * Determine how many columns to go back 680 * in order to erase the tab. 681 * This depends on the number of columns 682 * used by other characters within the tab 683 * area. If this (modulo 8) count is from 684 * the start of input rather than from a 685 * previous tab, we offset by canon column. 686 * Otherwise, tab spacing is normal. 687 */ 688 if (!(num_chars & 0x80)) 689 num_chars += ldata->canon_column; 690 num_bs = 8 - (num_chars & 7); 691 692 if (num_bs > space) { 693 no_space_left = 1; 694 break; 695 } 696 space -= num_bs; 697 while (num_bs--) { 698 tty_put_char(tty, '\b'); 699 if (ldata->column > 0) 700 ldata->column--; 701 } 702 tail += 3; 703 break; 704 705 case ECHO_OP_SET_CANON_COL: 706 ldata->canon_column = ldata->column; 707 tail += 2; 708 break; 709 710 case ECHO_OP_MOVE_BACK_COL: 711 if (ldata->column > 0) 712 ldata->column--; 713 tail += 2; 714 break; 715 716 case ECHO_OP_START: 717 /* This is an escaped echo op start code */ 718 if (!space) { 719 no_space_left = 1; 720 break; 721 } 722 tty_put_char(tty, ECHO_OP_START); 723 ldata->column++; 724 space--; 725 tail += 2; 726 break; 727 728 default: 729 /* 730 * If the op is not a special byte code, 731 * it is a ctrl char tagged to be echoed 732 * as "^X" (where X is the letter 733 * representing the control char). 734 * Note that we must ensure there is 735 * enough space for the whole ctrl pair. 736 * 737 */ 738 if (space < 2) { 739 no_space_left = 1; 740 break; 741 } 742 tty_put_char(tty, '^'); 743 tty_put_char(tty, op ^ 0100); 744 ldata->column += 2; 745 space -= 2; 746 tail += 2; 747 } 748 749 if (no_space_left) 750 break; 751 } else { 752 if (O_OPOST(tty)) { 753 int retval = do_output_char(c, tty, space); 754 if (retval < 0) 755 break; 756 space -= retval; 757 } else { 758 if (!space) 759 break; 760 tty_put_char(tty, c); 761 space -= 1; 762 } 763 tail += 1; 764 } 765 } 766 767 /* If the echo buffer is nearly full (so that the possibility exists 768 * of echo overrun before the next commit), then discard enough 769 * data at the tail to prevent a subsequent overrun */ 770 while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) { 771 if (echo_buf(ldata, tail) == ECHO_OP_START) { 772 if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB) 773 tail += 3; 774 else 775 tail += 2; 776 } else 777 tail++; 778 } 779 780 ldata->echo_tail = tail; 781 return old_space - space; 782 } 783 784 static void commit_echoes(struct tty_struct *tty) 785 { 786 struct n_tty_data *ldata = tty->disc_data; 787 size_t nr, old, echoed; 788 size_t head; 789 790 head = ldata->echo_head; 791 ldata->echo_mark = head; 792 old = ldata->echo_commit - ldata->echo_tail; 793 794 /* Process committed echoes if the accumulated # of bytes 795 * is over the threshold (and try again each time another 796 * block is accumulated) */ 797 nr = head - ldata->echo_tail; 798 if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK)) 799 return; 800 801 mutex_lock(&ldata->output_lock); 802 ldata->echo_commit = head; 803 echoed = __process_echoes(tty); 804 mutex_unlock(&ldata->output_lock); 805 806 if (echoed && tty->ops->flush_chars) 807 tty->ops->flush_chars(tty); 808 } 809 810 static void process_echoes(struct tty_struct *tty) 811 { 812 struct n_tty_data *ldata = tty->disc_data; 813 size_t echoed; 814 815 if (ldata->echo_mark == ldata->echo_tail) 816 return; 817 818 mutex_lock(&ldata->output_lock); 819 ldata->echo_commit = ldata->echo_mark; 820 echoed = __process_echoes(tty); 821 mutex_unlock(&ldata->output_lock); 822 823 if (echoed && tty->ops->flush_chars) 824 tty->ops->flush_chars(tty); 825 } 826 827 /* NB: echo_mark and echo_head should be equivalent here */ 828 static void flush_echoes(struct tty_struct *tty) 829 { 830 struct n_tty_data *ldata = tty->disc_data; 831 832 if ((!L_ECHO(tty) && !L_ECHONL(tty)) || 833 ldata->echo_commit == ldata->echo_head) 834 return; 835 836 mutex_lock(&ldata->output_lock); 837 ldata->echo_commit = ldata->echo_head; 838 __process_echoes(tty); 839 mutex_unlock(&ldata->output_lock); 840 } 841 842 /** 843 * add_echo_byte - add a byte to the echo buffer 844 * @c: unicode byte to echo 845 * @ldata: n_tty data 846 * 847 * Add a character or operation byte to the echo buffer. 848 */ 849 850 static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata) 851 { 852 *echo_buf_addr(ldata, ldata->echo_head++) = c; 853 } 854 855 /** 856 * echo_move_back_col - add operation to move back a column 857 * @ldata: n_tty data 858 * 859 * Add an operation to the echo buffer to move back one column. 860 */ 861 862 static void echo_move_back_col(struct n_tty_data *ldata) 863 { 864 add_echo_byte(ECHO_OP_START, ldata); 865 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata); 866 } 867 868 /** 869 * echo_set_canon_col - add operation to set the canon column 870 * @ldata: n_tty data 871 * 872 * Add an operation to the echo buffer to set the canon column 873 * to the current column. 874 */ 875 876 static void echo_set_canon_col(struct n_tty_data *ldata) 877 { 878 add_echo_byte(ECHO_OP_START, ldata); 879 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata); 880 } 881 882 /** 883 * echo_erase_tab - add operation to erase a tab 884 * @num_chars: number of character columns already used 885 * @after_tab: true if num_chars starts after a previous tab 886 * @ldata: n_tty data 887 * 888 * Add an operation to the echo buffer to erase a tab. 889 * 890 * Called by the eraser function, which knows how many character 891 * columns have been used since either a previous tab or the start 892 * of input. This information will be used later, along with 893 * canon column (if applicable), to go back the correct number 894 * of columns. 895 */ 896 897 static void echo_erase_tab(unsigned int num_chars, int after_tab, 898 struct n_tty_data *ldata) 899 { 900 add_echo_byte(ECHO_OP_START, ldata); 901 add_echo_byte(ECHO_OP_ERASE_TAB, ldata); 902 903 /* We only need to know this modulo 8 (tab spacing) */ 904 num_chars &= 7; 905 906 /* Set the high bit as a flag if num_chars is after a previous tab */ 907 if (after_tab) 908 num_chars |= 0x80; 909 910 add_echo_byte(num_chars, ldata); 911 } 912 913 /** 914 * echo_char_raw - echo a character raw 915 * @c: unicode byte to echo 916 * @tty: terminal device 917 * 918 * Echo user input back onto the screen. This must be called only when 919 * L_ECHO(tty) is true. Called from the driver receive_buf path. 920 * 921 * This variant does not treat control characters specially. 922 */ 923 924 static void echo_char_raw(unsigned char c, struct n_tty_data *ldata) 925 { 926 if (c == ECHO_OP_START) { 927 add_echo_byte(ECHO_OP_START, ldata); 928 add_echo_byte(ECHO_OP_START, ldata); 929 } else { 930 add_echo_byte(c, ldata); 931 } 932 } 933 934 /** 935 * echo_char - echo a character 936 * @c: unicode byte to echo 937 * @tty: terminal device 938 * 939 * Echo user input back onto the screen. This must be called only when 940 * L_ECHO(tty) is true. Called from the driver receive_buf path. 941 * 942 * This variant tags control characters to be echoed as "^X" 943 * (where X is the letter representing the control char). 944 */ 945 946 static void echo_char(unsigned char c, struct tty_struct *tty) 947 { 948 struct n_tty_data *ldata = tty->disc_data; 949 950 if (c == ECHO_OP_START) { 951 add_echo_byte(ECHO_OP_START, ldata); 952 add_echo_byte(ECHO_OP_START, ldata); 953 } else { 954 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t') 955 add_echo_byte(ECHO_OP_START, ldata); 956 add_echo_byte(c, ldata); 957 } 958 } 959 960 /** 961 * finish_erasing - complete erase 962 * @ldata: n_tty data 963 */ 964 965 static inline void finish_erasing(struct n_tty_data *ldata) 966 { 967 if (ldata->erasing) { 968 echo_char_raw('/', ldata); 969 ldata->erasing = 0; 970 } 971 } 972 973 /** 974 * eraser - handle erase function 975 * @c: character input 976 * @tty: terminal device 977 * 978 * Perform erase and necessary output when an erase character is 979 * present in the stream from the driver layer. Handles the complexities 980 * of UTF-8 multibyte symbols. 981 * 982 * n_tty_receive_buf()/producer path: 983 * caller holds non-exclusive termios_rwsem 984 */ 985 986 static void eraser(unsigned char c, struct tty_struct *tty) 987 { 988 struct n_tty_data *ldata = tty->disc_data; 989 enum { ERASE, WERASE, KILL } kill_type; 990 size_t head; 991 size_t cnt; 992 int seen_alnums; 993 994 if (ldata->read_head == ldata->canon_head) { 995 /* process_output('\a', tty); */ /* what do you think? */ 996 return; 997 } 998 if (c == ERASE_CHAR(tty)) 999 kill_type = ERASE; 1000 else if (c == WERASE_CHAR(tty)) 1001 kill_type = WERASE; 1002 else { 1003 if (!L_ECHO(tty)) { 1004 ldata->read_head = ldata->canon_head; 1005 return; 1006 } 1007 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) { 1008 ldata->read_head = ldata->canon_head; 1009 finish_erasing(ldata); 1010 echo_char(KILL_CHAR(tty), tty); 1011 /* Add a newline if ECHOK is on and ECHOKE is off. */ 1012 if (L_ECHOK(tty)) 1013 echo_char_raw('\n', ldata); 1014 return; 1015 } 1016 kill_type = KILL; 1017 } 1018 1019 seen_alnums = 0; 1020 while (ldata->read_head != ldata->canon_head) { 1021 head = ldata->read_head; 1022 1023 /* erase a single possibly multibyte character */ 1024 do { 1025 head--; 1026 c = read_buf(ldata, head); 1027 } while (is_continuation(c, tty) && head != ldata->canon_head); 1028 1029 /* do not partially erase */ 1030 if (is_continuation(c, tty)) 1031 break; 1032 1033 if (kill_type == WERASE) { 1034 /* Equivalent to BSD's ALTWERASE. */ 1035 if (isalnum(c) || c == '_') 1036 seen_alnums++; 1037 else if (seen_alnums) 1038 break; 1039 } 1040 cnt = ldata->read_head - head; 1041 ldata->read_head = head; 1042 if (L_ECHO(tty)) { 1043 if (L_ECHOPRT(tty)) { 1044 if (!ldata->erasing) { 1045 echo_char_raw('\\', ldata); 1046 ldata->erasing = 1; 1047 } 1048 /* if cnt > 1, output a multi-byte character */ 1049 echo_char(c, tty); 1050 while (--cnt > 0) { 1051 head++; 1052 echo_char_raw(read_buf(ldata, head), ldata); 1053 echo_move_back_col(ldata); 1054 } 1055 } else if (kill_type == ERASE && !L_ECHOE(tty)) { 1056 echo_char(ERASE_CHAR(tty), tty); 1057 } else if (c == '\t') { 1058 unsigned int num_chars = 0; 1059 int after_tab = 0; 1060 size_t tail = ldata->read_head; 1061 1062 /* 1063 * Count the columns used for characters 1064 * since the start of input or after a 1065 * previous tab. 1066 * This info is used to go back the correct 1067 * number of columns. 1068 */ 1069 while (tail != ldata->canon_head) { 1070 tail--; 1071 c = read_buf(ldata, tail); 1072 if (c == '\t') { 1073 after_tab = 1; 1074 break; 1075 } else if (iscntrl(c)) { 1076 if (L_ECHOCTL(tty)) 1077 num_chars += 2; 1078 } else if (!is_continuation(c, tty)) { 1079 num_chars++; 1080 } 1081 } 1082 echo_erase_tab(num_chars, after_tab, ldata); 1083 } else { 1084 if (iscntrl(c) && L_ECHOCTL(tty)) { 1085 echo_char_raw('\b', ldata); 1086 echo_char_raw(' ', ldata); 1087 echo_char_raw('\b', ldata); 1088 } 1089 if (!iscntrl(c) || L_ECHOCTL(tty)) { 1090 echo_char_raw('\b', ldata); 1091 echo_char_raw(' ', ldata); 1092 echo_char_raw('\b', ldata); 1093 } 1094 } 1095 } 1096 if (kill_type == ERASE) 1097 break; 1098 } 1099 if (ldata->read_head == ldata->canon_head && L_ECHO(tty)) 1100 finish_erasing(ldata); 1101 } 1102 1103 /** 1104 * isig - handle the ISIG optio 1105 * @sig: signal 1106 * @tty: terminal 1107 * 1108 * Called when a signal is being sent due to terminal input. 1109 * Called from the driver receive_buf path so serialized. 1110 * 1111 * Performs input and output flush if !NOFLSH. In this context, the echo 1112 * buffer is 'output'. The signal is processed first to alert any current 1113 * readers or writers to discontinue and exit their i/o loops. 1114 * 1115 * Locking: ctrl_lock 1116 */ 1117 1118 static void __isig(int sig, struct tty_struct *tty) 1119 { 1120 struct pid *tty_pgrp = tty_get_pgrp(tty); 1121 if (tty_pgrp) { 1122 kill_pgrp(tty_pgrp, sig, 1); 1123 put_pid(tty_pgrp); 1124 } 1125 } 1126 1127 static void isig(int sig, struct tty_struct *tty) 1128 { 1129 struct n_tty_data *ldata = tty->disc_data; 1130 1131 if (L_NOFLSH(tty)) { 1132 /* signal only */ 1133 __isig(sig, tty); 1134 1135 } else { /* signal and flush */ 1136 up_read(&tty->termios_rwsem); 1137 down_write(&tty->termios_rwsem); 1138 1139 __isig(sig, tty); 1140 1141 /* clear echo buffer */ 1142 mutex_lock(&ldata->output_lock); 1143 ldata->echo_head = ldata->echo_tail = 0; 1144 ldata->echo_mark = ldata->echo_commit = 0; 1145 mutex_unlock(&ldata->output_lock); 1146 1147 /* clear output buffer */ 1148 tty_driver_flush_buffer(tty); 1149 1150 /* clear input buffer */ 1151 reset_buffer_flags(tty->disc_data); 1152 1153 /* notify pty master of flush */ 1154 if (tty->link) 1155 n_tty_packet_mode_flush(tty); 1156 1157 up_write(&tty->termios_rwsem); 1158 down_read(&tty->termios_rwsem); 1159 } 1160 } 1161 1162 /** 1163 * n_tty_receive_break - handle break 1164 * @tty: terminal 1165 * 1166 * An RS232 break event has been hit in the incoming bitstream. This 1167 * can cause a variety of events depending upon the termios settings. 1168 * 1169 * n_tty_receive_buf()/producer path: 1170 * caller holds non-exclusive termios_rwsem 1171 * 1172 * Note: may get exclusive termios_rwsem if flushing input buffer 1173 */ 1174 1175 static void n_tty_receive_break(struct tty_struct *tty) 1176 { 1177 struct n_tty_data *ldata = tty->disc_data; 1178 1179 if (I_IGNBRK(tty)) 1180 return; 1181 if (I_BRKINT(tty)) { 1182 isig(SIGINT, tty); 1183 return; 1184 } 1185 if (I_PARMRK(tty)) { 1186 put_tty_queue('\377', ldata); 1187 put_tty_queue('\0', ldata); 1188 } 1189 put_tty_queue('\0', ldata); 1190 } 1191 1192 /** 1193 * n_tty_receive_overrun - handle overrun reporting 1194 * @tty: terminal 1195 * 1196 * Data arrived faster than we could process it. While the tty 1197 * driver has flagged this the bits that were missed are gone 1198 * forever. 1199 * 1200 * Called from the receive_buf path so single threaded. Does not 1201 * need locking as num_overrun and overrun_time are function 1202 * private. 1203 */ 1204 1205 static void n_tty_receive_overrun(struct tty_struct *tty) 1206 { 1207 struct n_tty_data *ldata = tty->disc_data; 1208 1209 ldata->num_overrun++; 1210 if (time_after(jiffies, ldata->overrun_time + HZ) || 1211 time_after(ldata->overrun_time, jiffies)) { 1212 tty_warn(tty, "%d input overrun(s)\n", ldata->num_overrun); 1213 ldata->overrun_time = jiffies; 1214 ldata->num_overrun = 0; 1215 } 1216 } 1217 1218 /** 1219 * n_tty_receive_parity_error - error notifier 1220 * @tty: terminal device 1221 * @c: character 1222 * 1223 * Process a parity error and queue the right data to indicate 1224 * the error case if necessary. 1225 * 1226 * n_tty_receive_buf()/producer path: 1227 * caller holds non-exclusive termios_rwsem 1228 */ 1229 static void n_tty_receive_parity_error(struct tty_struct *tty, unsigned char c) 1230 { 1231 struct n_tty_data *ldata = tty->disc_data; 1232 1233 if (I_INPCK(tty)) { 1234 if (I_IGNPAR(tty)) 1235 return; 1236 if (I_PARMRK(tty)) { 1237 put_tty_queue('\377', ldata); 1238 put_tty_queue('\0', ldata); 1239 put_tty_queue(c, ldata); 1240 } else 1241 put_tty_queue('\0', ldata); 1242 } else 1243 put_tty_queue(c, ldata); 1244 } 1245 1246 static void 1247 n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c) 1248 { 1249 isig(signal, tty); 1250 if (I_IXON(tty)) 1251 start_tty(tty); 1252 if (L_ECHO(tty)) { 1253 echo_char(c, tty); 1254 commit_echoes(tty); 1255 } else 1256 process_echoes(tty); 1257 return; 1258 } 1259 1260 /** 1261 * n_tty_receive_char - perform processing 1262 * @tty: terminal device 1263 * @c: character 1264 * 1265 * Process an individual character of input received from the driver. 1266 * This is serialized with respect to itself by the rules for the 1267 * driver above. 1268 * 1269 * n_tty_receive_buf()/producer path: 1270 * caller holds non-exclusive termios_rwsem 1271 * publishes canon_head if canonical mode is active 1272 * 1273 * Returns 1 if LNEXT was received, else returns 0 1274 */ 1275 1276 static int 1277 n_tty_receive_char_special(struct tty_struct *tty, unsigned char c) 1278 { 1279 struct n_tty_data *ldata = tty->disc_data; 1280 1281 if (I_IXON(tty)) { 1282 if (c == START_CHAR(tty)) { 1283 start_tty(tty); 1284 process_echoes(tty); 1285 return 0; 1286 } 1287 if (c == STOP_CHAR(tty)) { 1288 stop_tty(tty); 1289 return 0; 1290 } 1291 } 1292 1293 if (L_ISIG(tty)) { 1294 if (c == INTR_CHAR(tty)) { 1295 n_tty_receive_signal_char(tty, SIGINT, c); 1296 return 0; 1297 } else if (c == QUIT_CHAR(tty)) { 1298 n_tty_receive_signal_char(tty, SIGQUIT, c); 1299 return 0; 1300 } else if (c == SUSP_CHAR(tty)) { 1301 n_tty_receive_signal_char(tty, SIGTSTP, c); 1302 return 0; 1303 } 1304 } 1305 1306 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) { 1307 start_tty(tty); 1308 process_echoes(tty); 1309 } 1310 1311 if (c == '\r') { 1312 if (I_IGNCR(tty)) 1313 return 0; 1314 if (I_ICRNL(tty)) 1315 c = '\n'; 1316 } else if (c == '\n' && I_INLCR(tty)) 1317 c = '\r'; 1318 1319 if (ldata->icanon) { 1320 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) || 1321 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) { 1322 eraser(c, tty); 1323 commit_echoes(tty); 1324 return 0; 1325 } 1326 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) { 1327 ldata->lnext = 1; 1328 if (L_ECHO(tty)) { 1329 finish_erasing(ldata); 1330 if (L_ECHOCTL(tty)) { 1331 echo_char_raw('^', ldata); 1332 echo_char_raw('\b', ldata); 1333 commit_echoes(tty); 1334 } 1335 } 1336 return 1; 1337 } 1338 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && L_IEXTEN(tty)) { 1339 size_t tail = ldata->canon_head; 1340 1341 finish_erasing(ldata); 1342 echo_char(c, tty); 1343 echo_char_raw('\n', ldata); 1344 while (tail != ldata->read_head) { 1345 echo_char(read_buf(ldata, tail), tty); 1346 tail++; 1347 } 1348 commit_echoes(tty); 1349 return 0; 1350 } 1351 if (c == '\n') { 1352 if (L_ECHO(tty) || L_ECHONL(tty)) { 1353 echo_char_raw('\n', ldata); 1354 commit_echoes(tty); 1355 } 1356 goto handle_newline; 1357 } 1358 if (c == EOF_CHAR(tty)) { 1359 c = __DISABLED_CHAR; 1360 goto handle_newline; 1361 } 1362 if ((c == EOL_CHAR(tty)) || 1363 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) { 1364 /* 1365 * XXX are EOL_CHAR and EOL2_CHAR echoed?!? 1366 */ 1367 if (L_ECHO(tty)) { 1368 /* Record the column of first canon char. */ 1369 if (ldata->canon_head == ldata->read_head) 1370 echo_set_canon_col(ldata); 1371 echo_char(c, tty); 1372 commit_echoes(tty); 1373 } 1374 /* 1375 * XXX does PARMRK doubling happen for 1376 * EOL_CHAR and EOL2_CHAR? 1377 */ 1378 if (c == (unsigned char) '\377' && I_PARMRK(tty)) 1379 put_tty_queue(c, ldata); 1380 1381 handle_newline: 1382 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags); 1383 put_tty_queue(c, ldata); 1384 smp_store_release(&ldata->canon_head, ldata->read_head); 1385 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 1386 wake_up_interruptible_poll(&tty->read_wait, POLLIN); 1387 return 0; 1388 } 1389 } 1390 1391 if (L_ECHO(tty)) { 1392 finish_erasing(ldata); 1393 if (c == '\n') 1394 echo_char_raw('\n', ldata); 1395 else { 1396 /* Record the column of first canon char. */ 1397 if (ldata->canon_head == ldata->read_head) 1398 echo_set_canon_col(ldata); 1399 echo_char(c, tty); 1400 } 1401 commit_echoes(tty); 1402 } 1403 1404 /* PARMRK doubling check */ 1405 if (c == (unsigned char) '\377' && I_PARMRK(tty)) 1406 put_tty_queue(c, ldata); 1407 1408 put_tty_queue(c, ldata); 1409 return 0; 1410 } 1411 1412 static inline void 1413 n_tty_receive_char_inline(struct tty_struct *tty, unsigned char c) 1414 { 1415 struct n_tty_data *ldata = tty->disc_data; 1416 1417 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) { 1418 start_tty(tty); 1419 process_echoes(tty); 1420 } 1421 if (L_ECHO(tty)) { 1422 finish_erasing(ldata); 1423 /* Record the column of first canon char. */ 1424 if (ldata->canon_head == ldata->read_head) 1425 echo_set_canon_col(ldata); 1426 echo_char(c, tty); 1427 commit_echoes(tty); 1428 } 1429 /* PARMRK doubling check */ 1430 if (c == (unsigned char) '\377' && I_PARMRK(tty)) 1431 put_tty_queue(c, ldata); 1432 put_tty_queue(c, ldata); 1433 } 1434 1435 static void n_tty_receive_char(struct tty_struct *tty, unsigned char c) 1436 { 1437 n_tty_receive_char_inline(tty, c); 1438 } 1439 1440 static inline void 1441 n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c) 1442 { 1443 struct n_tty_data *ldata = tty->disc_data; 1444 1445 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) { 1446 start_tty(tty); 1447 process_echoes(tty); 1448 } 1449 if (L_ECHO(tty)) { 1450 finish_erasing(ldata); 1451 /* Record the column of first canon char. */ 1452 if (ldata->canon_head == ldata->read_head) 1453 echo_set_canon_col(ldata); 1454 echo_char(c, tty); 1455 commit_echoes(tty); 1456 } 1457 put_tty_queue(c, ldata); 1458 } 1459 1460 static void n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c) 1461 { 1462 if (I_ISTRIP(tty)) 1463 c &= 0x7f; 1464 if (I_IUCLC(tty) && L_IEXTEN(tty)) 1465 c = tolower(c); 1466 1467 if (I_IXON(tty)) { 1468 if (c == STOP_CHAR(tty)) 1469 stop_tty(tty); 1470 else if (c == START_CHAR(tty) || 1471 (tty->stopped && !tty->flow_stopped && I_IXANY(tty) && 1472 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && 1473 c != SUSP_CHAR(tty))) { 1474 start_tty(tty); 1475 process_echoes(tty); 1476 } 1477 } 1478 } 1479 1480 static void 1481 n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag) 1482 { 1483 switch (flag) { 1484 case TTY_BREAK: 1485 n_tty_receive_break(tty); 1486 break; 1487 case TTY_PARITY: 1488 case TTY_FRAME: 1489 n_tty_receive_parity_error(tty, c); 1490 break; 1491 case TTY_OVERRUN: 1492 n_tty_receive_overrun(tty); 1493 break; 1494 default: 1495 tty_err(tty, "unknown flag %d\n", flag); 1496 break; 1497 } 1498 } 1499 1500 static void 1501 n_tty_receive_char_lnext(struct tty_struct *tty, unsigned char c, char flag) 1502 { 1503 struct n_tty_data *ldata = tty->disc_data; 1504 1505 ldata->lnext = 0; 1506 if (likely(flag == TTY_NORMAL)) { 1507 if (I_ISTRIP(tty)) 1508 c &= 0x7f; 1509 if (I_IUCLC(tty) && L_IEXTEN(tty)) 1510 c = tolower(c); 1511 n_tty_receive_char(tty, c); 1512 } else 1513 n_tty_receive_char_flagged(tty, c, flag); 1514 } 1515 1516 static void 1517 n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp, 1518 char *fp, int count) 1519 { 1520 struct n_tty_data *ldata = tty->disc_data; 1521 size_t n, head; 1522 1523 head = ldata->read_head & (N_TTY_BUF_SIZE - 1); 1524 n = min_t(size_t, count, N_TTY_BUF_SIZE - head); 1525 memcpy(read_buf_addr(ldata, head), cp, n); 1526 ldata->read_head += n; 1527 cp += n; 1528 count -= n; 1529 1530 head = ldata->read_head & (N_TTY_BUF_SIZE - 1); 1531 n = min_t(size_t, count, N_TTY_BUF_SIZE - head); 1532 memcpy(read_buf_addr(ldata, head), cp, n); 1533 ldata->read_head += n; 1534 } 1535 1536 static void 1537 n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp, 1538 char *fp, int count) 1539 { 1540 struct n_tty_data *ldata = tty->disc_data; 1541 char flag = TTY_NORMAL; 1542 1543 while (count--) { 1544 if (fp) 1545 flag = *fp++; 1546 if (likely(flag == TTY_NORMAL)) 1547 put_tty_queue(*cp++, ldata); 1548 else 1549 n_tty_receive_char_flagged(tty, *cp++, flag); 1550 } 1551 } 1552 1553 static void 1554 n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp, 1555 char *fp, int count) 1556 { 1557 char flag = TTY_NORMAL; 1558 1559 while (count--) { 1560 if (fp) 1561 flag = *fp++; 1562 if (likely(flag == TTY_NORMAL)) 1563 n_tty_receive_char_closing(tty, *cp++); 1564 else 1565 n_tty_receive_char_flagged(tty, *cp++, flag); 1566 } 1567 } 1568 1569 static void 1570 n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp, 1571 char *fp, int count) 1572 { 1573 struct n_tty_data *ldata = tty->disc_data; 1574 char flag = TTY_NORMAL; 1575 1576 while (count--) { 1577 if (fp) 1578 flag = *fp++; 1579 if (likely(flag == TTY_NORMAL)) { 1580 unsigned char c = *cp++; 1581 1582 if (I_ISTRIP(tty)) 1583 c &= 0x7f; 1584 if (I_IUCLC(tty) && L_IEXTEN(tty)) 1585 c = tolower(c); 1586 if (L_EXTPROC(tty)) { 1587 put_tty_queue(c, ldata); 1588 continue; 1589 } 1590 if (!test_bit(c, ldata->char_map)) 1591 n_tty_receive_char_inline(tty, c); 1592 else if (n_tty_receive_char_special(tty, c) && count) { 1593 if (fp) 1594 flag = *fp++; 1595 n_tty_receive_char_lnext(tty, *cp++, flag); 1596 count--; 1597 } 1598 } else 1599 n_tty_receive_char_flagged(tty, *cp++, flag); 1600 } 1601 } 1602 1603 static void 1604 n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp, 1605 char *fp, int count) 1606 { 1607 struct n_tty_data *ldata = tty->disc_data; 1608 char flag = TTY_NORMAL; 1609 1610 while (count--) { 1611 if (fp) 1612 flag = *fp++; 1613 if (likely(flag == TTY_NORMAL)) { 1614 unsigned char c = *cp++; 1615 1616 if (!test_bit(c, ldata->char_map)) 1617 n_tty_receive_char_fast(tty, c); 1618 else if (n_tty_receive_char_special(tty, c) && count) { 1619 if (fp) 1620 flag = *fp++; 1621 n_tty_receive_char_lnext(tty, *cp++, flag); 1622 count--; 1623 } 1624 } else 1625 n_tty_receive_char_flagged(tty, *cp++, flag); 1626 } 1627 } 1628 1629 static void __receive_buf(struct tty_struct *tty, const unsigned char *cp, 1630 char *fp, int count) 1631 { 1632 struct n_tty_data *ldata = tty->disc_data; 1633 bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty)); 1634 1635 if (ldata->real_raw) 1636 n_tty_receive_buf_real_raw(tty, cp, fp, count); 1637 else if (ldata->raw || (L_EXTPROC(tty) && !preops)) 1638 n_tty_receive_buf_raw(tty, cp, fp, count); 1639 else if (tty->closing && !L_EXTPROC(tty)) 1640 n_tty_receive_buf_closing(tty, cp, fp, count); 1641 else { 1642 if (ldata->lnext) { 1643 char flag = TTY_NORMAL; 1644 1645 if (fp) 1646 flag = *fp++; 1647 n_tty_receive_char_lnext(tty, *cp++, flag); 1648 count--; 1649 } 1650 1651 if (!preops && !I_PARMRK(tty)) 1652 n_tty_receive_buf_fast(tty, cp, fp, count); 1653 else 1654 n_tty_receive_buf_standard(tty, cp, fp, count); 1655 1656 flush_echoes(tty); 1657 if (tty->ops->flush_chars) 1658 tty->ops->flush_chars(tty); 1659 } 1660 1661 if (ldata->icanon && !L_EXTPROC(tty)) 1662 return; 1663 1664 /* publish read_head to consumer */ 1665 smp_store_release(&ldata->commit_head, ldata->read_head); 1666 1667 if ((read_cnt(ldata) >= ldata->minimum_to_wake) || L_EXTPROC(tty)) { 1668 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 1669 wake_up_interruptible_poll(&tty->read_wait, POLLIN); 1670 } 1671 } 1672 1673 /** 1674 * n_tty_receive_buf_common - process input 1675 * @tty: device to receive input 1676 * @cp: input chars 1677 * @fp: flags for each char (if NULL, all chars are TTY_NORMAL) 1678 * @count: number of input chars in @cp 1679 * 1680 * Called by the terminal driver when a block of characters has 1681 * been received. This function must be called from soft contexts 1682 * not from interrupt context. The driver is responsible for making 1683 * calls one at a time and in order (or using flush_to_ldisc) 1684 * 1685 * Returns the # of input chars from @cp which were processed. 1686 * 1687 * In canonical mode, the maximum line length is 4096 chars (including 1688 * the line termination char); lines longer than 4096 chars are 1689 * truncated. After 4095 chars, input data is still processed but 1690 * not stored. Overflow processing ensures the tty can always 1691 * receive more input until at least one line can be read. 1692 * 1693 * In non-canonical mode, the read buffer will only accept 4095 chars; 1694 * this provides the necessary space for a newline char if the input 1695 * mode is switched to canonical. 1696 * 1697 * Note it is possible for the read buffer to _contain_ 4096 chars 1698 * in non-canonical mode: the read buffer could already contain the 1699 * maximum canon line of 4096 chars when the mode is switched to 1700 * non-canonical. 1701 * 1702 * n_tty_receive_buf()/producer path: 1703 * claims non-exclusive termios_rwsem 1704 * publishes commit_head or canon_head 1705 */ 1706 static int 1707 n_tty_receive_buf_common(struct tty_struct *tty, const unsigned char *cp, 1708 char *fp, int count, int flow) 1709 { 1710 struct n_tty_data *ldata = tty->disc_data; 1711 int room, n, rcvd = 0, overflow; 1712 1713 down_read(&tty->termios_rwsem); 1714 1715 while (1) { 1716 /* 1717 * When PARMRK is set, each input char may take up to 3 chars 1718 * in the read buf; reduce the buffer space avail by 3x 1719 * 1720 * If we are doing input canonicalization, and there are no 1721 * pending newlines, let characters through without limit, so 1722 * that erase characters will be handled. Other excess 1723 * characters will be beeped. 1724 * 1725 * paired with store in *_copy_from_read_buf() -- guarantees 1726 * the consumer has loaded the data in read_buf up to the new 1727 * read_tail (so this producer will not overwrite unread data) 1728 */ 1729 size_t tail = smp_load_acquire(&ldata->read_tail); 1730 1731 room = N_TTY_BUF_SIZE - (ldata->read_head - tail); 1732 if (I_PARMRK(tty)) 1733 room = (room + 2) / 3; 1734 room--; 1735 if (room <= 0) { 1736 overflow = ldata->icanon && ldata->canon_head == tail; 1737 if (overflow && room < 0) 1738 ldata->read_head--; 1739 room = overflow; 1740 ldata->no_room = flow && !room; 1741 } else 1742 overflow = 0; 1743 1744 n = min(count, room); 1745 if (!n) 1746 break; 1747 1748 /* ignore parity errors if handling overflow */ 1749 if (!overflow || !fp || *fp != TTY_PARITY) 1750 __receive_buf(tty, cp, fp, n); 1751 1752 cp += n; 1753 if (fp) 1754 fp += n; 1755 count -= n; 1756 rcvd += n; 1757 } 1758 1759 tty->receive_room = room; 1760 1761 /* Unthrottle if handling overflow on pty */ 1762 if (tty->driver->type == TTY_DRIVER_TYPE_PTY) { 1763 if (overflow) { 1764 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE); 1765 tty_unthrottle_safe(tty); 1766 __tty_set_flow_change(tty, 0); 1767 } 1768 } else 1769 n_tty_check_throttle(tty); 1770 1771 up_read(&tty->termios_rwsem); 1772 1773 return rcvd; 1774 } 1775 1776 static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp, 1777 char *fp, int count) 1778 { 1779 n_tty_receive_buf_common(tty, cp, fp, count, 0); 1780 } 1781 1782 static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp, 1783 char *fp, int count) 1784 { 1785 return n_tty_receive_buf_common(tty, cp, fp, count, 1); 1786 } 1787 1788 int is_ignored(int sig) 1789 { 1790 return (sigismember(¤t->blocked, sig) || 1791 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN); 1792 } 1793 1794 /** 1795 * n_tty_set_termios - termios data changed 1796 * @tty: terminal 1797 * @old: previous data 1798 * 1799 * Called by the tty layer when the user changes termios flags so 1800 * that the line discipline can plan ahead. This function cannot sleep 1801 * and is protected from re-entry by the tty layer. The user is 1802 * guaranteed that this function will not be re-entered or in progress 1803 * when the ldisc is closed. 1804 * 1805 * Locking: Caller holds tty->termios_rwsem 1806 */ 1807 1808 static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old) 1809 { 1810 struct n_tty_data *ldata = tty->disc_data; 1811 1812 if (!old || (old->c_lflag ^ tty->termios.c_lflag) & ICANON) { 1813 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE); 1814 ldata->line_start = ldata->read_tail; 1815 if (!L_ICANON(tty) || !read_cnt(ldata)) { 1816 ldata->canon_head = ldata->read_tail; 1817 ldata->push = 0; 1818 } else { 1819 set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1), 1820 ldata->read_flags); 1821 ldata->canon_head = ldata->read_head; 1822 ldata->push = 1; 1823 } 1824 ldata->commit_head = ldata->read_head; 1825 ldata->erasing = 0; 1826 ldata->lnext = 0; 1827 } 1828 1829 ldata->icanon = (L_ICANON(tty) != 0); 1830 1831 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) || 1832 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) || 1833 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) || 1834 I_PARMRK(tty)) { 1835 bitmap_zero(ldata->char_map, 256); 1836 1837 if (I_IGNCR(tty) || I_ICRNL(tty)) 1838 set_bit('\r', ldata->char_map); 1839 if (I_INLCR(tty)) 1840 set_bit('\n', ldata->char_map); 1841 1842 if (L_ICANON(tty)) { 1843 set_bit(ERASE_CHAR(tty), ldata->char_map); 1844 set_bit(KILL_CHAR(tty), ldata->char_map); 1845 set_bit(EOF_CHAR(tty), ldata->char_map); 1846 set_bit('\n', ldata->char_map); 1847 set_bit(EOL_CHAR(tty), ldata->char_map); 1848 if (L_IEXTEN(tty)) { 1849 set_bit(WERASE_CHAR(tty), ldata->char_map); 1850 set_bit(LNEXT_CHAR(tty), ldata->char_map); 1851 set_bit(EOL2_CHAR(tty), ldata->char_map); 1852 if (L_ECHO(tty)) 1853 set_bit(REPRINT_CHAR(tty), 1854 ldata->char_map); 1855 } 1856 } 1857 if (I_IXON(tty)) { 1858 set_bit(START_CHAR(tty), ldata->char_map); 1859 set_bit(STOP_CHAR(tty), ldata->char_map); 1860 } 1861 if (L_ISIG(tty)) { 1862 set_bit(INTR_CHAR(tty), ldata->char_map); 1863 set_bit(QUIT_CHAR(tty), ldata->char_map); 1864 set_bit(SUSP_CHAR(tty), ldata->char_map); 1865 } 1866 clear_bit(__DISABLED_CHAR, ldata->char_map); 1867 ldata->raw = 0; 1868 ldata->real_raw = 0; 1869 } else { 1870 ldata->raw = 1; 1871 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) && 1872 (I_IGNPAR(tty) || !I_INPCK(tty)) && 1873 (tty->driver->flags & TTY_DRIVER_REAL_RAW)) 1874 ldata->real_raw = 1; 1875 else 1876 ldata->real_raw = 0; 1877 } 1878 /* 1879 * Fix tty hang when I_IXON(tty) is cleared, but the tty 1880 * been stopped by STOP_CHAR(tty) before it. 1881 */ 1882 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) { 1883 start_tty(tty); 1884 process_echoes(tty); 1885 } 1886 1887 /* The termios change make the tty ready for I/O */ 1888 wake_up_interruptible(&tty->write_wait); 1889 wake_up_interruptible(&tty->read_wait); 1890 } 1891 1892 /** 1893 * n_tty_close - close the ldisc for this tty 1894 * @tty: device 1895 * 1896 * Called from the terminal layer when this line discipline is 1897 * being shut down, either because of a close or becsuse of a 1898 * discipline change. The function will not be called while other 1899 * ldisc methods are in progress. 1900 */ 1901 1902 static void n_tty_close(struct tty_struct *tty) 1903 { 1904 struct n_tty_data *ldata = tty->disc_data; 1905 1906 if (tty->link) 1907 n_tty_packet_mode_flush(tty); 1908 1909 vfree(ldata); 1910 tty->disc_data = NULL; 1911 } 1912 1913 /** 1914 * n_tty_open - open an ldisc 1915 * @tty: terminal to open 1916 * 1917 * Called when this line discipline is being attached to the 1918 * terminal device. Can sleep. Called serialized so that no 1919 * other events will occur in parallel. No further open will occur 1920 * until a close. 1921 */ 1922 1923 static int n_tty_open(struct tty_struct *tty) 1924 { 1925 struct n_tty_data *ldata; 1926 1927 /* Currently a malloc failure here can panic */ 1928 ldata = vmalloc(sizeof(*ldata)); 1929 if (!ldata) 1930 goto err; 1931 1932 ldata->overrun_time = jiffies; 1933 mutex_init(&ldata->atomic_read_lock); 1934 mutex_init(&ldata->output_lock); 1935 1936 tty->disc_data = ldata; 1937 reset_buffer_flags(tty->disc_data); 1938 ldata->column = 0; 1939 ldata->canon_column = 0; 1940 ldata->minimum_to_wake = 1; 1941 ldata->num_overrun = 0; 1942 ldata->no_room = 0; 1943 ldata->lnext = 0; 1944 tty->closing = 0; 1945 /* indicate buffer work may resume */ 1946 clear_bit(TTY_LDISC_HALTED, &tty->flags); 1947 n_tty_set_termios(tty, NULL); 1948 tty_unthrottle(tty); 1949 1950 return 0; 1951 err: 1952 return -ENOMEM; 1953 } 1954 1955 static inline int input_available_p(struct tty_struct *tty, int poll) 1956 { 1957 struct n_tty_data *ldata = tty->disc_data; 1958 int amt = poll && !TIME_CHAR(tty) && MIN_CHAR(tty) ? MIN_CHAR(tty) : 1; 1959 1960 if (ldata->icanon && !L_EXTPROC(tty)) 1961 return ldata->canon_head != ldata->read_tail; 1962 else 1963 return ldata->commit_head - ldata->read_tail >= amt; 1964 } 1965 1966 static inline int check_other_done(struct tty_struct *tty) 1967 { 1968 int done = test_bit(TTY_OTHER_DONE, &tty->flags); 1969 if (done) { 1970 /* paired with cmpxchg() in check_other_closed(); ensures 1971 * read buffer head index is not stale 1972 */ 1973 smp_mb__after_atomic(); 1974 } 1975 return done; 1976 } 1977 1978 /** 1979 * copy_from_read_buf - copy read data directly 1980 * @tty: terminal device 1981 * @b: user data 1982 * @nr: size of data 1983 * 1984 * Helper function to speed up n_tty_read. It is only called when 1985 * ICANON is off; it copies characters straight from the tty queue to 1986 * user space directly. It can be profitably called twice; once to 1987 * drain the space from the tail pointer to the (physical) end of the 1988 * buffer, and once to drain the space from the (physical) beginning of 1989 * the buffer to head pointer. 1990 * 1991 * Called under the ldata->atomic_read_lock sem 1992 * 1993 * n_tty_read()/consumer path: 1994 * caller holds non-exclusive termios_rwsem 1995 * read_tail published 1996 */ 1997 1998 static int copy_from_read_buf(struct tty_struct *tty, 1999 unsigned char __user **b, 2000 size_t *nr) 2001 2002 { 2003 struct n_tty_data *ldata = tty->disc_data; 2004 int retval; 2005 size_t n; 2006 bool is_eof; 2007 size_t head = smp_load_acquire(&ldata->commit_head); 2008 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); 2009 2010 retval = 0; 2011 n = min(head - ldata->read_tail, N_TTY_BUF_SIZE - tail); 2012 n = min(*nr, n); 2013 if (n) { 2014 const unsigned char *from = read_buf_addr(ldata, tail); 2015 retval = copy_to_user(*b, from, n); 2016 n -= retval; 2017 is_eof = n == 1 && *from == EOF_CHAR(tty); 2018 tty_audit_add_data(tty, from, n, ldata->icanon); 2019 smp_store_release(&ldata->read_tail, ldata->read_tail + n); 2020 /* Turn single EOF into zero-length read */ 2021 if (L_EXTPROC(tty) && ldata->icanon && is_eof && 2022 (head == ldata->read_tail)) 2023 n = 0; 2024 *b += n; 2025 *nr -= n; 2026 } 2027 return retval; 2028 } 2029 2030 /** 2031 * canon_copy_from_read_buf - copy read data in canonical mode 2032 * @tty: terminal device 2033 * @b: user data 2034 * @nr: size of data 2035 * 2036 * Helper function for n_tty_read. It is only called when ICANON is on; 2037 * it copies one line of input up to and including the line-delimiting 2038 * character into the user-space buffer. 2039 * 2040 * NB: When termios is changed from non-canonical to canonical mode and 2041 * the read buffer contains data, n_tty_set_termios() simulates an EOF 2042 * push (as if C-d were input) _without_ the DISABLED_CHAR in the buffer. 2043 * This causes data already processed as input to be immediately available 2044 * as input although a newline has not been received. 2045 * 2046 * Called under the atomic_read_lock mutex 2047 * 2048 * n_tty_read()/consumer path: 2049 * caller holds non-exclusive termios_rwsem 2050 * read_tail published 2051 */ 2052 2053 static int canon_copy_from_read_buf(struct tty_struct *tty, 2054 unsigned char __user **b, 2055 size_t *nr) 2056 { 2057 struct n_tty_data *ldata = tty->disc_data; 2058 size_t n, size, more, c; 2059 size_t eol; 2060 size_t tail; 2061 int ret, found = 0; 2062 2063 /* N.B. avoid overrun if nr == 0 */ 2064 if (!*nr) 2065 return 0; 2066 2067 n = min(*nr + 1, smp_load_acquire(&ldata->canon_head) - ldata->read_tail); 2068 2069 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); 2070 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE); 2071 2072 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n", 2073 __func__, *nr, tail, n, size); 2074 2075 eol = find_next_bit(ldata->read_flags, size, tail); 2076 more = n - (size - tail); 2077 if (eol == N_TTY_BUF_SIZE && more) { 2078 /* scan wrapped without finding set bit */ 2079 eol = find_next_bit(ldata->read_flags, more, 0); 2080 found = eol != more; 2081 } else 2082 found = eol != size; 2083 2084 n = eol - tail; 2085 if (n > N_TTY_BUF_SIZE) 2086 n += N_TTY_BUF_SIZE; 2087 c = n + found; 2088 2089 if (!found || read_buf(ldata, eol) != __DISABLED_CHAR) { 2090 c = min(*nr, c); 2091 n = c; 2092 } 2093 2094 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu tail:%zu more:%zu\n", 2095 __func__, eol, found, n, c, tail, more); 2096 2097 ret = tty_copy_to_user(tty, *b, tail, n); 2098 if (ret) 2099 return -EFAULT; 2100 *b += n; 2101 *nr -= n; 2102 2103 if (found) 2104 clear_bit(eol, ldata->read_flags); 2105 smp_store_release(&ldata->read_tail, ldata->read_tail + c); 2106 2107 if (found) { 2108 if (!ldata->push) 2109 ldata->line_start = ldata->read_tail; 2110 else 2111 ldata->push = 0; 2112 tty_audit_push(tty); 2113 } 2114 return 0; 2115 } 2116 2117 extern ssize_t redirected_tty_write(struct file *, const char __user *, 2118 size_t, loff_t *); 2119 2120 /** 2121 * job_control - check job control 2122 * @tty: tty 2123 * @file: file handle 2124 * 2125 * Perform job control management checks on this file/tty descriptor 2126 * and if appropriate send any needed signals and return a negative 2127 * error code if action should be taken. 2128 * 2129 * Locking: redirected write test is safe 2130 * current->signal->tty check is safe 2131 * ctrl_lock to safely reference tty->pgrp 2132 */ 2133 2134 static int job_control(struct tty_struct *tty, struct file *file) 2135 { 2136 /* Job control check -- must be done at start and after 2137 every sleep (POSIX.1 7.1.1.4). */ 2138 /* NOTE: not yet done after every sleep pending a thorough 2139 check of the logic of this change. -- jlc */ 2140 /* don't stop on /dev/console */ 2141 if (file->f_op->write == redirected_tty_write) 2142 return 0; 2143 2144 return __tty_check_change(tty, SIGTTIN); 2145 } 2146 2147 2148 /** 2149 * n_tty_read - read function for tty 2150 * @tty: tty device 2151 * @file: file object 2152 * @buf: userspace buffer pointer 2153 * @nr: size of I/O 2154 * 2155 * Perform reads for the line discipline. We are guaranteed that the 2156 * line discipline will not be closed under us but we may get multiple 2157 * parallel readers and must handle this ourselves. We may also get 2158 * a hangup. Always called in user context, may sleep. 2159 * 2160 * This code must be sure never to sleep through a hangup. 2161 * 2162 * n_tty_read()/consumer path: 2163 * claims non-exclusive termios_rwsem 2164 * publishes read_tail 2165 */ 2166 2167 static ssize_t n_tty_read(struct tty_struct *tty, struct file *file, 2168 unsigned char __user *buf, size_t nr) 2169 { 2170 struct n_tty_data *ldata = tty->disc_data; 2171 unsigned char __user *b = buf; 2172 DEFINE_WAIT_FUNC(wait, woken_wake_function); 2173 int c, done; 2174 int minimum, time; 2175 ssize_t retval = 0; 2176 long timeout; 2177 int packet; 2178 size_t tail; 2179 2180 c = job_control(tty, file); 2181 if (c < 0) 2182 return c; 2183 2184 /* 2185 * Internal serialization of reads. 2186 */ 2187 if (file->f_flags & O_NONBLOCK) { 2188 if (!mutex_trylock(&ldata->atomic_read_lock)) 2189 return -EAGAIN; 2190 } else { 2191 if (mutex_lock_interruptible(&ldata->atomic_read_lock)) 2192 return -ERESTARTSYS; 2193 } 2194 2195 down_read(&tty->termios_rwsem); 2196 2197 minimum = time = 0; 2198 timeout = MAX_SCHEDULE_TIMEOUT; 2199 if (!ldata->icanon) { 2200 minimum = MIN_CHAR(tty); 2201 if (minimum) { 2202 time = (HZ / 10) * TIME_CHAR(tty); 2203 if (time) 2204 ldata->minimum_to_wake = 1; 2205 else if (!waitqueue_active(&tty->read_wait) || 2206 (ldata->minimum_to_wake > minimum)) 2207 ldata->minimum_to_wake = minimum; 2208 } else { 2209 timeout = (HZ / 10) * TIME_CHAR(tty); 2210 ldata->minimum_to_wake = minimum = 1; 2211 } 2212 } 2213 2214 packet = tty->packet; 2215 tail = ldata->read_tail; 2216 2217 add_wait_queue(&tty->read_wait, &wait); 2218 while (nr) { 2219 /* First test for status change. */ 2220 if (packet && tty->link->ctrl_status) { 2221 unsigned char cs; 2222 if (b != buf) 2223 break; 2224 spin_lock_irq(&tty->link->ctrl_lock); 2225 cs = tty->link->ctrl_status; 2226 tty->link->ctrl_status = 0; 2227 spin_unlock_irq(&tty->link->ctrl_lock); 2228 if (tty_put_user(tty, cs, b++)) { 2229 retval = -EFAULT; 2230 b--; 2231 break; 2232 } 2233 nr--; 2234 break; 2235 } 2236 2237 if (((minimum - (b - buf)) < ldata->minimum_to_wake) && 2238 ((minimum - (b - buf)) >= 1)) 2239 ldata->minimum_to_wake = (minimum - (b - buf)); 2240 2241 done = check_other_done(tty); 2242 2243 if (!input_available_p(tty, 0)) { 2244 if (done) { 2245 retval = -EIO; 2246 break; 2247 } 2248 if (tty_hung_up_p(file)) 2249 break; 2250 if (!timeout) 2251 break; 2252 if (file->f_flags & O_NONBLOCK) { 2253 retval = -EAGAIN; 2254 break; 2255 } 2256 if (signal_pending(current)) { 2257 retval = -ERESTARTSYS; 2258 break; 2259 } 2260 up_read(&tty->termios_rwsem); 2261 2262 timeout = wait_woken(&wait, TASK_INTERRUPTIBLE, 2263 timeout); 2264 2265 down_read(&tty->termios_rwsem); 2266 continue; 2267 } 2268 2269 if (ldata->icanon && !L_EXTPROC(tty)) { 2270 retval = canon_copy_from_read_buf(tty, &b, &nr); 2271 if (retval) 2272 break; 2273 } else { 2274 int uncopied; 2275 2276 /* Deal with packet mode. */ 2277 if (packet && b == buf) { 2278 if (tty_put_user(tty, TIOCPKT_DATA, b++)) { 2279 retval = -EFAULT; 2280 b--; 2281 break; 2282 } 2283 nr--; 2284 } 2285 2286 uncopied = copy_from_read_buf(tty, &b, &nr); 2287 uncopied += copy_from_read_buf(tty, &b, &nr); 2288 if (uncopied) { 2289 retval = -EFAULT; 2290 break; 2291 } 2292 } 2293 2294 n_tty_check_unthrottle(tty); 2295 2296 if (b - buf >= minimum) 2297 break; 2298 if (time) 2299 timeout = time; 2300 } 2301 if (tail != ldata->read_tail) 2302 n_tty_kick_worker(tty); 2303 up_read(&tty->termios_rwsem); 2304 2305 remove_wait_queue(&tty->read_wait, &wait); 2306 if (!waitqueue_active(&tty->read_wait)) 2307 ldata->minimum_to_wake = minimum; 2308 2309 mutex_unlock(&ldata->atomic_read_lock); 2310 2311 if (b - buf) 2312 retval = b - buf; 2313 2314 return retval; 2315 } 2316 2317 /** 2318 * n_tty_write - write function for tty 2319 * @tty: tty device 2320 * @file: file object 2321 * @buf: userspace buffer pointer 2322 * @nr: size of I/O 2323 * 2324 * Write function of the terminal device. This is serialized with 2325 * respect to other write callers but not to termios changes, reads 2326 * and other such events. Since the receive code will echo characters, 2327 * thus calling driver write methods, the output_lock is used in 2328 * the output processing functions called here as well as in the 2329 * echo processing function to protect the column state and space 2330 * left in the buffer. 2331 * 2332 * This code must be sure never to sleep through a hangup. 2333 * 2334 * Locking: output_lock to protect column state and space left 2335 * (note that the process_output*() functions take this 2336 * lock themselves) 2337 */ 2338 2339 static ssize_t n_tty_write(struct tty_struct *tty, struct file *file, 2340 const unsigned char *buf, size_t nr) 2341 { 2342 const unsigned char *b = buf; 2343 DEFINE_WAIT_FUNC(wait, woken_wake_function); 2344 int c; 2345 ssize_t retval = 0; 2346 2347 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */ 2348 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) { 2349 retval = tty_check_change(tty); 2350 if (retval) 2351 return retval; 2352 } 2353 2354 down_read(&tty->termios_rwsem); 2355 2356 /* Write out any echoed characters that are still pending */ 2357 process_echoes(tty); 2358 2359 add_wait_queue(&tty->write_wait, &wait); 2360 while (1) { 2361 if (signal_pending(current)) { 2362 retval = -ERESTARTSYS; 2363 break; 2364 } 2365 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) { 2366 retval = -EIO; 2367 break; 2368 } 2369 if (O_OPOST(tty)) { 2370 while (nr > 0) { 2371 ssize_t num = process_output_block(tty, b, nr); 2372 if (num < 0) { 2373 if (num == -EAGAIN) 2374 break; 2375 retval = num; 2376 goto break_out; 2377 } 2378 b += num; 2379 nr -= num; 2380 if (nr == 0) 2381 break; 2382 c = *b; 2383 if (process_output(c, tty) < 0) 2384 break; 2385 b++; nr--; 2386 } 2387 if (tty->ops->flush_chars) 2388 tty->ops->flush_chars(tty); 2389 } else { 2390 struct n_tty_data *ldata = tty->disc_data; 2391 2392 while (nr > 0) { 2393 mutex_lock(&ldata->output_lock); 2394 c = tty->ops->write(tty, b, nr); 2395 mutex_unlock(&ldata->output_lock); 2396 if (c < 0) { 2397 retval = c; 2398 goto break_out; 2399 } 2400 if (!c) 2401 break; 2402 b += c; 2403 nr -= c; 2404 } 2405 } 2406 if (!nr) 2407 break; 2408 if (file->f_flags & O_NONBLOCK) { 2409 retval = -EAGAIN; 2410 break; 2411 } 2412 up_read(&tty->termios_rwsem); 2413 2414 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT); 2415 2416 down_read(&tty->termios_rwsem); 2417 } 2418 break_out: 2419 remove_wait_queue(&tty->write_wait, &wait); 2420 if (b - buf != nr && tty->fasync) 2421 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 2422 up_read(&tty->termios_rwsem); 2423 return (b - buf) ? b - buf : retval; 2424 } 2425 2426 /** 2427 * n_tty_poll - poll method for N_TTY 2428 * @tty: terminal device 2429 * @file: file accessing it 2430 * @wait: poll table 2431 * 2432 * Called when the line discipline is asked to poll() for data or 2433 * for special events. This code is not serialized with respect to 2434 * other events save open/close. 2435 * 2436 * This code must be sure never to sleep through a hangup. 2437 * Called without the kernel lock held - fine 2438 */ 2439 2440 static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file, 2441 poll_table *wait) 2442 { 2443 struct n_tty_data *ldata = tty->disc_data; 2444 unsigned int mask = 0; 2445 2446 poll_wait(file, &tty->read_wait, wait); 2447 poll_wait(file, &tty->write_wait, wait); 2448 if (check_other_done(tty)) 2449 mask |= POLLHUP; 2450 if (input_available_p(tty, 1)) 2451 mask |= POLLIN | POLLRDNORM; 2452 if (tty->packet && tty->link->ctrl_status) 2453 mask |= POLLPRI | POLLIN | POLLRDNORM; 2454 if (tty_hung_up_p(file)) 2455 mask |= POLLHUP; 2456 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) { 2457 if (MIN_CHAR(tty) && !TIME_CHAR(tty)) 2458 ldata->minimum_to_wake = MIN_CHAR(tty); 2459 else 2460 ldata->minimum_to_wake = 1; 2461 } 2462 if (tty->ops->write && !tty_is_writelocked(tty) && 2463 tty_chars_in_buffer(tty) < WAKEUP_CHARS && 2464 tty_write_room(tty) > 0) 2465 mask |= POLLOUT | POLLWRNORM; 2466 return mask; 2467 } 2468 2469 static unsigned long inq_canon(struct n_tty_data *ldata) 2470 { 2471 size_t nr, head, tail; 2472 2473 if (ldata->canon_head == ldata->read_tail) 2474 return 0; 2475 head = ldata->canon_head; 2476 tail = ldata->read_tail; 2477 nr = head - tail; 2478 /* Skip EOF-chars.. */ 2479 while (head != tail) { 2480 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) && 2481 read_buf(ldata, tail) == __DISABLED_CHAR) 2482 nr--; 2483 tail++; 2484 } 2485 return nr; 2486 } 2487 2488 static int n_tty_ioctl(struct tty_struct *tty, struct file *file, 2489 unsigned int cmd, unsigned long arg) 2490 { 2491 struct n_tty_data *ldata = tty->disc_data; 2492 int retval; 2493 2494 switch (cmd) { 2495 case TIOCOUTQ: 2496 return put_user(tty_chars_in_buffer(tty), (int __user *) arg); 2497 case TIOCINQ: 2498 down_write(&tty->termios_rwsem); 2499 if (L_ICANON(tty)) 2500 retval = inq_canon(ldata); 2501 else 2502 retval = read_cnt(ldata); 2503 up_write(&tty->termios_rwsem); 2504 return put_user(retval, (unsigned int __user *) arg); 2505 default: 2506 return n_tty_ioctl_helper(tty, file, cmd, arg); 2507 } 2508 } 2509 2510 static void n_tty_fasync(struct tty_struct *tty, int on) 2511 { 2512 struct n_tty_data *ldata = tty->disc_data; 2513 2514 if (!waitqueue_active(&tty->read_wait)) { 2515 if (on) 2516 ldata->minimum_to_wake = 1; 2517 else if (!tty->fasync) 2518 ldata->minimum_to_wake = N_TTY_BUF_SIZE; 2519 } 2520 } 2521 2522 struct tty_ldisc_ops tty_ldisc_N_TTY = { 2523 .magic = TTY_LDISC_MAGIC, 2524 .name = "n_tty", 2525 .open = n_tty_open, 2526 .close = n_tty_close, 2527 .flush_buffer = n_tty_flush_buffer, 2528 .chars_in_buffer = n_tty_chars_in_buffer, 2529 .read = n_tty_read, 2530 .write = n_tty_write, 2531 .ioctl = n_tty_ioctl, 2532 .set_termios = n_tty_set_termios, 2533 .poll = n_tty_poll, 2534 .receive_buf = n_tty_receive_buf, 2535 .write_wakeup = n_tty_write_wakeup, 2536 .fasync = n_tty_fasync, 2537 .receive_buf2 = n_tty_receive_buf2, 2538 }; 2539 2540 /** 2541 * n_tty_inherit_ops - inherit N_TTY methods 2542 * @ops: struct tty_ldisc_ops where to save N_TTY methods 2543 * 2544 * Enables a 'subclass' line discipline to 'inherit' N_TTY 2545 * methods. 2546 */ 2547 2548 void n_tty_inherit_ops(struct tty_ldisc_ops *ops) 2549 { 2550 *ops = tty_ldisc_N_TTY; 2551 ops->owner = NULL; 2552 ops->refcount = ops->flags = 0; 2553 } 2554 EXPORT_SYMBOL_GPL(n_tty_inherit_ops); 2555