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