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
80 static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
81 unsigned char __user *ptr)
83 tty_audit_add_data(tty, &x, 1, tty->icanon);
84 return put_user(x, ptr);
88 * n_tty_set__room - receive space
91 * Called by the driver to find out how much data it is
92 * permitted to feed to the line discipline without any being lost
93 * and thus to manage flow control. Not serialized. Answers for the
97 static void n_tty_set_room(struct tty_struct *tty)
102 /* tty->read_cnt is not read locked ? */
104 /* Multiply read_cnt by 3, since each byte might take up to
105 * three times as many spaces when PARMRK is set (depending on
106 * its flags, e.g. parity error). */
107 left = N_TTY_BUF_SIZE - tty->read_cnt * 3 - 1;
109 left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
112 * If we are doing input canonicalization, and there are no
113 * pending newlines, let characters through without limit, so
114 * that erase characters will be handled. Other excess
115 * characters will be beeped.
118 left = tty->icanon && !tty->canon_data;
119 old_left = tty->receive_room;
120 tty->receive_room = left;
122 /* Did this open up the receive buffer? We may need to flip */
123 if (left && !old_left)
124 schedule_work(&tty->buf.work);
127 static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
129 if (tty->read_cnt < N_TTY_BUF_SIZE) {
130 tty->read_buf[tty->read_head] = c;
131 tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
137 * put_tty_queue - add character to tty
141 * Add a character to the tty read_buf queue. This is done under the
142 * read_lock to serialize character addition and also to protect us
143 * against parallel reads or flushes
146 static void put_tty_queue(unsigned char c, struct tty_struct *tty)
150 * The problem of stomping on the buffers ends here.
151 * Why didn't anyone see this one coming? --AJK
153 spin_lock_irqsave(&tty->read_lock, flags);
154 put_tty_queue_nolock(c, tty);
155 spin_unlock_irqrestore(&tty->read_lock, flags);
159 * check_unthrottle - allow new receive data
162 * Check whether to call the driver unthrottle functions
164 * Can sleep, may be called under the atomic_read_lock mutex but
165 * this is not guaranteed.
167 static void check_unthrottle(struct tty_struct *tty)
174 * reset_buffer_flags - reset buffer state
175 * @tty: terminal to reset
177 * Reset the read buffer counters, clear the flags,
178 * and make sure the driver is unthrottled. Called
179 * from n_tty_open() and n_tty_flush_buffer().
181 * Locking: tty_read_lock for read fields.
184 static void reset_buffer_flags(struct tty_struct *tty)
188 spin_lock_irqsave(&tty->read_lock, flags);
189 tty->read_head = tty->read_tail = tty->read_cnt = 0;
190 spin_unlock_irqrestore(&tty->read_lock, flags);
192 mutex_lock(&tty->echo_lock);
193 tty->echo_pos = tty->echo_cnt = tty->echo_overrun = 0;
194 mutex_unlock(&tty->echo_lock);
196 tty->canon_head = tty->canon_data = tty->erasing = 0;
197 memset(&tty->read_flags, 0, sizeof tty->read_flags);
202 * n_tty_flush_buffer - clean input queue
203 * @tty: terminal device
205 * Flush the input buffer. Called when the line discipline is
206 * being closed, when the tty layer wants the buffer flushed (eg
207 * at hangup) or when the N_TTY line discipline internally has to
208 * clean the pending queue (for example some signals).
210 * Locking: ctrl_lock, read_lock.
213 static void n_tty_flush_buffer(struct tty_struct *tty)
216 /* clear everything and unthrottle the driver */
217 reset_buffer_flags(tty);
222 spin_lock_irqsave(&tty->ctrl_lock, flags);
223 if (tty->link->packet) {
224 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
225 wake_up_interruptible(&tty->link->read_wait);
227 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
231 * n_tty_chars_in_buffer - report available bytes
234 * Report the number of characters buffered to be delivered to user
235 * at this instant in time.
240 static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
245 spin_lock_irqsave(&tty->read_lock, flags);
248 } else if (tty->canon_data) {
249 n = (tty->canon_head > tty->read_tail) ?
250 tty->canon_head - tty->read_tail :
251 tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail);
253 spin_unlock_irqrestore(&tty->read_lock, flags);
258 * is_utf8_continuation - utf8 multibyte check
261 * Returns true if the utf8 character 'c' is a multibyte continuation
262 * character. We use this to correctly compute the on screen size
263 * of the character when printing
266 static inline int is_utf8_continuation(unsigned char c)
268 return (c & 0xc0) == 0x80;
272 * is_continuation - multibyte check
275 * Returns true if the utf8 character 'c' is a multibyte continuation
276 * character and the terminal is in unicode mode.
279 static inline int is_continuation(unsigned char c, struct tty_struct *tty)
281 return I_IUTF8(tty) && is_utf8_continuation(c);
285 * do_output_char - output one character
286 * @c: character (or partial unicode symbol)
287 * @tty: terminal device
288 * @space: space available in tty driver write buffer
290 * This is a helper function that handles one output character
291 * (including special characters like TAB, CR, LF, etc.),
292 * doing OPOST processing and putting the results in the
293 * tty driver's write buffer.
295 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
296 * and NLDLY. They simply aren't relevant in the world today.
297 * If you ever need them, add them here.
299 * Returns the number of bytes of buffer space used or -1 if
302 * Locking: should be called under the output_lock to protect
303 * the column state and space left in the buffer
306 static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
320 tty->canon_column = tty->column = 0;
321 tty->ops->write(tty, "\r\n", 2);
324 tty->canon_column = tty->column;
327 if (O_ONOCR(tty) && tty->column == 0)
332 tty->canon_column = tty->column = 0;
335 tty->canon_column = tty->column = 0;
338 spaces = 8 - (tty->column & 7);
339 if (O_TABDLY(tty) == XTABS) {
342 tty->column += spaces;
343 tty->ops->write(tty, " ", spaces);
346 tty->column += spaces;
356 if (!is_continuation(c, tty))
362 tty_put_char(tty, c);
367 * process_output - output post processor
368 * @c: character (or partial unicode symbol)
369 * @tty: terminal device
371 * Output one character with OPOST processing.
372 * Returns -1 when the output device is full and the character
375 * Locking: output_lock to protect column state and space left
376 * (also, this is called from n_tty_write under the
377 * tty layer write lock)
380 static int process_output(unsigned char c, struct tty_struct *tty)
384 mutex_lock(&tty->output_lock);
386 space = tty_write_room(tty);
387 retval = do_output_char(c, tty, space);
389 mutex_unlock(&tty->output_lock);
397 * process_output_block - block post processor
398 * @tty: terminal device
399 * @buf: character buffer
400 * @nr: number of bytes to output
402 * Output a block of characters with OPOST processing.
403 * Returns the number of characters output.
405 * This path is used to speed up block console writes, among other
406 * things when processing blocks of output data. It handles only
407 * the simple cases normally found and helps to generate blocks of
408 * symbols for the console driver and thus improve performance.
410 * Locking: output_lock to protect column state and space left
411 * (also, this is called from n_tty_write under the
412 * tty layer write lock)
415 static ssize_t process_output_block(struct tty_struct *tty,
416 const unsigned char *buf, unsigned int nr)
420 const unsigned char *cp;
422 mutex_lock(&tty->output_lock);
424 space = tty_write_room(tty);
426 mutex_unlock(&tty->output_lock);
432 for (i = 0, cp = buf; i < nr; i++, cp++) {
433 unsigned char c = *cp;
441 tty->canon_column = tty->column;
444 if (O_ONOCR(tty) && tty->column == 0)
448 tty->canon_column = tty->column = 0;
460 if (!is_continuation(c, tty))
467 i = tty->ops->write(tty, buf, i);
469 mutex_unlock(&tty->output_lock);
474 * process_echoes - write pending echo characters
475 * @tty: terminal device
477 * Write previously buffered echo (and other ldisc-generated)
478 * characters to the tty.
480 * Characters generated by the ldisc (including echoes) need to
481 * be buffered because the driver's write buffer can fill during
482 * heavy program output. Echoing straight to the driver will
483 * often fail under these conditions, causing lost characters and
484 * resulting mismatches of ldisc state information.
486 * Since the ldisc state must represent the characters actually sent
487 * to the driver at the time of the write, operations like certain
488 * changes in column state are also saved in the buffer and executed
491 * A circular fifo buffer is used so that the most recent characters
492 * are prioritized. Also, when control characters are echoed with a
493 * prefixed "^", the pair is treated atomically and thus not separated.
495 * Locking: output_lock to protect column state and space left,
496 * echo_lock to protect the echo buffer
499 static void process_echoes(struct tty_struct *tty)
503 unsigned char *cp, *buf_end;
508 mutex_lock(&tty->output_lock);
509 mutex_lock(&tty->echo_lock);
511 space = tty_write_room(tty);
513 buf_end = tty->echo_buf + N_TTY_BUF_SIZE;
514 cp = tty->echo_buf + tty->echo_pos;
518 if (c == ECHO_OP_START) {
521 int no_space_left = 0;
524 * If the buffer byte is the start of a multi-byte
525 * operation, get the next byte, which is either the
526 * op code or a control character value.
530 opp -= N_TTY_BUF_SIZE;
534 unsigned int num_chars, num_bs;
536 case ECHO_OP_ERASE_TAB:
537 if (++opp == buf_end)
538 opp -= N_TTY_BUF_SIZE;
542 * Determine how many columns to go back
543 * in order to erase the tab.
544 * This depends on the number of columns
545 * used by other characters within the tab
546 * area. If this (modulo 8) count is from
547 * the start of input rather than from a
548 * previous tab, we offset by canon column.
549 * Otherwise, tab spacing is normal.
551 if (!(num_chars & 0x80))
552 num_chars += tty->canon_column;
553 num_bs = 8 - (num_chars & 7);
555 if (num_bs > space) {
561 tty_put_char(tty, '\b');
569 case ECHO_OP_SET_CANON_COL:
570 tty->canon_column = tty->column;
575 case ECHO_OP_MOVE_BACK_COL:
583 /* This is an escaped echo op start code */
588 tty_put_char(tty, ECHO_OP_START);
597 * If the op is not a special byte code,
598 * it is a ctrl char tagged to be echoed
599 * as "^X" (where X is the letter
600 * representing the control char).
601 * Note that we must ensure there is
602 * enough space for the whole ctrl pair.
609 tty_put_char(tty, '^');
610 tty_put_char(tty, op ^ 0100);
621 !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
622 int retval = do_output_char(c, tty, space);
629 tty_put_char(tty, c);
636 /* When end of circular buffer reached, wrap around */
638 cp -= N_TTY_BUF_SIZE;
644 tty->echo_overrun = 0;
646 int num_processed = tty->echo_cnt - nr;
647 tty->echo_pos += num_processed;
648 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
650 if (num_processed > 0)
651 tty->echo_overrun = 0;
654 mutex_unlock(&tty->echo_lock);
655 mutex_unlock(&tty->output_lock);
657 if (tty->ops->flush_chars)
658 tty->ops->flush_chars(tty);
662 * add_echo_byte - add a byte to the echo buffer
663 * @c: unicode byte to echo
664 * @tty: terminal device
666 * Add a character or operation byte to the echo buffer.
668 * Should be called under the echo lock to protect the echo buffer.
671 static void add_echo_byte(unsigned char c, struct tty_struct *tty)
675 if (tty->echo_cnt == N_TTY_BUF_SIZE) {
676 /* Circular buffer is already at capacity */
677 new_byte_pos = tty->echo_pos;
680 * Since the buffer start position needs to be advanced,
681 * be sure to step by a whole operation byte group.
683 if (tty->echo_buf[tty->echo_pos] == ECHO_OP_START) {
684 if (tty->echo_buf[(tty->echo_pos + 1) &
685 (N_TTY_BUF_SIZE - 1)] ==
696 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
698 tty->echo_overrun = 1;
700 new_byte_pos = tty->echo_pos + tty->echo_cnt;
701 new_byte_pos &= N_TTY_BUF_SIZE - 1;
705 tty->echo_buf[new_byte_pos] = c;
709 * echo_move_back_col - add operation to move back a column
710 * @tty: terminal device
712 * Add an operation to the echo buffer to move back one column.
714 * Locking: echo_lock to protect the echo buffer
717 static void echo_move_back_col(struct tty_struct *tty)
719 mutex_lock(&tty->echo_lock);
721 add_echo_byte(ECHO_OP_START, tty);
722 add_echo_byte(ECHO_OP_MOVE_BACK_COL, tty);
724 mutex_unlock(&tty->echo_lock);
728 * echo_set_canon_col - add operation to set the canon column
729 * @tty: terminal device
731 * Add an operation to the echo buffer to set the canon column
732 * to the current column.
734 * Locking: echo_lock to protect the echo buffer
737 static void echo_set_canon_col(struct tty_struct *tty)
739 mutex_lock(&tty->echo_lock);
741 add_echo_byte(ECHO_OP_START, tty);
742 add_echo_byte(ECHO_OP_SET_CANON_COL, tty);
744 mutex_unlock(&tty->echo_lock);
748 * echo_erase_tab - add operation to erase a tab
749 * @num_chars: number of character columns already used
750 * @after_tab: true if num_chars starts after a previous tab
751 * @tty: terminal device
753 * Add an operation to the echo buffer to erase a tab.
755 * Called by the eraser function, which knows how many character
756 * columns have been used since either a previous tab or the start
757 * of input. This information will be used later, along with
758 * canon column (if applicable), to go back the correct number
761 * Locking: echo_lock to protect the echo buffer
764 static void echo_erase_tab(unsigned int num_chars, int after_tab,
765 struct tty_struct *tty)
767 mutex_lock(&tty->echo_lock);
769 add_echo_byte(ECHO_OP_START, tty);
770 add_echo_byte(ECHO_OP_ERASE_TAB, tty);
772 /* We only need to know this modulo 8 (tab spacing) */
775 /* Set the high bit as a flag if num_chars is after a previous tab */
779 add_echo_byte(num_chars, tty);
781 mutex_unlock(&tty->echo_lock);
785 * echo_char_raw - echo a character raw
786 * @c: unicode byte to echo
787 * @tty: terminal device
789 * Echo user input back onto the screen. This must be called only when
790 * L_ECHO(tty) is true. Called from the driver receive_buf path.
792 * This variant does not treat control characters specially.
794 * Locking: echo_lock to protect the echo buffer
797 static void echo_char_raw(unsigned char c, struct tty_struct *tty)
799 mutex_lock(&tty->echo_lock);
801 if (c == ECHO_OP_START) {
802 add_echo_byte(ECHO_OP_START, tty);
803 add_echo_byte(ECHO_OP_START, tty);
805 add_echo_byte(c, tty);
808 mutex_unlock(&tty->echo_lock);
812 * echo_char - echo a character
813 * @c: unicode byte to echo
814 * @tty: terminal device
816 * Echo user input back onto the screen. This must be called only when
817 * L_ECHO(tty) is true. Called from the driver receive_buf path.
819 * This variant tags control characters to be echoed as "^X"
820 * (where X is the letter representing the control char).
822 * Locking: echo_lock to protect the echo buffer
825 static void echo_char(unsigned char c, struct tty_struct *tty)
827 mutex_lock(&tty->echo_lock);
829 if (c == ECHO_OP_START) {
830 add_echo_byte(ECHO_OP_START, tty);
831 add_echo_byte(ECHO_OP_START, tty);
833 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
834 add_echo_byte(ECHO_OP_START, tty);
835 add_echo_byte(c, tty);
838 mutex_unlock(&tty->echo_lock);
842 * finish_erasing - complete erase
843 * @tty: tty doing the erase
846 static inline void finish_erasing(struct tty_struct *tty)
849 echo_char_raw('/', tty);
855 * eraser - handle erase function
856 * @c: character input
857 * @tty: terminal device
859 * Perform erase and necessary output when an erase character is
860 * present in the stream from the driver layer. Handles the complexities
861 * of UTF-8 multibyte symbols.
863 * Locking: read_lock for tty buffers
866 static void eraser(unsigned char c, struct tty_struct *tty)
868 enum { ERASE, WERASE, KILL } kill_type;
869 int head, seen_alnums, cnt;
872 /* FIXME: locking needed ? */
873 if (tty->read_head == tty->canon_head) {
874 /* process_output('\a', tty); */ /* what do you think? */
877 if (c == ERASE_CHAR(tty))
879 else if (c == WERASE_CHAR(tty))
883 spin_lock_irqsave(&tty->read_lock, flags);
884 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
885 (N_TTY_BUF_SIZE - 1));
886 tty->read_head = tty->canon_head;
887 spin_unlock_irqrestore(&tty->read_lock, flags);
890 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
891 spin_lock_irqsave(&tty->read_lock, flags);
892 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
893 (N_TTY_BUF_SIZE - 1));
894 tty->read_head = tty->canon_head;
895 spin_unlock_irqrestore(&tty->read_lock, flags);
897 echo_char(KILL_CHAR(tty), tty);
898 /* Add a newline if ECHOK is on and ECHOKE is off. */
900 echo_char_raw('\n', tty);
907 /* FIXME: Locking ?? */
908 while (tty->read_head != tty->canon_head) {
909 head = tty->read_head;
911 /* erase a single possibly multibyte character */
913 head = (head - 1) & (N_TTY_BUF_SIZE-1);
914 c = tty->read_buf[head];
915 } while (is_continuation(c, tty) && head != tty->canon_head);
917 /* do not partially erase */
918 if (is_continuation(c, tty))
921 if (kill_type == WERASE) {
922 /* Equivalent to BSD's ALTWERASE. */
923 if (isalnum(c) || c == '_')
925 else if (seen_alnums)
928 cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1);
929 spin_lock_irqsave(&tty->read_lock, flags);
930 tty->read_head = head;
931 tty->read_cnt -= cnt;
932 spin_unlock_irqrestore(&tty->read_lock, flags);
934 if (L_ECHOPRT(tty)) {
936 echo_char_raw('\\', tty);
939 /* if cnt > 1, output a multi-byte character */
942 head = (head+1) & (N_TTY_BUF_SIZE-1);
943 echo_char_raw(tty->read_buf[head], tty);
944 echo_move_back_col(tty);
946 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
947 echo_char(ERASE_CHAR(tty), tty);
948 } else if (c == '\t') {
949 unsigned int num_chars = 0;
951 unsigned long tail = tty->read_head;
954 * Count the columns used for characters
955 * since the start of input or after a
957 * This info is used to go back the correct
960 while (tail != tty->canon_head) {
961 tail = (tail-1) & (N_TTY_BUF_SIZE-1);
962 c = tty->read_buf[tail];
966 } else if (iscntrl(c)) {
969 } else if (!is_continuation(c, tty)) {
973 echo_erase_tab(num_chars, after_tab, tty);
975 if (iscntrl(c) && L_ECHOCTL(tty)) {
976 echo_char_raw('\b', tty);
977 echo_char_raw(' ', tty);
978 echo_char_raw('\b', tty);
980 if (!iscntrl(c) || L_ECHOCTL(tty)) {
981 echo_char_raw('\b', tty);
982 echo_char_raw(' ', tty);
983 echo_char_raw('\b', tty);
987 if (kill_type == ERASE)
990 if (tty->read_head == tty->canon_head && L_ECHO(tty))
995 * isig - handle the ISIG optio
998 * @flush: force flush
1000 * Called when a signal is being sent due to terminal input. This
1001 * may caus terminal flushing to take place according to the termios
1002 * settings and character used. Called from the driver receive_buf
1003 * path so serialized.
1005 * Locking: ctrl_lock, read_lock (both via flush buffer)
1008 static inline void isig(int sig, struct tty_struct *tty, int flush)
1011 kill_pgrp(tty->pgrp, sig, 1);
1012 if (flush || !L_NOFLSH(tty)) {
1013 n_tty_flush_buffer(tty);
1014 tty_driver_flush_buffer(tty);
1019 * n_tty_receive_break - handle break
1022 * An RS232 break event has been hit in the incoming bitstream. This
1023 * can cause a variety of events depending upon the termios settings.
1025 * Called from the receive_buf path so single threaded.
1028 static inline void n_tty_receive_break(struct tty_struct *tty)
1032 if (I_BRKINT(tty)) {
1033 isig(SIGINT, tty, 1);
1036 if (I_PARMRK(tty)) {
1037 put_tty_queue('\377', tty);
1038 put_tty_queue('\0', tty);
1040 put_tty_queue('\0', tty);
1041 wake_up_interruptible(&tty->read_wait);
1045 * n_tty_receive_overrun - handle overrun reporting
1048 * Data arrived faster than we could process it. While the tty
1049 * driver has flagged this the bits that were missed are gone
1052 * Called from the receive_buf path so single threaded. Does not
1053 * need locking as num_overrun and overrun_time are function
1057 static inline void n_tty_receive_overrun(struct tty_struct *tty)
1062 if (time_before(tty->overrun_time, jiffies - HZ) ||
1063 time_after(tty->overrun_time, jiffies)) {
1064 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1067 tty->overrun_time = jiffies;
1068 tty->num_overrun = 0;
1073 * n_tty_receive_parity_error - error notifier
1074 * @tty: terminal device
1077 * Process a parity error and queue the right data to indicate
1078 * the error case if necessary. Locking as per n_tty_receive_buf.
1080 static inline void n_tty_receive_parity_error(struct tty_struct *tty,
1085 if (I_PARMRK(tty)) {
1086 put_tty_queue('\377', tty);
1087 put_tty_queue('\0', tty);
1088 put_tty_queue(c, tty);
1089 } else if (I_INPCK(tty))
1090 put_tty_queue('\0', tty);
1092 put_tty_queue(c, tty);
1093 wake_up_interruptible(&tty->read_wait);
1097 * n_tty_receive_char - perform processing
1098 * @tty: terminal device
1101 * Process an individual character of input received from the driver.
1102 * This is serialized with respect to itself by the rules for the
1106 static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1108 unsigned long flags;
1112 put_tty_queue(c, tty);
1118 if (I_IUCLC(tty) && L_IEXTEN(tty))
1121 if (L_EXTPROC(tty)) {
1122 put_tty_queue(c, tty);
1126 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
1127 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
1128 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
1130 process_echoes(tty);
1135 if (c == START_CHAR(tty)) {
1137 process_echoes(tty);
1138 } else if (c == STOP_CHAR(tty))
1145 * If the previous character was LNEXT, or we know that this
1146 * character is not one of the characters that we'll have to
1147 * handle specially, do shortcut processing to speed things
1150 if (!test_bit(c, tty->process_char_map) || tty->lnext) {
1152 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1153 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1154 /* beep if no space */
1156 process_output('\a', tty);
1160 finish_erasing(tty);
1161 /* Record the column of first canon char. */
1162 if (tty->canon_head == tty->read_head)
1163 echo_set_canon_col(tty);
1165 process_echoes(tty);
1168 put_tty_queue(c, tty);
1169 put_tty_queue(c, tty);
1174 if (c == START_CHAR(tty)) {
1176 process_echoes(tty);
1179 if (c == STOP_CHAR(tty)) {
1188 if (c == INTR_CHAR(tty))
1191 if (c == QUIT_CHAR(tty))
1194 if (c == SUSP_CHAR(tty)) {
1197 * Note that we do not use isig() here because we want
1199 * 1) flush, 2) echo, 3) signal
1201 if (!L_NOFLSH(tty)) {
1202 n_tty_flush_buffer(tty);
1203 tty_driver_flush_buffer(tty);
1209 process_echoes(tty);
1212 kill_pgrp(tty->pgrp, signal, 1);
1222 } else if (c == '\n' && I_INLCR(tty))
1226 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1227 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1229 process_echoes(tty);
1232 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1235 finish_erasing(tty);
1236 if (L_ECHOCTL(tty)) {
1237 echo_char_raw('^', tty);
1238 echo_char_raw('\b', tty);
1239 process_echoes(tty);
1244 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
1246 unsigned long tail = tty->canon_head;
1248 finish_erasing(tty);
1250 echo_char_raw('\n', tty);
1251 while (tail != tty->read_head) {
1252 echo_char(tty->read_buf[tail], tty);
1253 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
1255 process_echoes(tty);
1259 if (tty->read_cnt >= N_TTY_BUF_SIZE) {
1261 process_output('\a', tty);
1264 if (L_ECHO(tty) || L_ECHONL(tty)) {
1265 echo_char_raw('\n', tty);
1266 process_echoes(tty);
1268 goto handle_newline;
1270 if (c == EOF_CHAR(tty)) {
1271 if (tty->read_cnt >= N_TTY_BUF_SIZE)
1273 if (tty->canon_head != tty->read_head)
1274 set_bit(TTY_PUSH, &tty->flags);
1275 c = __DISABLED_CHAR;
1276 goto handle_newline;
1278 if ((c == EOL_CHAR(tty)) ||
1279 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1280 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
1282 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) {
1284 process_output('\a', tty);
1288 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1291 /* Record the column of first canon char. */
1292 if (tty->canon_head == tty->read_head)
1293 echo_set_canon_col(tty);
1295 process_echoes(tty);
1298 * XXX does PARMRK doubling happen for
1299 * EOL_CHAR and EOL2_CHAR?
1302 put_tty_queue(c, tty);
1305 spin_lock_irqsave(&tty->read_lock, flags);
1306 set_bit(tty->read_head, tty->read_flags);
1307 put_tty_queue_nolock(c, tty);
1308 tty->canon_head = tty->read_head;
1310 spin_unlock_irqrestore(&tty->read_lock, flags);
1311 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1312 if (waitqueue_active(&tty->read_wait))
1313 wake_up_interruptible(&tty->read_wait);
1318 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1319 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1320 /* beep if no space */
1322 process_output('\a', tty);
1326 finish_erasing(tty);
1328 echo_char_raw('\n', tty);
1330 /* Record the column of first canon char. */
1331 if (tty->canon_head == tty->read_head)
1332 echo_set_canon_col(tty);
1335 process_echoes(tty);
1339 put_tty_queue(c, tty);
1341 put_tty_queue(c, tty);
1346 * n_tty_write_wakeup - asynchronous I/O notifier
1349 * Required for the ptys, serial driver etc. since processes
1350 * that attach themselves to the master and rely on ASYNC
1351 * IO must be woken up
1354 static void n_tty_write_wakeup(struct tty_struct *tty)
1356 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
1357 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
1361 * n_tty_receive_buf - data receive
1362 * @tty: terminal device
1365 * @count: characters
1367 * Called by the terminal driver when a block of characters has
1368 * been received. This function must be called from soft contexts
1369 * not from interrupt context. The driver is responsible for making
1370 * calls one at a time and in order (or using flush_to_ldisc)
1373 static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1374 char *fp, int count)
1376 const unsigned char *p;
1377 char *f, flags = TTY_NORMAL;
1380 unsigned long cpuflags;
1382 if (tty->real_raw) {
1383 spin_lock_irqsave(&tty->read_lock, cpuflags);
1384 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1385 N_TTY_BUF_SIZE - tty->read_head);
1387 memcpy(tty->read_buf + tty->read_head, cp, i);
1388 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1393 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1394 N_TTY_BUF_SIZE - tty->read_head);
1396 memcpy(tty->read_buf + tty->read_head, cp, i);
1397 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1399 spin_unlock_irqrestore(&tty->read_lock, cpuflags);
1401 for (i = count, p = cp, f = fp; i; i--, p++) {
1406 n_tty_receive_char(tty, *p);
1409 n_tty_receive_break(tty);
1413 n_tty_receive_parity_error(tty, *p);
1416 n_tty_receive_overrun(tty);
1419 printk(KERN_ERR "%s: unknown flag %d\n",
1420 tty_name(tty, buf), flags);
1424 if (tty->ops->flush_chars)
1425 tty->ops->flush_chars(tty);
1428 n_tty_set_room(tty);
1430 if ((!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) ||
1432 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1433 if (waitqueue_active(&tty->read_wait))
1434 wake_up_interruptible(&tty->read_wait);
1438 * Check the remaining room for the input canonicalization
1439 * mode. We don't want to throttle the driver if we're in
1440 * canonical mode and don't have a newline yet!
1442 if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
1445 /* FIXME: there is a tiny race here if the receive room check runs
1446 before the other work executes and empties the buffer (upping
1447 the receiving room and unthrottling. We then throttle and get
1448 stuck. This has been observed and traced down by Vincent Pillet/
1449 We need to address this when we sort out out the rx path locking */
1452 int is_ignored(int sig)
1454 return (sigismember(¤t->blocked, sig) ||
1455 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
1459 * n_tty_set_termios - termios data changed
1461 * @old: previous data
1463 * Called by the tty layer when the user changes termios flags so
1464 * that the line discipline can plan ahead. This function cannot sleep
1465 * and is protected from re-entry by the tty layer. The user is
1466 * guaranteed that this function will not be re-entered or in progress
1467 * when the ldisc is closed.
1469 * Locking: Caller holds tty->termios_mutex
1472 static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1474 int canon_change = 1;
1477 canon_change = (old->c_lflag ^ tty->termios.c_lflag) & ICANON;
1479 memset(&tty->read_flags, 0, sizeof tty->read_flags);
1480 tty->canon_head = tty->read_tail;
1481 tty->canon_data = 0;
1485 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
1486 wake_up_interruptible(&tty->read_wait);
1488 tty->icanon = (L_ICANON(tty) != 0);
1489 if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
1492 n_tty_set_room(tty);
1495 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1496 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1497 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1499 memset(tty->process_char_map, 0, 256/8);
1501 if (I_IGNCR(tty) || I_ICRNL(tty))
1502 set_bit('\r', tty->process_char_map);
1504 set_bit('\n', tty->process_char_map);
1506 if (L_ICANON(tty)) {
1507 set_bit(ERASE_CHAR(tty), tty->process_char_map);
1508 set_bit(KILL_CHAR(tty), tty->process_char_map);
1509 set_bit(EOF_CHAR(tty), tty->process_char_map);
1510 set_bit('\n', tty->process_char_map);
1511 set_bit(EOL_CHAR(tty), tty->process_char_map);
1512 if (L_IEXTEN(tty)) {
1513 set_bit(WERASE_CHAR(tty),
1514 tty->process_char_map);
1515 set_bit(LNEXT_CHAR(tty),
1516 tty->process_char_map);
1517 set_bit(EOL2_CHAR(tty),
1518 tty->process_char_map);
1520 set_bit(REPRINT_CHAR(tty),
1521 tty->process_char_map);
1525 set_bit(START_CHAR(tty), tty->process_char_map);
1526 set_bit(STOP_CHAR(tty), tty->process_char_map);
1529 set_bit(INTR_CHAR(tty), tty->process_char_map);
1530 set_bit(QUIT_CHAR(tty), tty->process_char_map);
1531 set_bit(SUSP_CHAR(tty), tty->process_char_map);
1533 clear_bit(__DISABLED_CHAR, tty->process_char_map);
1538 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1539 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1540 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1545 n_tty_set_room(tty);
1546 /* The termios change make the tty ready for I/O */
1547 wake_up_interruptible(&tty->write_wait);
1548 wake_up_interruptible(&tty->read_wait);
1552 * n_tty_close - close the ldisc for this tty
1555 * Called from the terminal layer when this line discipline is
1556 * being shut down, either because of a close or becsuse of a
1557 * discipline change. The function will not be called while other
1558 * ldisc methods are in progress.
1561 static void n_tty_close(struct tty_struct *tty)
1563 struct n_tty_data *ldata = tty->disc_data;
1565 n_tty_flush_buffer(tty);
1566 kfree(tty->read_buf);
1567 kfree(tty->echo_buf);
1569 tty->read_buf = NULL;
1570 tty->echo_buf = NULL;
1571 tty->disc_data = NULL;
1575 * n_tty_open - open an ldisc
1576 * @tty: terminal to open
1578 * Called when this line discipline is being attached to the
1579 * terminal device. Can sleep. Called serialized so that no
1580 * other events will occur in parallel. No further open will occur
1584 static int n_tty_open(struct tty_struct *tty)
1586 struct n_tty_data *ldata;
1588 ldata = kzalloc(sizeof(*ldata), GFP_KERNEL);
1592 /* These are ugly. Currently a malloc failure here can panic */
1593 tty->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1594 tty->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1595 if (!tty->read_buf || !tty->echo_buf)
1598 tty->disc_data = ldata;
1599 reset_buffer_flags(tty);
1600 tty_unthrottle(tty);
1602 n_tty_set_termios(tty, NULL);
1603 tty->minimum_to_wake = 1;
1608 kfree(tty->read_buf);
1609 kfree(tty->echo_buf);
1615 static inline int input_available_p(struct tty_struct *tty, int amt)
1617 tty_flush_to_ldisc(tty);
1618 if (tty->icanon && !L_EXTPROC(tty)) {
1619 if (tty->canon_data)
1621 } else if (tty->read_cnt >= (amt ? amt : 1))
1628 * copy_from_read_buf - copy read data directly
1629 * @tty: terminal device
1633 * Helper function to speed up n_tty_read. It is only called when
1634 * ICANON is off; it copies characters straight from the tty queue to
1635 * user space directly. It can be profitably called twice; once to
1636 * drain the space from the tail pointer to the (physical) end of the
1637 * buffer, and once to drain the space from the (physical) beginning of
1638 * the buffer to head pointer.
1640 * Called under the tty->atomic_read_lock sem
1644 static int copy_from_read_buf(struct tty_struct *tty,
1645 unsigned char __user **b,
1651 unsigned long flags;
1655 spin_lock_irqsave(&tty->read_lock, flags);
1656 n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail);
1658 spin_unlock_irqrestore(&tty->read_lock, flags);
1660 retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);
1663 tty->read_buf[tty->read_tail] == EOF_CHAR(tty);
1664 tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n,
1666 spin_lock_irqsave(&tty->read_lock, flags);
1667 tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
1669 /* Turn single EOF into zero-length read */
1670 if (L_EXTPROC(tty) && tty->icanon && is_eof && !tty->read_cnt)
1672 spin_unlock_irqrestore(&tty->read_lock, flags);
1679 extern ssize_t redirected_tty_write(struct file *, const char __user *,
1683 * job_control - check job control
1685 * @file: file handle
1687 * Perform job control management checks on this file/tty descriptor
1688 * and if appropriate send any needed signals and return a negative
1689 * error code if action should be taken.
1692 * Locking: None - redirected write test is safe, testing
1693 * current->signal should possibly lock current->sighand
1697 static int job_control(struct tty_struct *tty, struct file *file)
1699 /* Job control check -- must be done at start and after
1700 every sleep (POSIX.1 7.1.1.4). */
1701 /* NOTE: not yet done after every sleep pending a thorough
1702 check of the logic of this change. -- jlc */
1703 /* don't stop on /dev/console */
1704 if (file->f_op->write != redirected_tty_write &&
1705 current->signal->tty == tty) {
1707 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
1708 else if (task_pgrp(current) != tty->pgrp) {
1709 if (is_ignored(SIGTTIN) ||
1710 is_current_pgrp_orphaned())
1712 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
1713 set_thread_flag(TIF_SIGPENDING);
1714 return -ERESTARTSYS;
1722 * n_tty_read - read function for tty
1724 * @file: file object
1725 * @buf: userspace buffer pointer
1728 * Perform reads for the line discipline. We are guaranteed that the
1729 * line discipline will not be closed under us but we may get multiple
1730 * parallel readers and must handle this ourselves. We may also get
1731 * a hangup. Always called in user context, may sleep.
1733 * This code must be sure never to sleep through a hangup.
1736 static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
1737 unsigned char __user *buf, size_t nr)
1739 unsigned char __user *b = buf;
1740 DECLARE_WAITQUEUE(wait, current);
1746 unsigned long flags;
1750 c = job_control(tty, file);
1755 timeout = MAX_SCHEDULE_TIMEOUT;
1757 time = (HZ / 10) * TIME_CHAR(tty);
1758 minimum = MIN_CHAR(tty);
1761 tty->minimum_to_wake = 1;
1762 else if (!waitqueue_active(&tty->read_wait) ||
1763 (tty->minimum_to_wake > minimum))
1764 tty->minimum_to_wake = minimum;
1771 tty->minimum_to_wake = minimum = 1;
1776 * Internal serialization of reads.
1778 if (file->f_flags & O_NONBLOCK) {
1779 if (!mutex_trylock(&tty->atomic_read_lock))
1782 if (mutex_lock_interruptible(&tty->atomic_read_lock))
1783 return -ERESTARTSYS;
1785 packet = tty->packet;
1787 add_wait_queue(&tty->read_wait, &wait);
1789 /* First test for status change. */
1790 if (packet && tty->link->ctrl_status) {
1794 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
1795 cs = tty->link->ctrl_status;
1796 tty->link->ctrl_status = 0;
1797 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
1798 if (tty_put_user(tty, cs, b++)) {
1806 /* This statement must be first before checking for input
1807 so that any interrupt will set the state back to
1809 set_current_state(TASK_INTERRUPTIBLE);
1811 if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
1812 ((minimum - (b - buf)) >= 1))
1813 tty->minimum_to_wake = (minimum - (b - buf));
1815 if (!input_available_p(tty, 0)) {
1816 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
1820 if (tty_hung_up_p(file))
1824 if (file->f_flags & O_NONBLOCK) {
1828 if (signal_pending(current)) {
1829 retval = -ERESTARTSYS;
1832 /* FIXME: does n_tty_set_room need locking ? */
1833 n_tty_set_room(tty);
1834 timeout = schedule_timeout(timeout);
1837 __set_current_state(TASK_RUNNING);
1839 /* Deal with packet mode. */
1840 if (packet && b == buf) {
1841 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
1849 if (tty->icanon && !L_EXTPROC(tty)) {
1850 /* N.B. avoid overrun if nr == 0 */
1851 spin_lock_irqsave(&tty->read_lock, flags);
1852 while (nr && tty->read_cnt) {
1855 eol = test_and_clear_bit(tty->read_tail,
1857 c = tty->read_buf[tty->read_tail];
1858 tty->read_tail = ((tty->read_tail+1) &
1859 (N_TTY_BUF_SIZE-1));
1862 /* this test should be redundant:
1863 * we shouldn't be reading data if
1866 if (--tty->canon_data < 0)
1867 tty->canon_data = 0;
1869 spin_unlock_irqrestore(&tty->read_lock, flags);
1871 if (!eol || (c != __DISABLED_CHAR)) {
1872 if (tty_put_user(tty, c, b++)) {
1875 spin_lock_irqsave(&tty->read_lock, flags);
1881 tty_audit_push(tty);
1882 spin_lock_irqsave(&tty->read_lock, flags);
1885 spin_lock_irqsave(&tty->read_lock, flags);
1887 spin_unlock_irqrestore(&tty->read_lock, flags);
1892 /* The copy function takes the read lock and handles
1893 locking internally for this case */
1894 uncopied = copy_from_read_buf(tty, &b, &nr);
1895 uncopied += copy_from_read_buf(tty, &b, &nr);
1902 /* If there is enough space in the read buffer now, let the
1903 * low-level driver know. We use n_tty_chars_in_buffer() to
1904 * check the buffer, as it now knows about canonical mode.
1905 * Otherwise, if the driver is throttled and the line is
1906 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
1907 * we won't get any more characters.
1909 if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
1910 n_tty_set_room(tty);
1911 check_unthrottle(tty);
1914 if (b - buf >= minimum)
1919 mutex_unlock(&tty->atomic_read_lock);
1920 remove_wait_queue(&tty->read_wait, &wait);
1922 if (!waitqueue_active(&tty->read_wait))
1923 tty->minimum_to_wake = minimum;
1925 __set_current_state(TASK_RUNNING);
1930 clear_bit(TTY_PUSH, &tty->flags);
1931 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
1934 n_tty_set_room(tty);
1939 * n_tty_write - write function for tty
1941 * @file: file object
1942 * @buf: userspace buffer pointer
1945 * Write function of the terminal device. This is serialized with
1946 * respect to other write callers but not to termios changes, reads
1947 * and other such events. Since the receive code will echo characters,
1948 * thus calling driver write methods, the output_lock is used in
1949 * the output processing functions called here as well as in the
1950 * echo processing function to protect the column state and space
1951 * left in the buffer.
1953 * This code must be sure never to sleep through a hangup.
1955 * Locking: output_lock to protect column state and space left
1956 * (note that the process_output*() functions take this
1960 static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
1961 const unsigned char *buf, size_t nr)
1963 const unsigned char *b = buf;
1964 DECLARE_WAITQUEUE(wait, current);
1968 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
1969 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
1970 retval = tty_check_change(tty);
1975 /* Write out any echoed characters that are still pending */
1976 process_echoes(tty);
1978 add_wait_queue(&tty->write_wait, &wait);
1980 set_current_state(TASK_INTERRUPTIBLE);
1981 if (signal_pending(current)) {
1982 retval = -ERESTARTSYS;
1985 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
1989 if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
1991 ssize_t num = process_output_block(tty, b, nr);
2003 if (process_output(c, tty) < 0)
2007 if (tty->ops->flush_chars)
2008 tty->ops->flush_chars(tty);
2011 c = tty->ops->write(tty, b, nr);
2024 if (file->f_flags & O_NONBLOCK) {
2031 __set_current_state(TASK_RUNNING);
2032 remove_wait_queue(&tty->write_wait, &wait);
2033 if (b - buf != nr && tty->fasync)
2034 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2035 return (b - buf) ? b - buf : retval;
2039 * n_tty_poll - poll method for N_TTY
2040 * @tty: terminal device
2041 * @file: file accessing it
2044 * Called when the line discipline is asked to poll() for data or
2045 * for special events. This code is not serialized with respect to
2046 * other events save open/close.
2048 * This code must be sure never to sleep through a hangup.
2049 * Called without the kernel lock held - fine
2052 static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
2055 unsigned int mask = 0;
2057 poll_wait(file, &tty->read_wait, wait);
2058 poll_wait(file, &tty->write_wait, wait);
2059 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
2060 mask |= POLLIN | POLLRDNORM;
2061 if (tty->packet && tty->link->ctrl_status)
2062 mask |= POLLPRI | POLLIN | POLLRDNORM;
2063 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2065 if (tty_hung_up_p(file))
2067 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2068 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
2069 tty->minimum_to_wake = MIN_CHAR(tty);
2071 tty->minimum_to_wake = 1;
2073 if (tty->ops->write && !tty_is_writelocked(tty) &&
2074 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2075 tty_write_room(tty) > 0)
2076 mask |= POLLOUT | POLLWRNORM;
2080 static unsigned long inq_canon(struct tty_struct *tty)
2084 if (!tty->canon_data)
2086 head = tty->canon_head;
2087 tail = tty->read_tail;
2088 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
2089 /* Skip EOF-chars.. */
2090 while (head != tail) {
2091 if (test_bit(tail, tty->read_flags) &&
2092 tty->read_buf[tail] == __DISABLED_CHAR)
2094 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
2099 static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2100 unsigned int cmd, unsigned long arg)
2106 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2108 /* FIXME: Locking */
2109 retval = tty->read_cnt;
2111 retval = inq_canon(tty);
2112 return put_user(retval, (unsigned int __user *) arg);
2114 return n_tty_ioctl_helper(tty, file, cmd, arg);
2118 struct tty_ldisc_ops tty_ldisc_N_TTY = {
2119 .magic = TTY_LDISC_MAGIC,
2122 .close = n_tty_close,
2123 .flush_buffer = n_tty_flush_buffer,
2124 .chars_in_buffer = n_tty_chars_in_buffer,
2126 .write = n_tty_write,
2127 .ioctl = n_tty_ioctl,
2128 .set_termios = n_tty_set_termios,
2130 .receive_buf = n_tty_receive_buf,
2131 .write_wakeup = n_tty_write_wakeup
2135 * n_tty_inherit_ops - inherit N_TTY methods
2136 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2138 * Used by a generic struct tty_ldisc_ops to easily inherit N_TTY
2142 void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2144 *ops = tty_ldisc_N_TTY;
2146 ops->refcount = ops->flags = 0;
2148 EXPORT_SYMBOL_GPL(n_tty_inherit_ops);