2 * n_tty.c --- implements the N_TTY line discipline.
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,
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.
13 * Written by Theodore Ts'o, Copyright 1994.
15 * This file also contains code originally written by Linus Torvalds,
16 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
18 * This file may be redistributed under the terms of the GNU General Public
21 * Reduced memory usage for older ARM systems - Russell King.
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.
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
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>
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>
54 /* number of characters left in xmit buffer before select has we have room */
55 #define WAKEUP_CHARS 256
58 * This defines the low- and high-watermarks for throttling and
59 * unthrottling the TTY driver. These watermarks are used for
60 * controlling the space in the read buffer.
62 #define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */
63 #define TTY_THRESHOLD_UNTHROTTLE 128
66 * Special byte codes used in the echo buffer to represent operations
67 * or special handling of characters. Bytes in the echo buffer that
68 * are not part of such special blocks are treated as normal character
71 #define ECHO_OP_START 0xff
72 #define ECHO_OP_MOVE_BACK_COL 0x80
73 #define ECHO_OP_SET_CANON_COL 0x81
74 #define ECHO_OP_ERASE_TAB 0x82
78 unsigned long overrun_time;
81 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
82 unsigned char echo_overrun:1;
84 DECLARE_BITMAP(process_char_map, 256);
85 DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
92 unsigned char *echo_buf;
93 unsigned int echo_pos;
94 unsigned int echo_cnt;
97 unsigned long canon_head;
98 unsigned int canon_column;
100 struct mutex atomic_read_lock;
101 struct mutex output_lock;
102 struct mutex echo_lock;
103 spinlock_t read_lock;
106 static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
107 unsigned char __user *ptr)
109 struct n_tty_data *ldata = tty->disc_data;
111 tty_audit_add_data(tty, &x, 1, ldata->icanon);
112 return put_user(x, ptr);
116 * n_tty_set__room - receive space
119 * Called by the driver to find out how much data it is
120 * permitted to feed to the line discipline without any being lost
121 * and thus to manage flow control. Not serialized. Answers for the
125 static void n_tty_set_room(struct tty_struct *tty)
127 struct n_tty_data *ldata = tty->disc_data;
131 /* ldata->read_cnt is not read locked ? */
133 /* Multiply read_cnt by 3, since each byte might take up to
134 * three times as many spaces when PARMRK is set (depending on
135 * its flags, e.g. parity error). */
136 left = N_TTY_BUF_SIZE - ldata->read_cnt * 3 - 1;
138 left = N_TTY_BUF_SIZE - ldata->read_cnt - 1;
141 * If we are doing input canonicalization, and there are no
142 * pending newlines, let characters through without limit, so
143 * that erase characters will be handled. Other excess
144 * characters will be beeped.
147 left = ldata->icanon && !ldata->canon_data;
148 old_left = tty->receive_room;
149 tty->receive_room = left;
151 /* Did this open up the receive buffer? We may need to flip */
152 if (left && !old_left) {
153 WARN_RATELIMIT(tty->port->itty == NULL,
154 "scheduling with invalid itty\n");
155 schedule_work(&tty->port->buf.work);
159 static void put_tty_queue_nolock(unsigned char c, struct n_tty_data *ldata)
161 if (ldata->read_cnt < N_TTY_BUF_SIZE) {
162 ldata->read_buf[ldata->read_head] = c;
163 ldata->read_head = (ldata->read_head + 1) & (N_TTY_BUF_SIZE-1);
169 * put_tty_queue - add character to tty
173 * Add a character to the tty read_buf queue. This is done under the
174 * read_lock to serialize character addition and also to protect us
175 * against parallel reads or flushes
178 static void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
182 * The problem of stomping on the buffers ends here.
183 * Why didn't anyone see this one coming? --AJK
185 spin_lock_irqsave(&ldata->read_lock, flags);
186 put_tty_queue_nolock(c, ldata);
187 spin_unlock_irqrestore(&ldata->read_lock, flags);
191 * check_unthrottle - allow new receive data
194 * Check whether to call the driver unthrottle functions
196 * Can sleep, may be called under the atomic_read_lock mutex but
197 * this is not guaranteed.
199 static void check_unthrottle(struct tty_struct *tty)
206 * reset_buffer_flags - reset buffer state
207 * @tty: terminal to reset
209 * Reset the read buffer counters, clear the flags,
210 * and make sure the driver is unthrottled. Called
211 * from n_tty_open() and n_tty_flush_buffer().
213 * Locking: tty_read_lock for read fields.
216 static void reset_buffer_flags(struct tty_struct *tty)
218 struct n_tty_data *ldata = tty->disc_data;
221 spin_lock_irqsave(&ldata->read_lock, flags);
222 ldata->read_head = ldata->read_tail = ldata->read_cnt = 0;
223 spin_unlock_irqrestore(&ldata->read_lock, flags);
225 mutex_lock(&ldata->echo_lock);
226 ldata->echo_pos = ldata->echo_cnt = ldata->echo_overrun = 0;
227 mutex_unlock(&ldata->echo_lock);
229 ldata->canon_head = ldata->canon_data = ldata->erasing = 0;
230 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
233 check_unthrottle(tty);
237 * n_tty_flush_buffer - clean input queue
238 * @tty: terminal device
240 * Flush the input buffer. Called when the line discipline is
241 * being closed, when the tty layer wants the buffer flushed (eg
242 * at hangup) or when the N_TTY line discipline internally has to
243 * clean the pending queue (for example some signals).
245 * Locking: ctrl_lock, read_lock.
248 static void n_tty_flush_buffer(struct tty_struct *tty)
251 /* clear everything and unthrottle the driver */
252 reset_buffer_flags(tty);
257 spin_lock_irqsave(&tty->ctrl_lock, flags);
258 if (tty->link->packet) {
259 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
260 wake_up_interruptible(&tty->link->read_wait);
262 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
266 * n_tty_chars_in_buffer - report available bytes
269 * Report the number of characters buffered to be delivered to user
270 * at this instant in time.
275 static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
277 struct n_tty_data *ldata = tty->disc_data;
281 spin_lock_irqsave(&ldata->read_lock, flags);
282 if (!ldata->icanon) {
284 } else if (ldata->canon_data) {
285 n = (ldata->canon_head > ldata->read_tail) ?
286 ldata->canon_head - ldata->read_tail :
287 ldata->canon_head + (N_TTY_BUF_SIZE - ldata->read_tail);
289 spin_unlock_irqrestore(&ldata->read_lock, flags);
294 * is_utf8_continuation - utf8 multibyte check
297 * Returns true if the utf8 character 'c' is a multibyte continuation
298 * character. We use this to correctly compute the on screen size
299 * of the character when printing
302 static inline int is_utf8_continuation(unsigned char c)
304 return (c & 0xc0) == 0x80;
308 * is_continuation - multibyte check
311 * Returns true if the utf8 character 'c' is a multibyte continuation
312 * character and the terminal is in unicode mode.
315 static inline int is_continuation(unsigned char c, struct tty_struct *tty)
317 return I_IUTF8(tty) && is_utf8_continuation(c);
321 * do_output_char - output one character
322 * @c: character (or partial unicode symbol)
323 * @tty: terminal device
324 * @space: space available in tty driver write buffer
326 * This is a helper function that handles one output character
327 * (including special characters like TAB, CR, LF, etc.),
328 * doing OPOST processing and putting the results in the
329 * tty driver's write buffer.
331 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
332 * and NLDLY. They simply aren't relevant in the world today.
333 * If you ever need them, add them here.
335 * Returns the number of bytes of buffer space used or -1 if
338 * Locking: should be called under the output_lock to protect
339 * the column state and space left in the buffer
342 static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
344 struct n_tty_data *ldata = tty->disc_data;
357 ldata->canon_column = ldata->column = 0;
358 tty->ops->write(tty, "\r\n", 2);
361 ldata->canon_column = ldata->column;
364 if (O_ONOCR(tty) && ldata->column == 0)
369 ldata->canon_column = ldata->column = 0;
372 ldata->canon_column = ldata->column = 0;
375 spaces = 8 - (ldata->column & 7);
376 if (O_TABDLY(tty) == XTABS) {
379 ldata->column += spaces;
380 tty->ops->write(tty, " ", spaces);
383 ldata->column += spaces;
386 if (ldata->column > 0)
393 if (!is_continuation(c, tty))
399 tty_put_char(tty, c);
404 * process_output - output post processor
405 * @c: character (or partial unicode symbol)
406 * @tty: terminal device
408 * Output one character with OPOST processing.
409 * Returns -1 when the output device is full and the character
412 * Locking: output_lock to protect column state and space left
413 * (also, this is called from n_tty_write under the
414 * tty layer write lock)
417 static int process_output(unsigned char c, struct tty_struct *tty)
419 struct n_tty_data *ldata = tty->disc_data;
422 mutex_lock(&ldata->output_lock);
424 space = tty_write_room(tty);
425 retval = do_output_char(c, tty, space);
427 mutex_unlock(&ldata->output_lock);
435 * process_output_block - block post processor
436 * @tty: terminal device
437 * @buf: character buffer
438 * @nr: number of bytes to output
440 * Output a block of characters with OPOST processing.
441 * Returns the number of characters output.
443 * This path is used to speed up block console writes, among other
444 * things when processing blocks of output data. It handles only
445 * the simple cases normally found and helps to generate blocks of
446 * symbols for the console driver and thus improve performance.
448 * Locking: output_lock to protect column state and space left
449 * (also, this is called from n_tty_write under the
450 * tty layer write lock)
453 static ssize_t process_output_block(struct tty_struct *tty,
454 const unsigned char *buf, unsigned int nr)
456 struct n_tty_data *ldata = tty->disc_data;
459 const unsigned char *cp;
461 mutex_lock(&ldata->output_lock);
463 space = tty_write_room(tty);
465 mutex_unlock(&ldata->output_lock);
471 for (i = 0, cp = buf; i < nr; i++, cp++) {
472 unsigned char c = *cp;
480 ldata->canon_column = ldata->column;
483 if (O_ONOCR(tty) && ldata->column == 0)
487 ldata->canon_column = ldata->column = 0;
492 if (ldata->column > 0)
499 if (!is_continuation(c, tty))
506 i = tty->ops->write(tty, buf, i);
508 mutex_unlock(&ldata->output_lock);
513 * process_echoes - write pending echo characters
514 * @tty: terminal device
516 * Write previously buffered echo (and other ldisc-generated)
517 * characters to the tty.
519 * Characters generated by the ldisc (including echoes) need to
520 * be buffered because the driver's write buffer can fill during
521 * heavy program output. Echoing straight to the driver will
522 * often fail under these conditions, causing lost characters and
523 * resulting mismatches of ldisc state information.
525 * Since the ldisc state must represent the characters actually sent
526 * to the driver at the time of the write, operations like certain
527 * changes in column state are also saved in the buffer and executed
530 * A circular fifo buffer is used so that the most recent characters
531 * are prioritized. Also, when control characters are echoed with a
532 * prefixed "^", the pair is treated atomically and thus not separated.
534 * Locking: output_lock to protect column state and space left,
535 * echo_lock to protect the echo buffer
538 static void process_echoes(struct tty_struct *tty)
540 struct n_tty_data *ldata = tty->disc_data;
543 unsigned char *cp, *buf_end;
545 if (!ldata->echo_cnt)
548 mutex_lock(&ldata->output_lock);
549 mutex_lock(&ldata->echo_lock);
551 space = tty_write_room(tty);
553 buf_end = ldata->echo_buf + N_TTY_BUF_SIZE;
554 cp = ldata->echo_buf + ldata->echo_pos;
555 nr = ldata->echo_cnt;
558 if (c == ECHO_OP_START) {
561 int no_space_left = 0;
564 * If the buffer byte is the start of a multi-byte
565 * operation, get the next byte, which is either the
566 * op code or a control character value.
570 opp -= N_TTY_BUF_SIZE;
574 unsigned int num_chars, num_bs;
576 case ECHO_OP_ERASE_TAB:
577 if (++opp == buf_end)
578 opp -= N_TTY_BUF_SIZE;
582 * Determine how many columns to go back
583 * in order to erase the tab.
584 * This depends on the number of columns
585 * used by other characters within the tab
586 * area. If this (modulo 8) count is from
587 * the start of input rather than from a
588 * previous tab, we offset by canon column.
589 * Otherwise, tab spacing is normal.
591 if (!(num_chars & 0x80))
592 num_chars += ldata->canon_column;
593 num_bs = 8 - (num_chars & 7);
595 if (num_bs > space) {
601 tty_put_char(tty, '\b');
602 if (ldata->column > 0)
609 case ECHO_OP_SET_CANON_COL:
610 ldata->canon_column = ldata->column;
615 case ECHO_OP_MOVE_BACK_COL:
616 if (ldata->column > 0)
623 /* This is an escaped echo op start code */
628 tty_put_char(tty, ECHO_OP_START);
637 * If the op is not a special byte code,
638 * it is a ctrl char tagged to be echoed
639 * as "^X" (where X is the letter
640 * representing the control char).
641 * Note that we must ensure there is
642 * enough space for the whole ctrl pair.
649 tty_put_char(tty, '^');
650 tty_put_char(tty, op ^ 0100);
661 !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
662 int retval = do_output_char(c, tty, space);
669 tty_put_char(tty, c);
676 /* When end of circular buffer reached, wrap around */
678 cp -= N_TTY_BUF_SIZE;
684 ldata->echo_overrun = 0;
686 int num_processed = ldata->echo_cnt - nr;
687 ldata->echo_pos += num_processed;
688 ldata->echo_pos &= N_TTY_BUF_SIZE - 1;
689 ldata->echo_cnt = nr;
690 if (num_processed > 0)
691 ldata->echo_overrun = 0;
694 mutex_unlock(&ldata->echo_lock);
695 mutex_unlock(&ldata->output_lock);
697 if (tty->ops->flush_chars)
698 tty->ops->flush_chars(tty);
702 * add_echo_byte - add a byte to the echo buffer
703 * @c: unicode byte to echo
706 * Add a character or operation byte to the echo buffer.
708 * Should be called under the echo lock to protect the echo buffer.
711 static void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
715 if (ldata->echo_cnt == N_TTY_BUF_SIZE) {
716 /* Circular buffer is already at capacity */
717 new_byte_pos = ldata->echo_pos;
720 * Since the buffer start position needs to be advanced,
721 * be sure to step by a whole operation byte group.
723 if (ldata->echo_buf[ldata->echo_pos] == ECHO_OP_START) {
724 if (ldata->echo_buf[(ldata->echo_pos + 1) &
725 (N_TTY_BUF_SIZE - 1)] ==
727 ldata->echo_pos += 3;
728 ldata->echo_cnt -= 2;
730 ldata->echo_pos += 2;
731 ldata->echo_cnt -= 1;
736 ldata->echo_pos &= N_TTY_BUF_SIZE - 1;
738 ldata->echo_overrun = 1;
740 new_byte_pos = ldata->echo_pos + ldata->echo_cnt;
741 new_byte_pos &= N_TTY_BUF_SIZE - 1;
745 ldata->echo_buf[new_byte_pos] = c;
749 * echo_move_back_col - add operation to move back a column
752 * Add an operation to the echo buffer to move back one column.
754 * Locking: echo_lock to protect the echo buffer
757 static void echo_move_back_col(struct n_tty_data *ldata)
759 mutex_lock(&ldata->echo_lock);
760 add_echo_byte(ECHO_OP_START, ldata);
761 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
762 mutex_unlock(&ldata->echo_lock);
766 * echo_set_canon_col - add operation to set the canon column
769 * Add an operation to the echo buffer to set the canon column
770 * to the current column.
772 * Locking: echo_lock to protect the echo buffer
775 static void echo_set_canon_col(struct n_tty_data *ldata)
777 mutex_lock(&ldata->echo_lock);
778 add_echo_byte(ECHO_OP_START, ldata);
779 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
780 mutex_unlock(&ldata->echo_lock);
784 * echo_erase_tab - add operation to erase a tab
785 * @num_chars: number of character columns already used
786 * @after_tab: true if num_chars starts after a previous tab
789 * Add an operation to the echo buffer to erase a tab.
791 * Called by the eraser function, which knows how many character
792 * columns have been used since either a previous tab or the start
793 * of input. This information will be used later, along with
794 * canon column (if applicable), to go back the correct number
797 * Locking: echo_lock to protect the echo buffer
800 static void echo_erase_tab(unsigned int num_chars, int after_tab,
801 struct n_tty_data *ldata)
803 mutex_lock(&ldata->echo_lock);
805 add_echo_byte(ECHO_OP_START, ldata);
806 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
808 /* We only need to know this modulo 8 (tab spacing) */
811 /* Set the high bit as a flag if num_chars is after a previous tab */
815 add_echo_byte(num_chars, ldata);
817 mutex_unlock(&ldata->echo_lock);
821 * echo_char_raw - echo a character raw
822 * @c: unicode byte to echo
823 * @tty: terminal device
825 * Echo user input back onto the screen. This must be called only when
826 * L_ECHO(tty) is true. Called from the driver receive_buf path.
828 * This variant does not treat control characters specially.
830 * Locking: echo_lock to protect the echo buffer
833 static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
835 mutex_lock(&ldata->echo_lock);
836 if (c == ECHO_OP_START) {
837 add_echo_byte(ECHO_OP_START, ldata);
838 add_echo_byte(ECHO_OP_START, ldata);
840 add_echo_byte(c, ldata);
842 mutex_unlock(&ldata->echo_lock);
846 * echo_char - echo a character
847 * @c: unicode byte to echo
848 * @tty: terminal device
850 * Echo user input back onto the screen. This must be called only when
851 * L_ECHO(tty) is true. Called from the driver receive_buf path.
853 * This variant tags control characters to be echoed as "^X"
854 * (where X is the letter representing the control char).
856 * Locking: echo_lock to protect the echo buffer
859 static void echo_char(unsigned char c, struct tty_struct *tty)
861 struct n_tty_data *ldata = tty->disc_data;
863 mutex_lock(&ldata->echo_lock);
865 if (c == ECHO_OP_START) {
866 add_echo_byte(ECHO_OP_START, ldata);
867 add_echo_byte(ECHO_OP_START, ldata);
869 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
870 add_echo_byte(ECHO_OP_START, ldata);
871 add_echo_byte(c, ldata);
874 mutex_unlock(&ldata->echo_lock);
878 * finish_erasing - complete erase
882 static inline void finish_erasing(struct n_tty_data *ldata)
884 if (ldata->erasing) {
885 echo_char_raw('/', ldata);
891 * eraser - handle erase function
892 * @c: character input
893 * @tty: terminal device
895 * Perform erase and necessary output when an erase character is
896 * present in the stream from the driver layer. Handles the complexities
897 * of UTF-8 multibyte symbols.
899 * Locking: read_lock for tty buffers
902 static void eraser(unsigned char c, struct tty_struct *tty)
904 struct n_tty_data *ldata = tty->disc_data;
905 enum { ERASE, WERASE, KILL } kill_type;
906 int head, seen_alnums, cnt;
909 /* FIXME: locking needed ? */
910 if (ldata->read_head == ldata->canon_head) {
911 /* process_output('\a', tty); */ /* what do you think? */
914 if (c == ERASE_CHAR(tty))
916 else if (c == WERASE_CHAR(tty))
920 spin_lock_irqsave(&ldata->read_lock, flags);
921 ldata->read_cnt -= ((ldata->read_head - ldata->canon_head) &
922 (N_TTY_BUF_SIZE - 1));
923 ldata->read_head = ldata->canon_head;
924 spin_unlock_irqrestore(&ldata->read_lock, flags);
927 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
928 spin_lock_irqsave(&ldata->read_lock, flags);
929 ldata->read_cnt -= ((ldata->read_head - ldata->canon_head) &
930 (N_TTY_BUF_SIZE - 1));
931 ldata->read_head = ldata->canon_head;
932 spin_unlock_irqrestore(&ldata->read_lock, flags);
933 finish_erasing(ldata);
934 echo_char(KILL_CHAR(tty), tty);
935 /* Add a newline if ECHOK is on and ECHOKE is off. */
937 echo_char_raw('\n', ldata);
944 /* FIXME: Locking ?? */
945 while (ldata->read_head != ldata->canon_head) {
946 head = ldata->read_head;
948 /* erase a single possibly multibyte character */
950 head = (head - 1) & (N_TTY_BUF_SIZE-1);
951 c = ldata->read_buf[head];
952 } while (is_continuation(c, tty) && head != ldata->canon_head);
954 /* do not partially erase */
955 if (is_continuation(c, tty))
958 if (kill_type == WERASE) {
959 /* Equivalent to BSD's ALTWERASE. */
960 if (isalnum(c) || c == '_')
962 else if (seen_alnums)
965 cnt = (ldata->read_head - head) & (N_TTY_BUF_SIZE-1);
966 spin_lock_irqsave(&ldata->read_lock, flags);
967 ldata->read_head = head;
968 ldata->read_cnt -= cnt;
969 spin_unlock_irqrestore(&ldata->read_lock, flags);
971 if (L_ECHOPRT(tty)) {
972 if (!ldata->erasing) {
973 echo_char_raw('\\', ldata);
976 /* if cnt > 1, output a multi-byte character */
979 head = (head+1) & (N_TTY_BUF_SIZE-1);
980 echo_char_raw(ldata->read_buf[head],
982 echo_move_back_col(ldata);
984 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
985 echo_char(ERASE_CHAR(tty), tty);
986 } else if (c == '\t') {
987 unsigned int num_chars = 0;
989 unsigned long tail = ldata->read_head;
992 * Count the columns used for characters
993 * since the start of input or after a
995 * This info is used to go back the correct
998 while (tail != ldata->canon_head) {
999 tail = (tail-1) & (N_TTY_BUF_SIZE-1);
1000 c = ldata->read_buf[tail];
1004 } else if (iscntrl(c)) {
1007 } else if (!is_continuation(c, tty)) {
1011 echo_erase_tab(num_chars, after_tab, ldata);
1013 if (iscntrl(c) && L_ECHOCTL(tty)) {
1014 echo_char_raw('\b', ldata);
1015 echo_char_raw(' ', ldata);
1016 echo_char_raw('\b', ldata);
1018 if (!iscntrl(c) || L_ECHOCTL(tty)) {
1019 echo_char_raw('\b', ldata);
1020 echo_char_raw(' ', ldata);
1021 echo_char_raw('\b', ldata);
1025 if (kill_type == ERASE)
1028 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
1029 finish_erasing(ldata);
1033 * isig - handle the ISIG optio
1036 * @flush: force flush
1038 * Called when a signal is being sent due to terminal input. This
1039 * may caus terminal flushing to take place according to the termios
1040 * settings and character used. Called from the driver receive_buf
1041 * path so serialized.
1043 * Locking: ctrl_lock, read_lock (both via flush buffer)
1046 static inline void isig(int sig, struct tty_struct *tty, int flush)
1049 kill_pgrp(tty->pgrp, sig, 1);
1050 if (flush || !L_NOFLSH(tty)) {
1051 n_tty_flush_buffer(tty);
1052 tty_driver_flush_buffer(tty);
1057 * n_tty_receive_break - handle break
1060 * An RS232 break event has been hit in the incoming bitstream. This
1061 * can cause a variety of events depending upon the termios settings.
1063 * Called from the receive_buf path so single threaded.
1066 static inline void n_tty_receive_break(struct tty_struct *tty)
1068 struct n_tty_data *ldata = tty->disc_data;
1072 if (I_BRKINT(tty)) {
1073 isig(SIGINT, tty, 1);
1076 if (I_PARMRK(tty)) {
1077 put_tty_queue('\377', ldata);
1078 put_tty_queue('\0', ldata);
1080 put_tty_queue('\0', ldata);
1081 wake_up_interruptible(&tty->read_wait);
1085 * n_tty_receive_overrun - handle overrun reporting
1088 * Data arrived faster than we could process it. While the tty
1089 * driver has flagged this the bits that were missed are gone
1092 * Called from the receive_buf path so single threaded. Does not
1093 * need locking as num_overrun and overrun_time are function
1097 static inline void n_tty_receive_overrun(struct tty_struct *tty)
1099 struct n_tty_data *ldata = tty->disc_data;
1102 ldata->num_overrun++;
1103 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1104 time_after(ldata->overrun_time, jiffies)) {
1105 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1107 ldata->num_overrun);
1108 ldata->overrun_time = jiffies;
1109 ldata->num_overrun = 0;
1114 * n_tty_receive_parity_error - error notifier
1115 * @tty: terminal device
1118 * Process a parity error and queue the right data to indicate
1119 * the error case if necessary. Locking as per n_tty_receive_buf.
1121 static inline void n_tty_receive_parity_error(struct tty_struct *tty,
1124 struct n_tty_data *ldata = tty->disc_data;
1128 if (I_PARMRK(tty)) {
1129 put_tty_queue('\377', ldata);
1130 put_tty_queue('\0', ldata);
1131 put_tty_queue(c, ldata);
1132 } else if (I_INPCK(tty))
1133 put_tty_queue('\0', ldata);
1135 put_tty_queue(c, ldata);
1136 wake_up_interruptible(&tty->read_wait);
1140 * n_tty_receive_char - perform processing
1141 * @tty: terminal device
1144 * Process an individual character of input received from the driver.
1145 * This is serialized with respect to itself by the rules for the
1149 static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1151 struct n_tty_data *ldata = tty->disc_data;
1152 unsigned long flags;
1156 put_tty_queue(c, ldata);
1162 if (I_IUCLC(tty) && L_IEXTEN(tty))
1165 if (L_EXTPROC(tty)) {
1166 put_tty_queue(c, ldata);
1170 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
1171 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
1172 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
1174 process_echoes(tty);
1179 if (c == START_CHAR(tty)) {
1181 process_echoes(tty);
1182 } else if (c == STOP_CHAR(tty))
1189 * If the previous character was LNEXT, or we know that this
1190 * character is not one of the characters that we'll have to
1191 * handle specially, do shortcut processing to speed things
1194 if (!test_bit(c, ldata->process_char_map) || ldata->lnext) {
1196 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1197 if (ldata->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1198 /* beep if no space */
1200 process_output('\a', tty);
1204 finish_erasing(ldata);
1205 /* Record the column of first canon char. */
1206 if (ldata->canon_head == ldata->read_head)
1207 echo_set_canon_col(ldata);
1209 process_echoes(tty);
1212 put_tty_queue(c, ldata);
1213 put_tty_queue(c, ldata);
1218 if (c == START_CHAR(tty)) {
1220 process_echoes(tty);
1223 if (c == STOP_CHAR(tty)) {
1232 if (c == INTR_CHAR(tty))
1235 if (c == QUIT_CHAR(tty))
1238 if (c == SUSP_CHAR(tty)) {
1241 * Note that we do not use isig() here because we want
1243 * 1) flush, 2) echo, 3) signal
1245 if (!L_NOFLSH(tty)) {
1246 n_tty_flush_buffer(tty);
1247 tty_driver_flush_buffer(tty);
1253 process_echoes(tty);
1256 kill_pgrp(tty->pgrp, signal, 1);
1266 } else if (c == '\n' && I_INLCR(tty))
1269 if (ldata->icanon) {
1270 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1271 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1273 process_echoes(tty);
1276 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1279 finish_erasing(ldata);
1280 if (L_ECHOCTL(tty)) {
1281 echo_char_raw('^', ldata);
1282 echo_char_raw('\b', ldata);
1283 process_echoes(tty);
1288 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
1290 unsigned long tail = ldata->canon_head;
1292 finish_erasing(ldata);
1294 echo_char_raw('\n', ldata);
1295 while (tail != ldata->read_head) {
1296 echo_char(ldata->read_buf[tail], tty);
1297 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
1299 process_echoes(tty);
1303 if (ldata->read_cnt >= N_TTY_BUF_SIZE) {
1305 process_output('\a', tty);
1308 if (L_ECHO(tty) || L_ECHONL(tty)) {
1309 echo_char_raw('\n', ldata);
1310 process_echoes(tty);
1312 goto handle_newline;
1314 if (c == EOF_CHAR(tty)) {
1315 if (ldata->read_cnt >= N_TTY_BUF_SIZE)
1317 if (ldata->canon_head != ldata->read_head)
1318 set_bit(TTY_PUSH, &tty->flags);
1319 c = __DISABLED_CHAR;
1320 goto handle_newline;
1322 if ((c == EOL_CHAR(tty)) ||
1323 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1324 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
1326 if (ldata->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) {
1328 process_output('\a', tty);
1332 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1335 /* Record the column of first canon char. */
1336 if (ldata->canon_head == ldata->read_head)
1337 echo_set_canon_col(ldata);
1339 process_echoes(tty);
1342 * XXX does PARMRK doubling happen for
1343 * EOL_CHAR and EOL2_CHAR?
1346 put_tty_queue(c, ldata);
1349 spin_lock_irqsave(&ldata->read_lock, flags);
1350 set_bit(ldata->read_head, ldata->read_flags);
1351 put_tty_queue_nolock(c, ldata);
1352 ldata->canon_head = ldata->read_head;
1353 ldata->canon_data++;
1354 spin_unlock_irqrestore(&ldata->read_lock, flags);
1355 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1356 if (waitqueue_active(&tty->read_wait))
1357 wake_up_interruptible(&tty->read_wait);
1362 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1363 if (ldata->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1364 /* beep if no space */
1366 process_output('\a', tty);
1370 finish_erasing(ldata);
1372 echo_char_raw('\n', ldata);
1374 /* Record the column of first canon char. */
1375 if (ldata->canon_head == ldata->read_head)
1376 echo_set_canon_col(ldata);
1379 process_echoes(tty);
1383 put_tty_queue(c, ldata);
1385 put_tty_queue(c, ldata);
1390 * n_tty_write_wakeup - asynchronous I/O notifier
1393 * Required for the ptys, serial driver etc. since processes
1394 * that attach themselves to the master and rely on ASYNC
1395 * IO must be woken up
1398 static void n_tty_write_wakeup(struct tty_struct *tty)
1400 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
1401 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
1405 * n_tty_receive_buf - data receive
1406 * @tty: terminal device
1409 * @count: characters
1411 * Called by the terminal driver when a block of characters has
1412 * been received. This function must be called from soft contexts
1413 * not from interrupt context. The driver is responsible for making
1414 * calls one at a time and in order (or using flush_to_ldisc)
1417 static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1418 char *fp, int count)
1420 struct n_tty_data *ldata = tty->disc_data;
1421 const unsigned char *p;
1422 char *f, flags = TTY_NORMAL;
1425 unsigned long cpuflags;
1427 if (ldata->real_raw) {
1428 spin_lock_irqsave(&ldata->read_lock, cpuflags);
1429 i = min(N_TTY_BUF_SIZE - ldata->read_cnt,
1430 N_TTY_BUF_SIZE - ldata->read_head);
1432 memcpy(ldata->read_buf + ldata->read_head, cp, i);
1433 ldata->read_head = (ldata->read_head + i) & (N_TTY_BUF_SIZE-1);
1434 ldata->read_cnt += i;
1438 i = min(N_TTY_BUF_SIZE - ldata->read_cnt,
1439 N_TTY_BUF_SIZE - ldata->read_head);
1441 memcpy(ldata->read_buf + ldata->read_head, cp, i);
1442 ldata->read_head = (ldata->read_head + i) & (N_TTY_BUF_SIZE-1);
1443 ldata->read_cnt += i;
1444 spin_unlock_irqrestore(&ldata->read_lock, cpuflags);
1446 for (i = count, p = cp, f = fp; i; i--, p++) {
1451 n_tty_receive_char(tty, *p);
1454 n_tty_receive_break(tty);
1458 n_tty_receive_parity_error(tty, *p);
1461 n_tty_receive_overrun(tty);
1464 printk(KERN_ERR "%s: unknown flag %d\n",
1465 tty_name(tty, buf), flags);
1469 if (tty->ops->flush_chars)
1470 tty->ops->flush_chars(tty);
1473 n_tty_set_room(tty);
1475 if ((!ldata->icanon && (ldata->read_cnt >= tty->minimum_to_wake)) ||
1477 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1478 if (waitqueue_active(&tty->read_wait))
1479 wake_up_interruptible(&tty->read_wait);
1483 * Check the remaining room for the input canonicalization
1484 * mode. We don't want to throttle the driver if we're in
1485 * canonical mode and don't have a newline yet!
1487 if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
1490 /* FIXME: there is a tiny race here if the receive room check runs
1491 before the other work executes and empties the buffer (upping
1492 the receiving room and unthrottling. We then throttle and get
1493 stuck. This has been observed and traced down by Vincent Pillet/
1494 We need to address this when we sort out out the rx path locking */
1497 int is_ignored(int sig)
1499 return (sigismember(¤t->blocked, sig) ||
1500 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
1504 * n_tty_set_termios - termios data changed
1506 * @old: previous data
1508 * Called by the tty layer when the user changes termios flags so
1509 * that the line discipline can plan ahead. This function cannot sleep
1510 * and is protected from re-entry by the tty layer. The user is
1511 * guaranteed that this function will not be re-entered or in progress
1512 * when the ldisc is closed.
1514 * Locking: Caller holds tty->termios_mutex
1517 static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1519 struct n_tty_data *ldata = tty->disc_data;
1520 int canon_change = 1;
1523 canon_change = (old->c_lflag ^ tty->termios.c_lflag) & ICANON;
1525 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
1526 ldata->canon_head = ldata->read_tail;
1527 ldata->canon_data = 0;
1531 if (canon_change && !L_ICANON(tty) && ldata->read_cnt)
1532 wake_up_interruptible(&tty->read_wait);
1534 ldata->icanon = (L_ICANON(tty) != 0);
1535 if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
1537 ldata->real_raw = 1;
1538 n_tty_set_room(tty);
1541 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1542 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1543 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1545 bitmap_zero(ldata->process_char_map, 256);
1547 if (I_IGNCR(tty) || I_ICRNL(tty))
1548 set_bit('\r', ldata->process_char_map);
1550 set_bit('\n', ldata->process_char_map);
1552 if (L_ICANON(tty)) {
1553 set_bit(ERASE_CHAR(tty), ldata->process_char_map);
1554 set_bit(KILL_CHAR(tty), ldata->process_char_map);
1555 set_bit(EOF_CHAR(tty), ldata->process_char_map);
1556 set_bit('\n', ldata->process_char_map);
1557 set_bit(EOL_CHAR(tty), ldata->process_char_map);
1558 if (L_IEXTEN(tty)) {
1559 set_bit(WERASE_CHAR(tty),
1560 ldata->process_char_map);
1561 set_bit(LNEXT_CHAR(tty),
1562 ldata->process_char_map);
1563 set_bit(EOL2_CHAR(tty),
1564 ldata->process_char_map);
1566 set_bit(REPRINT_CHAR(tty),
1567 ldata->process_char_map);
1571 set_bit(START_CHAR(tty), ldata->process_char_map);
1572 set_bit(STOP_CHAR(tty), ldata->process_char_map);
1575 set_bit(INTR_CHAR(tty), ldata->process_char_map);
1576 set_bit(QUIT_CHAR(tty), ldata->process_char_map);
1577 set_bit(SUSP_CHAR(tty), ldata->process_char_map);
1579 clear_bit(__DISABLED_CHAR, ldata->process_char_map);
1581 ldata->real_raw = 0;
1584 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1585 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1586 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1587 ldata->real_raw = 1;
1589 ldata->real_raw = 0;
1591 n_tty_set_room(tty);
1592 /* The termios change make the tty ready for I/O */
1593 wake_up_interruptible(&tty->write_wait);
1594 wake_up_interruptible(&tty->read_wait);
1598 * n_tty_close - close the ldisc for this tty
1601 * Called from the terminal layer when this line discipline is
1602 * being shut down, either because of a close or becsuse of a
1603 * discipline change. The function will not be called while other
1604 * ldisc methods are in progress.
1607 static void n_tty_close(struct tty_struct *tty)
1609 struct n_tty_data *ldata = tty->disc_data;
1611 n_tty_flush_buffer(tty);
1612 kfree(ldata->read_buf);
1613 kfree(ldata->echo_buf);
1615 tty->disc_data = NULL;
1619 * n_tty_open - open an ldisc
1620 * @tty: terminal to open
1622 * Called when this line discipline is being attached to the
1623 * terminal device. Can sleep. Called serialized so that no
1624 * other events will occur in parallel. No further open will occur
1628 static int n_tty_open(struct tty_struct *tty)
1630 struct n_tty_data *ldata;
1632 ldata = kzalloc(sizeof(*ldata), GFP_KERNEL);
1636 ldata->overrun_time = jiffies;
1637 mutex_init(&ldata->atomic_read_lock);
1638 mutex_init(&ldata->output_lock);
1639 mutex_init(&ldata->echo_lock);
1640 spin_lock_init(&ldata->read_lock);
1642 /* These are ugly. Currently a malloc failure here can panic */
1643 ldata->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1644 ldata->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1645 if (!ldata->read_buf || !ldata->echo_buf)
1648 tty->disc_data = ldata;
1649 reset_buffer_flags(tty);
1650 tty_unthrottle(tty);
1652 n_tty_set_termios(tty, NULL);
1653 tty->minimum_to_wake = 1;
1658 kfree(ldata->read_buf);
1659 kfree(ldata->echo_buf);
1665 static inline int input_available_p(struct tty_struct *tty, int amt)
1667 struct n_tty_data *ldata = tty->disc_data;
1669 tty_flush_to_ldisc(tty);
1670 if (ldata->icanon && !L_EXTPROC(tty)) {
1671 if (ldata->canon_data)
1673 } else if (ldata->read_cnt >= (amt ? amt : 1))
1680 * copy_from_read_buf - copy read data directly
1681 * @tty: terminal device
1685 * Helper function to speed up n_tty_read. It is only called when
1686 * ICANON is off; it copies characters straight from the tty queue to
1687 * user space directly. It can be profitably called twice; once to
1688 * drain the space from the tail pointer to the (physical) end of the
1689 * buffer, and once to drain the space from the (physical) beginning of
1690 * the buffer to head pointer.
1692 * Called under the ldata->atomic_read_lock sem
1696 static int copy_from_read_buf(struct tty_struct *tty,
1697 unsigned char __user **b,
1701 struct n_tty_data *ldata = tty->disc_data;
1704 unsigned long flags;
1708 spin_lock_irqsave(&ldata->read_lock, flags);
1709 n = min(ldata->read_cnt, N_TTY_BUF_SIZE - ldata->read_tail);
1711 spin_unlock_irqrestore(&ldata->read_lock, flags);
1713 retval = copy_to_user(*b, &ldata->read_buf[ldata->read_tail], n);
1716 ldata->read_buf[ldata->read_tail] == EOF_CHAR(tty);
1717 tty_audit_add_data(tty, &ldata->read_buf[ldata->read_tail], n,
1719 spin_lock_irqsave(&ldata->read_lock, flags);
1720 ldata->read_tail = (ldata->read_tail + n) & (N_TTY_BUF_SIZE-1);
1721 ldata->read_cnt -= n;
1722 /* Turn single EOF into zero-length read */
1723 if (L_EXTPROC(tty) && ldata->icanon && is_eof && !ldata->read_cnt)
1725 spin_unlock_irqrestore(&ldata->read_lock, flags);
1732 extern ssize_t redirected_tty_write(struct file *, const char __user *,
1736 * job_control - check job control
1738 * @file: file handle
1740 * Perform job control management checks on this file/tty descriptor
1741 * and if appropriate send any needed signals and return a negative
1742 * error code if action should be taken.
1745 * Locking: None - redirected write test is safe, testing
1746 * current->signal should possibly lock current->sighand
1750 static int job_control(struct tty_struct *tty, struct file *file)
1752 /* Job control check -- must be done at start and after
1753 every sleep (POSIX.1 7.1.1.4). */
1754 /* NOTE: not yet done after every sleep pending a thorough
1755 check of the logic of this change. -- jlc */
1756 /* don't stop on /dev/console */
1757 if (file->f_op->write != redirected_tty_write &&
1758 current->signal->tty == tty) {
1760 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
1761 else if (task_pgrp(current) != tty->pgrp) {
1762 if (is_ignored(SIGTTIN) ||
1763 is_current_pgrp_orphaned())
1765 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
1766 set_thread_flag(TIF_SIGPENDING);
1767 return -ERESTARTSYS;
1775 * n_tty_read - read function for tty
1777 * @file: file object
1778 * @buf: userspace buffer pointer
1781 * Perform reads for the line discipline. We are guaranteed that the
1782 * line discipline will not be closed under us but we may get multiple
1783 * parallel readers and must handle this ourselves. We may also get
1784 * a hangup. Always called in user context, may sleep.
1786 * This code must be sure never to sleep through a hangup.
1789 static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
1790 unsigned char __user *buf, size_t nr)
1792 struct n_tty_data *ldata = tty->disc_data;
1793 unsigned char __user *b = buf;
1794 DECLARE_WAITQUEUE(wait, current);
1800 unsigned long flags;
1804 c = job_control(tty, file);
1809 timeout = MAX_SCHEDULE_TIMEOUT;
1810 if (!ldata->icanon) {
1811 time = (HZ / 10) * TIME_CHAR(tty);
1812 minimum = MIN_CHAR(tty);
1815 tty->minimum_to_wake = 1;
1816 else if (!waitqueue_active(&tty->read_wait) ||
1817 (tty->minimum_to_wake > minimum))
1818 tty->minimum_to_wake = minimum;
1825 tty->minimum_to_wake = minimum = 1;
1830 * Internal serialization of reads.
1832 if (file->f_flags & O_NONBLOCK) {
1833 if (!mutex_trylock(&ldata->atomic_read_lock))
1836 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
1837 return -ERESTARTSYS;
1839 packet = tty->packet;
1841 add_wait_queue(&tty->read_wait, &wait);
1843 /* First test for status change. */
1844 if (packet && tty->link->ctrl_status) {
1848 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
1849 cs = tty->link->ctrl_status;
1850 tty->link->ctrl_status = 0;
1851 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
1852 if (tty_put_user(tty, cs, b++)) {
1860 /* This statement must be first before checking for input
1861 so that any interrupt will set the state back to
1863 set_current_state(TASK_INTERRUPTIBLE);
1865 if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
1866 ((minimum - (b - buf)) >= 1))
1867 tty->minimum_to_wake = (minimum - (b - buf));
1869 if (!input_available_p(tty, 0)) {
1870 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
1874 if (tty_hung_up_p(file))
1878 if (file->f_flags & O_NONBLOCK) {
1882 if (signal_pending(current)) {
1883 retval = -ERESTARTSYS;
1886 /* FIXME: does n_tty_set_room need locking ? */
1887 n_tty_set_room(tty);
1888 timeout = schedule_timeout(timeout);
1891 __set_current_state(TASK_RUNNING);
1893 /* Deal with packet mode. */
1894 if (packet && b == buf) {
1895 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
1903 if (ldata->icanon && !L_EXTPROC(tty)) {
1904 /* N.B. avoid overrun if nr == 0 */
1905 spin_lock_irqsave(&ldata->read_lock, flags);
1906 while (nr && ldata->read_cnt) {
1909 eol = test_and_clear_bit(ldata->read_tail,
1911 c = ldata->read_buf[ldata->read_tail];
1912 ldata->read_tail = ((ldata->read_tail+1) &
1913 (N_TTY_BUF_SIZE-1));
1916 /* this test should be redundant:
1917 * we shouldn't be reading data if
1920 if (--ldata->canon_data < 0)
1921 ldata->canon_data = 0;
1923 spin_unlock_irqrestore(&ldata->read_lock, flags);
1925 if (!eol || (c != __DISABLED_CHAR)) {
1926 if (tty_put_user(tty, c, b++)) {
1929 spin_lock_irqsave(&ldata->read_lock, flags);
1935 tty_audit_push(tty);
1936 spin_lock_irqsave(&ldata->read_lock, flags);
1939 spin_lock_irqsave(&ldata->read_lock, flags);
1941 spin_unlock_irqrestore(&ldata->read_lock, flags);
1946 /* The copy function takes the read lock and handles
1947 locking internally for this case */
1948 uncopied = copy_from_read_buf(tty, &b, &nr);
1949 uncopied += copy_from_read_buf(tty, &b, &nr);
1956 /* If there is enough space in the read buffer now, let the
1957 * low-level driver know. We use n_tty_chars_in_buffer() to
1958 * check the buffer, as it now knows about canonical mode.
1959 * Otherwise, if the driver is throttled and the line is
1960 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
1961 * we won't get any more characters.
1963 if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
1964 n_tty_set_room(tty);
1965 check_unthrottle(tty);
1968 if (b - buf >= minimum)
1973 mutex_unlock(&ldata->atomic_read_lock);
1974 remove_wait_queue(&tty->read_wait, &wait);
1976 if (!waitqueue_active(&tty->read_wait))
1977 tty->minimum_to_wake = minimum;
1979 __set_current_state(TASK_RUNNING);
1984 clear_bit(TTY_PUSH, &tty->flags);
1985 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
1988 n_tty_set_room(tty);
1993 * n_tty_write - write function for tty
1995 * @file: file object
1996 * @buf: userspace buffer pointer
1999 * Write function of the terminal device. This is serialized with
2000 * respect to other write callers but not to termios changes, reads
2001 * and other such events. Since the receive code will echo characters,
2002 * thus calling driver write methods, the output_lock is used in
2003 * the output processing functions called here as well as in the
2004 * echo processing function to protect the column state and space
2005 * left in the buffer.
2007 * This code must be sure never to sleep through a hangup.
2009 * Locking: output_lock to protect column state and space left
2010 * (note that the process_output*() functions take this
2014 static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
2015 const unsigned char *buf, size_t nr)
2017 const unsigned char *b = buf;
2018 DECLARE_WAITQUEUE(wait, current);
2022 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2023 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2024 retval = tty_check_change(tty);
2029 /* Write out any echoed characters that are still pending */
2030 process_echoes(tty);
2032 add_wait_queue(&tty->write_wait, &wait);
2034 set_current_state(TASK_INTERRUPTIBLE);
2035 if (signal_pending(current)) {
2036 retval = -ERESTARTSYS;
2039 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2043 if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
2045 ssize_t num = process_output_block(tty, b, nr);
2057 if (process_output(c, tty) < 0)
2061 if (tty->ops->flush_chars)
2062 tty->ops->flush_chars(tty);
2065 c = tty->ops->write(tty, b, nr);
2078 if (file->f_flags & O_NONBLOCK) {
2085 __set_current_state(TASK_RUNNING);
2086 remove_wait_queue(&tty->write_wait, &wait);
2087 if (b - buf != nr && tty->fasync)
2088 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2089 return (b - buf) ? b - buf : retval;
2093 * n_tty_poll - poll method for N_TTY
2094 * @tty: terminal device
2095 * @file: file accessing it
2098 * Called when the line discipline is asked to poll() for data or
2099 * for special events. This code is not serialized with respect to
2100 * other events save open/close.
2102 * This code must be sure never to sleep through a hangup.
2103 * Called without the kernel lock held - fine
2106 static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
2109 unsigned int mask = 0;
2111 poll_wait(file, &tty->read_wait, wait);
2112 poll_wait(file, &tty->write_wait, wait);
2113 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
2114 mask |= POLLIN | POLLRDNORM;
2115 if (tty->packet && tty->link->ctrl_status)
2116 mask |= POLLPRI | POLLIN | POLLRDNORM;
2117 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2119 if (tty_hung_up_p(file))
2121 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2122 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
2123 tty->minimum_to_wake = MIN_CHAR(tty);
2125 tty->minimum_to_wake = 1;
2127 if (tty->ops->write && !tty_is_writelocked(tty) &&
2128 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2129 tty_write_room(tty) > 0)
2130 mask |= POLLOUT | POLLWRNORM;
2134 static unsigned long inq_canon(struct n_tty_data *ldata)
2138 if (!ldata->canon_data)
2140 head = ldata->canon_head;
2141 tail = ldata->read_tail;
2142 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
2143 /* Skip EOF-chars.. */
2144 while (head != tail) {
2145 if (test_bit(tail, ldata->read_flags) &&
2146 ldata->read_buf[tail] == __DISABLED_CHAR)
2148 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
2153 static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2154 unsigned int cmd, unsigned long arg)
2156 struct n_tty_data *ldata = tty->disc_data;
2161 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2163 /* FIXME: Locking */
2164 retval = ldata->read_cnt;
2166 retval = inq_canon(ldata);
2167 return put_user(retval, (unsigned int __user *) arg);
2169 return n_tty_ioctl_helper(tty, file, cmd, arg);
2173 struct tty_ldisc_ops tty_ldisc_N_TTY = {
2174 .magic = TTY_LDISC_MAGIC,
2177 .close = n_tty_close,
2178 .flush_buffer = n_tty_flush_buffer,
2179 .chars_in_buffer = n_tty_chars_in_buffer,
2181 .write = n_tty_write,
2182 .ioctl = n_tty_ioctl,
2183 .set_termios = n_tty_set_termios,
2185 .receive_buf = n_tty_receive_buf,
2186 .write_wakeup = n_tty_write_wakeup
2190 * n_tty_inherit_ops - inherit N_TTY methods
2191 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2193 * Used by a generic struct tty_ldisc_ops to easily inherit N_TTY
2197 void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2199 *ops = tty_ldisc_N_TTY;
2201 ops->refcount = ops->flags = 0;
2203 EXPORT_SYMBOL_GPL(n_tty_inherit_ops);