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