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);
88 static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
89 unsigned char __user *ptr)
91 struct n_tty_data *ldata = tty->disc_data;
93 tty_audit_add_data(tty, &x, 1, ldata->icanon);
94 return put_user(x, ptr);
98 * n_tty_set__room - receive space
101 * Called by the driver to find out how much data it is
102 * permitted to feed to the line discipline without any being lost
103 * and thus to manage flow control. Not serialized. Answers for the
107 static void n_tty_set_room(struct tty_struct *tty)
109 struct n_tty_data *ldata = tty->disc_data;
113 /* tty->read_cnt is not read locked ? */
115 /* Multiply read_cnt by 3, since each byte might take up to
116 * three times as many spaces when PARMRK is set (depending on
117 * its flags, e.g. parity error). */
118 left = N_TTY_BUF_SIZE - tty->read_cnt * 3 - 1;
120 left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
123 * If we are doing input canonicalization, and there are no
124 * pending newlines, let characters through without limit, so
125 * that erase characters will be handled. Other excess
126 * characters will be beeped.
129 left = ldata->icanon && !tty->canon_data;
130 old_left = tty->receive_room;
131 tty->receive_room = left;
133 /* Did this open up the receive buffer? We may need to flip */
134 if (left && !old_left)
135 schedule_work(&tty->buf.work);
138 static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
140 if (tty->read_cnt < N_TTY_BUF_SIZE) {
141 tty->read_buf[tty->read_head] = c;
142 tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
148 * put_tty_queue - add character to tty
152 * Add a character to the tty read_buf queue. This is done under the
153 * read_lock to serialize character addition and also to protect us
154 * against parallel reads or flushes
157 static void put_tty_queue(unsigned char c, struct tty_struct *tty)
161 * The problem of stomping on the buffers ends here.
162 * Why didn't anyone see this one coming? --AJK
164 spin_lock_irqsave(&tty->read_lock, flags);
165 put_tty_queue_nolock(c, tty);
166 spin_unlock_irqrestore(&tty->read_lock, flags);
170 * check_unthrottle - allow new receive data
173 * Check whether to call the driver unthrottle functions
175 * Can sleep, may be called under the atomic_read_lock mutex but
176 * this is not guaranteed.
178 static void check_unthrottle(struct tty_struct *tty)
185 * reset_buffer_flags - reset buffer state
186 * @tty: terminal to reset
188 * Reset the read buffer counters, clear the flags,
189 * and make sure the driver is unthrottled. Called
190 * from n_tty_open() and n_tty_flush_buffer().
192 * Locking: tty_read_lock for read fields.
195 static void reset_buffer_flags(struct tty_struct *tty)
197 struct n_tty_data *ldata = tty->disc_data;
200 spin_lock_irqsave(&tty->read_lock, flags);
201 tty->read_head = tty->read_tail = tty->read_cnt = 0;
202 spin_unlock_irqrestore(&tty->read_lock, flags);
204 mutex_lock(&tty->echo_lock);
205 tty->echo_pos = tty->echo_cnt = ldata->echo_overrun = 0;
206 mutex_unlock(&tty->echo_lock);
208 tty->canon_head = tty->canon_data = ldata->erasing = 0;
209 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
214 * n_tty_flush_buffer - clean input queue
215 * @tty: terminal device
217 * Flush the input buffer. Called when the line discipline is
218 * being closed, when the tty layer wants the buffer flushed (eg
219 * at hangup) or when the N_TTY line discipline internally has to
220 * clean the pending queue (for example some signals).
222 * Locking: ctrl_lock, read_lock.
225 static void n_tty_flush_buffer(struct tty_struct *tty)
228 /* clear everything and unthrottle the driver */
229 reset_buffer_flags(tty);
234 spin_lock_irqsave(&tty->ctrl_lock, flags);
235 if (tty->link->packet) {
236 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
237 wake_up_interruptible(&tty->link->read_wait);
239 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
243 * n_tty_chars_in_buffer - report available bytes
246 * Report the number of characters buffered to be delivered to user
247 * at this instant in time.
252 static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
254 struct n_tty_data *ldata = tty->disc_data;
258 spin_lock_irqsave(&tty->read_lock, flags);
259 if (!ldata->icanon) {
261 } else if (tty->canon_data) {
262 n = (tty->canon_head > tty->read_tail) ?
263 tty->canon_head - tty->read_tail :
264 tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail);
266 spin_unlock_irqrestore(&tty->read_lock, flags);
271 * is_utf8_continuation - utf8 multibyte check
274 * Returns true if the utf8 character 'c' is a multibyte continuation
275 * character. We use this to correctly compute the on screen size
276 * of the character when printing
279 static inline int is_utf8_continuation(unsigned char c)
281 return (c & 0xc0) == 0x80;
285 * is_continuation - multibyte check
288 * Returns true if the utf8 character 'c' is a multibyte continuation
289 * character and the terminal is in unicode mode.
292 static inline int is_continuation(unsigned char c, struct tty_struct *tty)
294 return I_IUTF8(tty) && is_utf8_continuation(c);
298 * do_output_char - output one character
299 * @c: character (or partial unicode symbol)
300 * @tty: terminal device
301 * @space: space available in tty driver write buffer
303 * This is a helper function that handles one output character
304 * (including special characters like TAB, CR, LF, etc.),
305 * doing OPOST processing and putting the results in the
306 * tty driver's write buffer.
308 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
309 * and NLDLY. They simply aren't relevant in the world today.
310 * If you ever need them, add them here.
312 * Returns the number of bytes of buffer space used or -1 if
315 * Locking: should be called under the output_lock to protect
316 * the column state and space left in the buffer
319 static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
321 struct n_tty_data *ldata = tty->disc_data;
334 tty->canon_column = ldata->column = 0;
335 tty->ops->write(tty, "\r\n", 2);
338 tty->canon_column = ldata->column;
341 if (O_ONOCR(tty) && ldata->column == 0)
346 tty->canon_column = ldata->column = 0;
349 tty->canon_column = ldata->column = 0;
352 spaces = 8 - (ldata->column & 7);
353 if (O_TABDLY(tty) == XTABS) {
356 ldata->column += spaces;
357 tty->ops->write(tty, " ", spaces);
360 ldata->column += spaces;
363 if (ldata->column > 0)
370 if (!is_continuation(c, tty))
376 tty_put_char(tty, c);
381 * process_output - output post processor
382 * @c: character (or partial unicode symbol)
383 * @tty: terminal device
385 * Output one character with OPOST processing.
386 * Returns -1 when the output device is full and the character
389 * Locking: output_lock to protect column state and space left
390 * (also, this is called from n_tty_write under the
391 * tty layer write lock)
394 static int process_output(unsigned char c, struct tty_struct *tty)
398 mutex_lock(&tty->output_lock);
400 space = tty_write_room(tty);
401 retval = do_output_char(c, tty, space);
403 mutex_unlock(&tty->output_lock);
411 * process_output_block - block post processor
412 * @tty: terminal device
413 * @buf: character buffer
414 * @nr: number of bytes to output
416 * Output a block of characters with OPOST processing.
417 * Returns the number of characters output.
419 * This path is used to speed up block console writes, among other
420 * things when processing blocks of output data. It handles only
421 * the simple cases normally found and helps to generate blocks of
422 * symbols for the console driver and thus improve performance.
424 * Locking: output_lock to protect column state and space left
425 * (also, this is called from n_tty_write under the
426 * tty layer write lock)
429 static ssize_t process_output_block(struct tty_struct *tty,
430 const unsigned char *buf, unsigned int nr)
432 struct n_tty_data *ldata = tty->disc_data;
435 const unsigned char *cp;
437 mutex_lock(&tty->output_lock);
439 space = tty_write_room(tty);
441 mutex_unlock(&tty->output_lock);
447 for (i = 0, cp = buf; i < nr; i++, cp++) {
448 unsigned char c = *cp;
456 tty->canon_column = ldata->column;
459 if (O_ONOCR(tty) && ldata->column == 0)
463 tty->canon_column = ldata->column = 0;
468 if (ldata->column > 0)
475 if (!is_continuation(c, tty))
482 i = tty->ops->write(tty, buf, i);
484 mutex_unlock(&tty->output_lock);
489 * process_echoes - write pending echo characters
490 * @tty: terminal device
492 * Write previously buffered echo (and other ldisc-generated)
493 * characters to the tty.
495 * Characters generated by the ldisc (including echoes) need to
496 * be buffered because the driver's write buffer can fill during
497 * heavy program output. Echoing straight to the driver will
498 * often fail under these conditions, causing lost characters and
499 * resulting mismatches of ldisc state information.
501 * Since the ldisc state must represent the characters actually sent
502 * to the driver at the time of the write, operations like certain
503 * changes in column state are also saved in the buffer and executed
506 * A circular fifo buffer is used so that the most recent characters
507 * are prioritized. Also, when control characters are echoed with a
508 * prefixed "^", the pair is treated atomically and thus not separated.
510 * Locking: output_lock to protect column state and space left,
511 * echo_lock to protect the echo buffer
514 static void process_echoes(struct tty_struct *tty)
516 struct n_tty_data *ldata = tty->disc_data;
519 unsigned char *cp, *buf_end;
524 mutex_lock(&tty->output_lock);
525 mutex_lock(&tty->echo_lock);
527 space = tty_write_room(tty);
529 buf_end = tty->echo_buf + N_TTY_BUF_SIZE;
530 cp = tty->echo_buf + tty->echo_pos;
534 if (c == ECHO_OP_START) {
537 int no_space_left = 0;
540 * If the buffer byte is the start of a multi-byte
541 * operation, get the next byte, which is either the
542 * op code or a control character value.
546 opp -= N_TTY_BUF_SIZE;
550 unsigned int num_chars, num_bs;
552 case ECHO_OP_ERASE_TAB:
553 if (++opp == buf_end)
554 opp -= N_TTY_BUF_SIZE;
558 * Determine how many columns to go back
559 * in order to erase the tab.
560 * This depends on the number of columns
561 * used by other characters within the tab
562 * area. If this (modulo 8) count is from
563 * the start of input rather than from a
564 * previous tab, we offset by canon column.
565 * Otherwise, tab spacing is normal.
567 if (!(num_chars & 0x80))
568 num_chars += tty->canon_column;
569 num_bs = 8 - (num_chars & 7);
571 if (num_bs > space) {
577 tty_put_char(tty, '\b');
578 if (ldata->column > 0)
585 case ECHO_OP_SET_CANON_COL:
586 tty->canon_column = ldata->column;
591 case ECHO_OP_MOVE_BACK_COL:
592 if (ldata->column > 0)
599 /* This is an escaped echo op start code */
604 tty_put_char(tty, ECHO_OP_START);
613 * If the op is not a special byte code,
614 * it is a ctrl char tagged to be echoed
615 * as "^X" (where X is the letter
616 * representing the control char).
617 * Note that we must ensure there is
618 * enough space for the whole ctrl pair.
625 tty_put_char(tty, '^');
626 tty_put_char(tty, op ^ 0100);
637 !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
638 int retval = do_output_char(c, tty, space);
645 tty_put_char(tty, c);
652 /* When end of circular buffer reached, wrap around */
654 cp -= N_TTY_BUF_SIZE;
660 ldata->echo_overrun = 0;
662 int num_processed = tty->echo_cnt - nr;
663 tty->echo_pos += num_processed;
664 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
666 if (num_processed > 0)
667 ldata->echo_overrun = 0;
670 mutex_unlock(&tty->echo_lock);
671 mutex_unlock(&tty->output_lock);
673 if (tty->ops->flush_chars)
674 tty->ops->flush_chars(tty);
678 * add_echo_byte - add a byte to the echo buffer
679 * @c: unicode byte to echo
680 * @tty: terminal device
682 * Add a character or operation byte to the echo buffer.
684 * Should be called under the echo lock to protect the echo buffer.
687 static void add_echo_byte(unsigned char c, struct tty_struct *tty)
689 struct n_tty_data *ldata = tty->disc_data;
692 if (tty->echo_cnt == N_TTY_BUF_SIZE) {
693 /* Circular buffer is already at capacity */
694 new_byte_pos = tty->echo_pos;
697 * Since the buffer start position needs to be advanced,
698 * be sure to step by a whole operation byte group.
700 if (tty->echo_buf[tty->echo_pos] == ECHO_OP_START) {
701 if (tty->echo_buf[(tty->echo_pos + 1) &
702 (N_TTY_BUF_SIZE - 1)] ==
713 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
715 ldata->echo_overrun = 1;
717 new_byte_pos = tty->echo_pos + tty->echo_cnt;
718 new_byte_pos &= N_TTY_BUF_SIZE - 1;
722 tty->echo_buf[new_byte_pos] = c;
726 * echo_move_back_col - add operation to move back a column
727 * @tty: terminal device
729 * Add an operation to the echo buffer to move back one column.
731 * Locking: echo_lock to protect the echo buffer
734 static void echo_move_back_col(struct tty_struct *tty)
736 mutex_lock(&tty->echo_lock);
738 add_echo_byte(ECHO_OP_START, tty);
739 add_echo_byte(ECHO_OP_MOVE_BACK_COL, tty);
741 mutex_unlock(&tty->echo_lock);
745 * echo_set_canon_col - add operation to set the canon column
746 * @tty: terminal device
748 * Add an operation to the echo buffer to set the canon column
749 * to the current column.
751 * Locking: echo_lock to protect the echo buffer
754 static void echo_set_canon_col(struct tty_struct *tty)
756 mutex_lock(&tty->echo_lock);
758 add_echo_byte(ECHO_OP_START, tty);
759 add_echo_byte(ECHO_OP_SET_CANON_COL, tty);
761 mutex_unlock(&tty->echo_lock);
765 * echo_erase_tab - add operation to erase a tab
766 * @num_chars: number of character columns already used
767 * @after_tab: true if num_chars starts after a previous tab
768 * @tty: terminal device
770 * Add an operation to the echo buffer to erase a tab.
772 * Called by the eraser function, which knows how many character
773 * columns have been used since either a previous tab or the start
774 * of input. This information will be used later, along with
775 * canon column (if applicable), to go back the correct number
778 * Locking: echo_lock to protect the echo buffer
781 static void echo_erase_tab(unsigned int num_chars, int after_tab,
782 struct tty_struct *tty)
784 mutex_lock(&tty->echo_lock);
786 add_echo_byte(ECHO_OP_START, tty);
787 add_echo_byte(ECHO_OP_ERASE_TAB, tty);
789 /* We only need to know this modulo 8 (tab spacing) */
792 /* Set the high bit as a flag if num_chars is after a previous tab */
796 add_echo_byte(num_chars, tty);
798 mutex_unlock(&tty->echo_lock);
802 * echo_char_raw - echo a character raw
803 * @c: unicode byte to echo
804 * @tty: terminal device
806 * Echo user input back onto the screen. This must be called only when
807 * L_ECHO(tty) is true. Called from the driver receive_buf path.
809 * This variant does not treat control characters specially.
811 * Locking: echo_lock to protect the echo buffer
814 static void echo_char_raw(unsigned char c, struct tty_struct *tty)
816 mutex_lock(&tty->echo_lock);
818 if (c == ECHO_OP_START) {
819 add_echo_byte(ECHO_OP_START, tty);
820 add_echo_byte(ECHO_OP_START, tty);
822 add_echo_byte(c, tty);
825 mutex_unlock(&tty->echo_lock);
829 * echo_char - echo a character
830 * @c: unicode byte to echo
831 * @tty: terminal device
833 * Echo user input back onto the screen. This must be called only when
834 * L_ECHO(tty) is true. Called from the driver receive_buf path.
836 * This variant tags control characters to be echoed as "^X"
837 * (where X is the letter representing the control char).
839 * Locking: echo_lock to protect the echo buffer
842 static void echo_char(unsigned char c, struct tty_struct *tty)
844 mutex_lock(&tty->echo_lock);
846 if (c == ECHO_OP_START) {
847 add_echo_byte(ECHO_OP_START, tty);
848 add_echo_byte(ECHO_OP_START, tty);
850 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
851 add_echo_byte(ECHO_OP_START, tty);
852 add_echo_byte(c, tty);
855 mutex_unlock(&tty->echo_lock);
859 * finish_erasing - complete erase
860 * @tty: tty doing the erase
863 static inline void finish_erasing(struct tty_struct *tty)
865 struct n_tty_data *ldata = tty->disc_data;
866 if (ldata->erasing) {
867 echo_char_raw('/', tty);
873 * eraser - handle erase function
874 * @c: character input
875 * @tty: terminal device
877 * Perform erase and necessary output when an erase character is
878 * present in the stream from the driver layer. Handles the complexities
879 * of UTF-8 multibyte symbols.
881 * Locking: read_lock for tty buffers
884 static void eraser(unsigned char c, struct tty_struct *tty)
886 struct n_tty_data *ldata = tty->disc_data;
887 enum { ERASE, WERASE, KILL } kill_type;
888 int head, seen_alnums, cnt;
891 /* FIXME: locking needed ? */
892 if (tty->read_head == tty->canon_head) {
893 /* process_output('\a', tty); */ /* what do you think? */
896 if (c == ERASE_CHAR(tty))
898 else if (c == WERASE_CHAR(tty))
902 spin_lock_irqsave(&tty->read_lock, flags);
903 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
904 (N_TTY_BUF_SIZE - 1));
905 tty->read_head = tty->canon_head;
906 spin_unlock_irqrestore(&tty->read_lock, flags);
909 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
910 spin_lock_irqsave(&tty->read_lock, flags);
911 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
912 (N_TTY_BUF_SIZE - 1));
913 tty->read_head = tty->canon_head;
914 spin_unlock_irqrestore(&tty->read_lock, flags);
916 echo_char(KILL_CHAR(tty), tty);
917 /* Add a newline if ECHOK is on and ECHOKE is off. */
919 echo_char_raw('\n', tty);
926 /* FIXME: Locking ?? */
927 while (tty->read_head != tty->canon_head) {
928 head = tty->read_head;
930 /* erase a single possibly multibyte character */
932 head = (head - 1) & (N_TTY_BUF_SIZE-1);
933 c = tty->read_buf[head];
934 } while (is_continuation(c, tty) && head != tty->canon_head);
936 /* do not partially erase */
937 if (is_continuation(c, tty))
940 if (kill_type == WERASE) {
941 /* Equivalent to BSD's ALTWERASE. */
942 if (isalnum(c) || c == '_')
944 else if (seen_alnums)
947 cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1);
948 spin_lock_irqsave(&tty->read_lock, flags);
949 tty->read_head = head;
950 tty->read_cnt -= cnt;
951 spin_unlock_irqrestore(&tty->read_lock, flags);
953 if (L_ECHOPRT(tty)) {
954 if (!ldata->erasing) {
955 echo_char_raw('\\', tty);
958 /* if cnt > 1, output a multi-byte character */
961 head = (head+1) & (N_TTY_BUF_SIZE-1);
962 echo_char_raw(tty->read_buf[head], tty);
963 echo_move_back_col(tty);
965 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
966 echo_char(ERASE_CHAR(tty), tty);
967 } else if (c == '\t') {
968 unsigned int num_chars = 0;
970 unsigned long tail = tty->read_head;
973 * Count the columns used for characters
974 * since the start of input or after a
976 * This info is used to go back the correct
979 while (tail != tty->canon_head) {
980 tail = (tail-1) & (N_TTY_BUF_SIZE-1);
981 c = tty->read_buf[tail];
985 } else if (iscntrl(c)) {
988 } else if (!is_continuation(c, tty)) {
992 echo_erase_tab(num_chars, after_tab, tty);
994 if (iscntrl(c) && L_ECHOCTL(tty)) {
995 echo_char_raw('\b', tty);
996 echo_char_raw(' ', tty);
997 echo_char_raw('\b', tty);
999 if (!iscntrl(c) || L_ECHOCTL(tty)) {
1000 echo_char_raw('\b', tty);
1001 echo_char_raw(' ', tty);
1002 echo_char_raw('\b', tty);
1006 if (kill_type == ERASE)
1009 if (tty->read_head == tty->canon_head && L_ECHO(tty))
1010 finish_erasing(tty);
1014 * isig - handle the ISIG optio
1017 * @flush: force flush
1019 * Called when a signal is being sent due to terminal input. This
1020 * may caus terminal flushing to take place according to the termios
1021 * settings and character used. Called from the driver receive_buf
1022 * path so serialized.
1024 * Locking: ctrl_lock, read_lock (both via flush buffer)
1027 static inline void isig(int sig, struct tty_struct *tty, int flush)
1030 kill_pgrp(tty->pgrp, sig, 1);
1031 if (flush || !L_NOFLSH(tty)) {
1032 n_tty_flush_buffer(tty);
1033 tty_driver_flush_buffer(tty);
1038 * n_tty_receive_break - handle break
1041 * An RS232 break event has been hit in the incoming bitstream. This
1042 * can cause a variety of events depending upon the termios settings.
1044 * Called from the receive_buf path so single threaded.
1047 static inline void n_tty_receive_break(struct tty_struct *tty)
1051 if (I_BRKINT(tty)) {
1052 isig(SIGINT, tty, 1);
1055 if (I_PARMRK(tty)) {
1056 put_tty_queue('\377', tty);
1057 put_tty_queue('\0', tty);
1059 put_tty_queue('\0', tty);
1060 wake_up_interruptible(&tty->read_wait);
1064 * n_tty_receive_overrun - handle overrun reporting
1067 * Data arrived faster than we could process it. While the tty
1068 * driver has flagged this the bits that were missed are gone
1071 * Called from the receive_buf path so single threaded. Does not
1072 * need locking as num_overrun and overrun_time are function
1076 static inline void n_tty_receive_overrun(struct tty_struct *tty)
1078 struct n_tty_data *ldata = tty->disc_data;
1081 ldata->num_overrun++;
1082 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1083 time_after(ldata->overrun_time, jiffies)) {
1084 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1086 ldata->num_overrun);
1087 ldata->overrun_time = jiffies;
1088 ldata->num_overrun = 0;
1093 * n_tty_receive_parity_error - error notifier
1094 * @tty: terminal device
1097 * Process a parity error and queue the right data to indicate
1098 * the error case if necessary. Locking as per n_tty_receive_buf.
1100 static inline void n_tty_receive_parity_error(struct tty_struct *tty,
1105 if (I_PARMRK(tty)) {
1106 put_tty_queue('\377', tty);
1107 put_tty_queue('\0', tty);
1108 put_tty_queue(c, tty);
1109 } else if (I_INPCK(tty))
1110 put_tty_queue('\0', tty);
1112 put_tty_queue(c, tty);
1113 wake_up_interruptible(&tty->read_wait);
1117 * n_tty_receive_char - perform processing
1118 * @tty: terminal device
1121 * Process an individual character of input received from the driver.
1122 * This is serialized with respect to itself by the rules for the
1126 static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1128 struct n_tty_data *ldata = tty->disc_data;
1129 unsigned long flags;
1133 put_tty_queue(c, tty);
1139 if (I_IUCLC(tty) && L_IEXTEN(tty))
1142 if (L_EXTPROC(tty)) {
1143 put_tty_queue(c, tty);
1147 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
1148 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
1149 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
1151 process_echoes(tty);
1156 if (c == START_CHAR(tty)) {
1158 process_echoes(tty);
1159 } else if (c == STOP_CHAR(tty))
1166 * If the previous character was LNEXT, or we know that this
1167 * character is not one of the characters that we'll have to
1168 * handle specially, do shortcut processing to speed things
1171 if (!test_bit(c, ldata->process_char_map) || ldata->lnext) {
1173 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1174 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1175 /* beep if no space */
1177 process_output('\a', tty);
1181 finish_erasing(tty);
1182 /* Record the column of first canon char. */
1183 if (tty->canon_head == tty->read_head)
1184 echo_set_canon_col(tty);
1186 process_echoes(tty);
1189 put_tty_queue(c, tty);
1190 put_tty_queue(c, tty);
1195 if (c == START_CHAR(tty)) {
1197 process_echoes(tty);
1200 if (c == STOP_CHAR(tty)) {
1209 if (c == INTR_CHAR(tty))
1212 if (c == QUIT_CHAR(tty))
1215 if (c == SUSP_CHAR(tty)) {
1218 * Note that we do not use isig() here because we want
1220 * 1) flush, 2) echo, 3) signal
1222 if (!L_NOFLSH(tty)) {
1223 n_tty_flush_buffer(tty);
1224 tty_driver_flush_buffer(tty);
1230 process_echoes(tty);
1233 kill_pgrp(tty->pgrp, signal, 1);
1243 } else if (c == '\n' && I_INLCR(tty))
1246 if (ldata->icanon) {
1247 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1248 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1250 process_echoes(tty);
1253 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1256 finish_erasing(tty);
1257 if (L_ECHOCTL(tty)) {
1258 echo_char_raw('^', tty);
1259 echo_char_raw('\b', tty);
1260 process_echoes(tty);
1265 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
1267 unsigned long tail = tty->canon_head;
1269 finish_erasing(tty);
1271 echo_char_raw('\n', tty);
1272 while (tail != tty->read_head) {
1273 echo_char(tty->read_buf[tail], tty);
1274 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
1276 process_echoes(tty);
1280 if (tty->read_cnt >= N_TTY_BUF_SIZE) {
1282 process_output('\a', tty);
1285 if (L_ECHO(tty) || L_ECHONL(tty)) {
1286 echo_char_raw('\n', tty);
1287 process_echoes(tty);
1289 goto handle_newline;
1291 if (c == EOF_CHAR(tty)) {
1292 if (tty->read_cnt >= N_TTY_BUF_SIZE)
1294 if (tty->canon_head != tty->read_head)
1295 set_bit(TTY_PUSH, &tty->flags);
1296 c = __DISABLED_CHAR;
1297 goto handle_newline;
1299 if ((c == EOL_CHAR(tty)) ||
1300 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1301 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
1303 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) {
1305 process_output('\a', tty);
1309 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1312 /* Record the column of first canon char. */
1313 if (tty->canon_head == tty->read_head)
1314 echo_set_canon_col(tty);
1316 process_echoes(tty);
1319 * XXX does PARMRK doubling happen for
1320 * EOL_CHAR and EOL2_CHAR?
1323 put_tty_queue(c, tty);
1326 spin_lock_irqsave(&tty->read_lock, flags);
1327 set_bit(tty->read_head, ldata->read_flags);
1328 put_tty_queue_nolock(c, tty);
1329 tty->canon_head = tty->read_head;
1331 spin_unlock_irqrestore(&tty->read_lock, flags);
1332 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1333 if (waitqueue_active(&tty->read_wait))
1334 wake_up_interruptible(&tty->read_wait);
1339 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1340 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1341 /* beep if no space */
1343 process_output('\a', tty);
1347 finish_erasing(tty);
1349 echo_char_raw('\n', tty);
1351 /* Record the column of first canon char. */
1352 if (tty->canon_head == tty->read_head)
1353 echo_set_canon_col(tty);
1356 process_echoes(tty);
1360 put_tty_queue(c, tty);
1362 put_tty_queue(c, tty);
1367 * n_tty_write_wakeup - asynchronous I/O notifier
1370 * Required for the ptys, serial driver etc. since processes
1371 * that attach themselves to the master and rely on ASYNC
1372 * IO must be woken up
1375 static void n_tty_write_wakeup(struct tty_struct *tty)
1377 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
1378 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
1382 * n_tty_receive_buf - data receive
1383 * @tty: terminal device
1386 * @count: characters
1388 * Called by the terminal driver when a block of characters has
1389 * been received. This function must be called from soft contexts
1390 * not from interrupt context. The driver is responsible for making
1391 * calls one at a time and in order (or using flush_to_ldisc)
1394 static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1395 char *fp, int count)
1397 struct n_tty_data *ldata = tty->disc_data;
1398 const unsigned char *p;
1399 char *f, flags = TTY_NORMAL;
1402 unsigned long cpuflags;
1404 if (ldata->real_raw) {
1405 spin_lock_irqsave(&tty->read_lock, cpuflags);
1406 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1407 N_TTY_BUF_SIZE - tty->read_head);
1409 memcpy(tty->read_buf + tty->read_head, cp, i);
1410 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1415 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1416 N_TTY_BUF_SIZE - tty->read_head);
1418 memcpy(tty->read_buf + tty->read_head, cp, i);
1419 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1421 spin_unlock_irqrestore(&tty->read_lock, cpuflags);
1423 for (i = count, p = cp, f = fp; i; i--, p++) {
1428 n_tty_receive_char(tty, *p);
1431 n_tty_receive_break(tty);
1435 n_tty_receive_parity_error(tty, *p);
1438 n_tty_receive_overrun(tty);
1441 printk(KERN_ERR "%s: unknown flag %d\n",
1442 tty_name(tty, buf), flags);
1446 if (tty->ops->flush_chars)
1447 tty->ops->flush_chars(tty);
1450 n_tty_set_room(tty);
1452 if ((!ldata->icanon && (tty->read_cnt >= tty->minimum_to_wake)) ||
1454 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1455 if (waitqueue_active(&tty->read_wait))
1456 wake_up_interruptible(&tty->read_wait);
1460 * Check the remaining room for the input canonicalization
1461 * mode. We don't want to throttle the driver if we're in
1462 * canonical mode and don't have a newline yet!
1464 if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
1467 /* FIXME: there is a tiny race here if the receive room check runs
1468 before the other work executes and empties the buffer (upping
1469 the receiving room and unthrottling. We then throttle and get
1470 stuck. This has been observed and traced down by Vincent Pillet/
1471 We need to address this when we sort out out the rx path locking */
1474 int is_ignored(int sig)
1476 return (sigismember(¤t->blocked, sig) ||
1477 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
1481 * n_tty_set_termios - termios data changed
1483 * @old: previous data
1485 * Called by the tty layer when the user changes termios flags so
1486 * that the line discipline can plan ahead. This function cannot sleep
1487 * and is protected from re-entry by the tty layer. The user is
1488 * guaranteed that this function will not be re-entered or in progress
1489 * when the ldisc is closed.
1491 * Locking: Caller holds tty->termios_mutex
1494 static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1496 struct n_tty_data *ldata = tty->disc_data;
1497 int canon_change = 1;
1500 canon_change = (old->c_lflag ^ tty->termios.c_lflag) & ICANON;
1502 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
1503 tty->canon_head = tty->read_tail;
1504 tty->canon_data = 0;
1508 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
1509 wake_up_interruptible(&tty->read_wait);
1511 ldata->icanon = (L_ICANON(tty) != 0);
1512 if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
1514 ldata->real_raw = 1;
1515 n_tty_set_room(tty);
1518 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1519 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1520 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1522 bitmap_zero(ldata->process_char_map, 256);
1524 if (I_IGNCR(tty) || I_ICRNL(tty))
1525 set_bit('\r', ldata->process_char_map);
1527 set_bit('\n', ldata->process_char_map);
1529 if (L_ICANON(tty)) {
1530 set_bit(ERASE_CHAR(tty), ldata->process_char_map);
1531 set_bit(KILL_CHAR(tty), ldata->process_char_map);
1532 set_bit(EOF_CHAR(tty), ldata->process_char_map);
1533 set_bit('\n', ldata->process_char_map);
1534 set_bit(EOL_CHAR(tty), ldata->process_char_map);
1535 if (L_IEXTEN(tty)) {
1536 set_bit(WERASE_CHAR(tty),
1537 ldata->process_char_map);
1538 set_bit(LNEXT_CHAR(tty),
1539 ldata->process_char_map);
1540 set_bit(EOL2_CHAR(tty),
1541 ldata->process_char_map);
1543 set_bit(REPRINT_CHAR(tty),
1544 ldata->process_char_map);
1548 set_bit(START_CHAR(tty), ldata->process_char_map);
1549 set_bit(STOP_CHAR(tty), ldata->process_char_map);
1552 set_bit(INTR_CHAR(tty), ldata->process_char_map);
1553 set_bit(QUIT_CHAR(tty), ldata->process_char_map);
1554 set_bit(SUSP_CHAR(tty), ldata->process_char_map);
1556 clear_bit(__DISABLED_CHAR, ldata->process_char_map);
1558 ldata->real_raw = 0;
1561 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1562 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1563 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1564 ldata->real_raw = 1;
1566 ldata->real_raw = 0;
1568 n_tty_set_room(tty);
1569 /* The termios change make the tty ready for I/O */
1570 wake_up_interruptible(&tty->write_wait);
1571 wake_up_interruptible(&tty->read_wait);
1575 * n_tty_close - close the ldisc for this tty
1578 * Called from the terminal layer when this line discipline is
1579 * being shut down, either because of a close or becsuse of a
1580 * discipline change. The function will not be called while other
1581 * ldisc methods are in progress.
1584 static void n_tty_close(struct tty_struct *tty)
1586 struct n_tty_data *ldata = tty->disc_data;
1588 n_tty_flush_buffer(tty);
1589 kfree(tty->read_buf);
1590 kfree(tty->echo_buf);
1592 tty->read_buf = NULL;
1593 tty->echo_buf = NULL;
1594 tty->disc_data = NULL;
1598 * n_tty_open - open an ldisc
1599 * @tty: terminal to open
1601 * Called when this line discipline is being attached to the
1602 * terminal device. Can sleep. Called serialized so that no
1603 * other events will occur in parallel. No further open will occur
1607 static int n_tty_open(struct tty_struct *tty)
1609 struct n_tty_data *ldata;
1611 ldata = kzalloc(sizeof(*ldata), GFP_KERNEL);
1615 ldata->overrun_time = jiffies;
1617 /* These are ugly. Currently a malloc failure here can panic */
1618 tty->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1619 tty->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1620 if (!tty->read_buf || !tty->echo_buf)
1623 tty->disc_data = ldata;
1624 reset_buffer_flags(tty);
1625 tty_unthrottle(tty);
1627 n_tty_set_termios(tty, NULL);
1628 tty->minimum_to_wake = 1;
1633 kfree(tty->read_buf);
1634 kfree(tty->echo_buf);
1640 static inline int input_available_p(struct tty_struct *tty, int amt)
1642 struct n_tty_data *ldata = tty->disc_data;
1644 tty_flush_to_ldisc(tty);
1645 if (ldata->icanon && !L_EXTPROC(tty)) {
1646 if (tty->canon_data)
1648 } else if (tty->read_cnt >= (amt ? amt : 1))
1655 * copy_from_read_buf - copy read data directly
1656 * @tty: terminal device
1660 * Helper function to speed up n_tty_read. It is only called when
1661 * ICANON is off; it copies characters straight from the tty queue to
1662 * user space directly. It can be profitably called twice; once to
1663 * drain the space from the tail pointer to the (physical) end of the
1664 * buffer, and once to drain the space from the (physical) beginning of
1665 * the buffer to head pointer.
1667 * Called under the tty->atomic_read_lock sem
1671 static int copy_from_read_buf(struct tty_struct *tty,
1672 unsigned char __user **b,
1676 struct n_tty_data *ldata = tty->disc_data;
1679 unsigned long flags;
1683 spin_lock_irqsave(&tty->read_lock, flags);
1684 n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail);
1686 spin_unlock_irqrestore(&tty->read_lock, flags);
1688 retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);
1691 tty->read_buf[tty->read_tail] == EOF_CHAR(tty);
1692 tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n,
1694 spin_lock_irqsave(&tty->read_lock, flags);
1695 tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
1697 /* Turn single EOF into zero-length read */
1698 if (L_EXTPROC(tty) && ldata->icanon && is_eof && !tty->read_cnt)
1700 spin_unlock_irqrestore(&tty->read_lock, flags);
1707 extern ssize_t redirected_tty_write(struct file *, const char __user *,
1711 * job_control - check job control
1713 * @file: file handle
1715 * Perform job control management checks on this file/tty descriptor
1716 * and if appropriate send any needed signals and return a negative
1717 * error code if action should be taken.
1720 * Locking: None - redirected write test is safe, testing
1721 * current->signal should possibly lock current->sighand
1725 static int job_control(struct tty_struct *tty, struct file *file)
1727 /* Job control check -- must be done at start and after
1728 every sleep (POSIX.1 7.1.1.4). */
1729 /* NOTE: not yet done after every sleep pending a thorough
1730 check of the logic of this change. -- jlc */
1731 /* don't stop on /dev/console */
1732 if (file->f_op->write != redirected_tty_write &&
1733 current->signal->tty == tty) {
1735 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
1736 else if (task_pgrp(current) != tty->pgrp) {
1737 if (is_ignored(SIGTTIN) ||
1738 is_current_pgrp_orphaned())
1740 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
1741 set_thread_flag(TIF_SIGPENDING);
1742 return -ERESTARTSYS;
1750 * n_tty_read - read function for tty
1752 * @file: file object
1753 * @buf: userspace buffer pointer
1756 * Perform reads for the line discipline. We are guaranteed that the
1757 * line discipline will not be closed under us but we may get multiple
1758 * parallel readers and must handle this ourselves. We may also get
1759 * a hangup. Always called in user context, may sleep.
1761 * This code must be sure never to sleep through a hangup.
1764 static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
1765 unsigned char __user *buf, size_t nr)
1767 struct n_tty_data *ldata = tty->disc_data;
1768 unsigned char __user *b = buf;
1769 DECLARE_WAITQUEUE(wait, current);
1775 unsigned long flags;
1779 c = job_control(tty, file);
1784 timeout = MAX_SCHEDULE_TIMEOUT;
1785 if (!ldata->icanon) {
1786 time = (HZ / 10) * TIME_CHAR(tty);
1787 minimum = MIN_CHAR(tty);
1790 tty->minimum_to_wake = 1;
1791 else if (!waitqueue_active(&tty->read_wait) ||
1792 (tty->minimum_to_wake > minimum))
1793 tty->minimum_to_wake = minimum;
1800 tty->minimum_to_wake = minimum = 1;
1805 * Internal serialization of reads.
1807 if (file->f_flags & O_NONBLOCK) {
1808 if (!mutex_trylock(&tty->atomic_read_lock))
1811 if (mutex_lock_interruptible(&tty->atomic_read_lock))
1812 return -ERESTARTSYS;
1814 packet = tty->packet;
1816 add_wait_queue(&tty->read_wait, &wait);
1818 /* First test for status change. */
1819 if (packet && tty->link->ctrl_status) {
1823 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
1824 cs = tty->link->ctrl_status;
1825 tty->link->ctrl_status = 0;
1826 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
1827 if (tty_put_user(tty, cs, b++)) {
1835 /* This statement must be first before checking for input
1836 so that any interrupt will set the state back to
1838 set_current_state(TASK_INTERRUPTIBLE);
1840 if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
1841 ((minimum - (b - buf)) >= 1))
1842 tty->minimum_to_wake = (minimum - (b - buf));
1844 if (!input_available_p(tty, 0)) {
1845 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
1849 if (tty_hung_up_p(file))
1853 if (file->f_flags & O_NONBLOCK) {
1857 if (signal_pending(current)) {
1858 retval = -ERESTARTSYS;
1861 /* FIXME: does n_tty_set_room need locking ? */
1862 n_tty_set_room(tty);
1863 timeout = schedule_timeout(timeout);
1866 __set_current_state(TASK_RUNNING);
1868 /* Deal with packet mode. */
1869 if (packet && b == buf) {
1870 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
1878 if (ldata->icanon && !L_EXTPROC(tty)) {
1879 /* N.B. avoid overrun if nr == 0 */
1880 spin_lock_irqsave(&tty->read_lock, flags);
1881 while (nr && tty->read_cnt) {
1884 eol = test_and_clear_bit(tty->read_tail,
1886 c = tty->read_buf[tty->read_tail];
1887 tty->read_tail = ((tty->read_tail+1) &
1888 (N_TTY_BUF_SIZE-1));
1891 /* this test should be redundant:
1892 * we shouldn't be reading data if
1895 if (--tty->canon_data < 0)
1896 tty->canon_data = 0;
1898 spin_unlock_irqrestore(&tty->read_lock, flags);
1900 if (!eol || (c != __DISABLED_CHAR)) {
1901 if (tty_put_user(tty, c, b++)) {
1904 spin_lock_irqsave(&tty->read_lock, flags);
1910 tty_audit_push(tty);
1911 spin_lock_irqsave(&tty->read_lock, flags);
1914 spin_lock_irqsave(&tty->read_lock, flags);
1916 spin_unlock_irqrestore(&tty->read_lock, flags);
1921 /* The copy function takes the read lock and handles
1922 locking internally for this case */
1923 uncopied = copy_from_read_buf(tty, &b, &nr);
1924 uncopied += copy_from_read_buf(tty, &b, &nr);
1931 /* If there is enough space in the read buffer now, let the
1932 * low-level driver know. We use n_tty_chars_in_buffer() to
1933 * check the buffer, as it now knows about canonical mode.
1934 * Otherwise, if the driver is throttled and the line is
1935 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
1936 * we won't get any more characters.
1938 if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
1939 n_tty_set_room(tty);
1940 check_unthrottle(tty);
1943 if (b - buf >= minimum)
1948 mutex_unlock(&tty->atomic_read_lock);
1949 remove_wait_queue(&tty->read_wait, &wait);
1951 if (!waitqueue_active(&tty->read_wait))
1952 tty->minimum_to_wake = minimum;
1954 __set_current_state(TASK_RUNNING);
1959 clear_bit(TTY_PUSH, &tty->flags);
1960 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
1963 n_tty_set_room(tty);
1968 * n_tty_write - write function for tty
1970 * @file: file object
1971 * @buf: userspace buffer pointer
1974 * Write function of the terminal device. This is serialized with
1975 * respect to other write callers but not to termios changes, reads
1976 * and other such events. Since the receive code will echo characters,
1977 * thus calling driver write methods, the output_lock is used in
1978 * the output processing functions called here as well as in the
1979 * echo processing function to protect the column state and space
1980 * left in the buffer.
1982 * This code must be sure never to sleep through a hangup.
1984 * Locking: output_lock to protect column state and space left
1985 * (note that the process_output*() functions take this
1989 static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
1990 const unsigned char *buf, size_t nr)
1992 const unsigned char *b = buf;
1993 DECLARE_WAITQUEUE(wait, current);
1997 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
1998 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
1999 retval = tty_check_change(tty);
2004 /* Write out any echoed characters that are still pending */
2005 process_echoes(tty);
2007 add_wait_queue(&tty->write_wait, &wait);
2009 set_current_state(TASK_INTERRUPTIBLE);
2010 if (signal_pending(current)) {
2011 retval = -ERESTARTSYS;
2014 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2018 if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
2020 ssize_t num = process_output_block(tty, b, nr);
2032 if (process_output(c, tty) < 0)
2036 if (tty->ops->flush_chars)
2037 tty->ops->flush_chars(tty);
2040 c = tty->ops->write(tty, b, nr);
2053 if (file->f_flags & O_NONBLOCK) {
2060 __set_current_state(TASK_RUNNING);
2061 remove_wait_queue(&tty->write_wait, &wait);
2062 if (b - buf != nr && tty->fasync)
2063 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2064 return (b - buf) ? b - buf : retval;
2068 * n_tty_poll - poll method for N_TTY
2069 * @tty: terminal device
2070 * @file: file accessing it
2073 * Called when the line discipline is asked to poll() for data or
2074 * for special events. This code is not serialized with respect to
2075 * other events save open/close.
2077 * This code must be sure never to sleep through a hangup.
2078 * Called without the kernel lock held - fine
2081 static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
2084 unsigned int mask = 0;
2086 poll_wait(file, &tty->read_wait, wait);
2087 poll_wait(file, &tty->write_wait, wait);
2088 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
2089 mask |= POLLIN | POLLRDNORM;
2090 if (tty->packet && tty->link->ctrl_status)
2091 mask |= POLLPRI | POLLIN | POLLRDNORM;
2092 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2094 if (tty_hung_up_p(file))
2096 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2097 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
2098 tty->minimum_to_wake = MIN_CHAR(tty);
2100 tty->minimum_to_wake = 1;
2102 if (tty->ops->write && !tty_is_writelocked(tty) &&
2103 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2104 tty_write_room(tty) > 0)
2105 mask |= POLLOUT | POLLWRNORM;
2109 static unsigned long inq_canon(struct tty_struct *tty)
2111 struct n_tty_data *ldata = tty->disc_data;
2114 if (!tty->canon_data)
2116 head = tty->canon_head;
2117 tail = tty->read_tail;
2118 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
2119 /* Skip EOF-chars.. */
2120 while (head != tail) {
2121 if (test_bit(tail, ldata->read_flags) &&
2122 tty->read_buf[tail] == __DISABLED_CHAR)
2124 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
2129 static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2130 unsigned int cmd, unsigned long arg)
2136 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2138 /* FIXME: Locking */
2139 retval = tty->read_cnt;
2141 retval = inq_canon(tty);
2142 return put_user(retval, (unsigned int __user *) arg);
2144 return n_tty_ioctl_helper(tty, file, cmd, arg);
2148 struct tty_ldisc_ops tty_ldisc_N_TTY = {
2149 .magic = TTY_LDISC_MAGIC,
2152 .close = n_tty_close,
2153 .flush_buffer = n_tty_flush_buffer,
2154 .chars_in_buffer = n_tty_chars_in_buffer,
2156 .write = n_tty_write,
2157 .ioctl = n_tty_ioctl,
2158 .set_termios = n_tty_set_termios,
2160 .receive_buf = n_tty_receive_buf,
2161 .write_wakeup = n_tty_write_wakeup
2165 * n_tty_inherit_ops - inherit N_TTY methods
2166 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2168 * Used by a generic struct tty_ldisc_ops to easily inherit N_TTY
2172 void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2174 *ops = tty_ldisc_N_TTY;
2176 ops->refcount = ops->flags = 0;
2178 EXPORT_SYMBOL_GPL(n_tty_inherit_ops);