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
76 static inline int tty_put_user(struct tty_struct
*tty
, unsigned char x
,
77 unsigned char __user
*ptr
)
79 tty_audit_add_data(tty
, &x
, 1);
80 return put_user(x
, ptr
);
84 * n_tty_set__room - receive space
87 * Called by the driver to find out how much data it is
88 * permitted to feed to the line discipline without any being lost
89 * and thus to manage flow control. Not serialized. Answers for the
93 static void n_tty_set_room(struct tty_struct
*tty
)
95 /* tty->read_cnt is not read locked ? */
96 int left
= N_TTY_BUF_SIZE
- tty
->read_cnt
- 1;
100 * If we are doing input canonicalization, and there are no
101 * pending newlines, let characters through without limit, so
102 * that erase characters will be handled. Other excess
103 * characters will be beeped.
106 left
= tty
->icanon
&& !tty
->canon_data
;
107 old_left
= tty
->receive_room
;
108 tty
->receive_room
= left
;
110 /* Did this open up the receive buffer? We may need to flip */
111 if (left
&& !old_left
)
112 schedule_work(&tty
->buf
.work
);
115 static void put_tty_queue_nolock(unsigned char c
, struct tty_struct
*tty
)
117 if (tty
->read_cnt
< N_TTY_BUF_SIZE
) {
118 tty
->read_buf
[tty
->read_head
] = c
;
119 tty
->read_head
= (tty
->read_head
+ 1) & (N_TTY_BUF_SIZE
-1);
125 * put_tty_queue - add character to tty
129 * Add a character to the tty read_buf queue. This is done under the
130 * read_lock to serialize character addition and also to protect us
131 * against parallel reads or flushes
134 static void put_tty_queue(unsigned char c
, struct tty_struct
*tty
)
138 * The problem of stomping on the buffers ends here.
139 * Why didn't anyone see this one coming? --AJK
141 spin_lock_irqsave(&tty
->read_lock
, flags
);
142 put_tty_queue_nolock(c
, tty
);
143 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
147 * check_unthrottle - allow new receive data
150 * Check whether to call the driver unthrottle functions
152 * Can sleep, may be called under the atomic_read_lock mutex but
153 * this is not guaranteed.
155 static void check_unthrottle(struct tty_struct
*tty
)
162 * reset_buffer_flags - reset buffer state
163 * @tty: terminal to reset
165 * Reset the read buffer counters, clear the flags,
166 * and make sure the driver is unthrottled. Called
167 * from n_tty_open() and n_tty_flush_buffer().
169 * Locking: tty_read_lock for read fields.
172 static void reset_buffer_flags(struct tty_struct
*tty
)
176 spin_lock_irqsave(&tty
->read_lock
, flags
);
177 tty
->read_head
= tty
->read_tail
= tty
->read_cnt
= 0;
178 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
180 mutex_lock(&tty
->echo_lock
);
181 tty
->echo_pos
= tty
->echo_cnt
= tty
->echo_overrun
= 0;
182 mutex_unlock(&tty
->echo_lock
);
184 tty
->canon_head
= tty
->canon_data
= tty
->erasing
= 0;
185 memset(&tty
->read_flags
, 0, sizeof tty
->read_flags
);
190 * n_tty_flush_buffer - clean input queue
191 * @tty: terminal device
193 * Flush the input buffer. Called when the line discipline is
194 * being closed, when the tty layer wants the buffer flushed (eg
195 * at hangup) or when the N_TTY line discipline internally has to
196 * clean the pending queue (for example some signals).
198 * Locking: ctrl_lock, read_lock.
201 static void n_tty_flush_buffer(struct tty_struct
*tty
)
204 /* clear everything and unthrottle the driver */
205 reset_buffer_flags(tty
);
210 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
211 if (tty
->link
->packet
) {
212 tty
->ctrl_status
|= TIOCPKT_FLUSHREAD
;
213 wake_up_interruptible(&tty
->link
->read_wait
);
215 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
219 * n_tty_chars_in_buffer - report available bytes
222 * Report the number of characters buffered to be delivered to user
223 * at this instant in time.
228 static ssize_t
n_tty_chars_in_buffer(struct tty_struct
*tty
)
233 spin_lock_irqsave(&tty
->read_lock
, flags
);
236 } else if (tty
->canon_data
) {
237 n
= (tty
->canon_head
> tty
->read_tail
) ?
238 tty
->canon_head
- tty
->read_tail
:
239 tty
->canon_head
+ (N_TTY_BUF_SIZE
- tty
->read_tail
);
241 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
246 * is_utf8_continuation - utf8 multibyte check
249 * Returns true if the utf8 character 'c' is a multibyte continuation
250 * character. We use this to correctly compute the on screen size
251 * of the character when printing
254 static inline int is_utf8_continuation(unsigned char c
)
256 return (c
& 0xc0) == 0x80;
260 * is_continuation - multibyte check
263 * Returns true if the utf8 character 'c' is a multibyte continuation
264 * character and the terminal is in unicode mode.
267 static inline int is_continuation(unsigned char c
, struct tty_struct
*tty
)
269 return I_IUTF8(tty
) && is_utf8_continuation(c
);
273 * do_output_char - output one character
274 * @c: character (or partial unicode symbol)
275 * @tty: terminal device
276 * @space: space available in tty driver write buffer
278 * This is a helper function that handles one output character
279 * (including special characters like TAB, CR, LF, etc.),
280 * doing OPOST processing and putting the results in the
281 * tty driver's write buffer.
283 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
284 * and NLDLY. They simply aren't relevant in the world today.
285 * If you ever need them, add them here.
287 * Returns the number of bytes of buffer space used or -1 if
290 * Locking: should be called under the output_lock to protect
291 * the column state and space left in the buffer
294 static int do_output_char(unsigned char c
, struct tty_struct
*tty
, int space
)
308 tty
->canon_column
= tty
->column
= 0;
309 tty
->ops
->write(tty
, "\r\n", 2);
312 tty
->canon_column
= tty
->column
;
315 if (O_ONOCR(tty
) && tty
->column
== 0)
320 tty
->canon_column
= tty
->column
= 0;
323 tty
->canon_column
= tty
->column
= 0;
326 spaces
= 8 - (tty
->column
& 7);
327 if (O_TABDLY(tty
) == XTABS
) {
330 tty
->column
+= spaces
;
331 tty
->ops
->write(tty
, " ", spaces
);
334 tty
->column
+= spaces
;
344 if (!is_continuation(c
, tty
))
350 tty_put_char(tty
, c
);
355 * process_output - output post processor
356 * @c: character (or partial unicode symbol)
357 * @tty: terminal device
359 * Output one character with OPOST processing.
360 * Returns -1 when the output device is full and the character
363 * Locking: output_lock to protect column state and space left
364 * (also, this is called from n_tty_write under the
365 * tty layer write lock)
368 static int process_output(unsigned char c
, struct tty_struct
*tty
)
372 mutex_lock(&tty
->output_lock
);
374 space
= tty_write_room(tty
);
375 retval
= do_output_char(c
, tty
, space
);
377 mutex_unlock(&tty
->output_lock
);
385 * process_output_block - block post processor
386 * @tty: terminal device
387 * @buf: character buffer
388 * @nr: number of bytes to output
390 * Output a block of characters with OPOST processing.
391 * Returns the number of characters output.
393 * This path is used to speed up block console writes, among other
394 * things when processing blocks of output data. It handles only
395 * the simple cases normally found and helps to generate blocks of
396 * symbols for the console driver and thus improve performance.
398 * Locking: output_lock to protect column state and space left
399 * (also, this is called from n_tty_write under the
400 * tty layer write lock)
403 static ssize_t
process_output_block(struct tty_struct
*tty
,
404 const unsigned char *buf
, unsigned int nr
)
408 const unsigned char *cp
;
410 mutex_lock(&tty
->output_lock
);
412 space
= tty_write_room(tty
);
414 mutex_unlock(&tty
->output_lock
);
420 for (i
= 0, cp
= buf
; i
< nr
; i
++, cp
++) {
421 unsigned char c
= *cp
;
429 tty
->canon_column
= tty
->column
;
432 if (O_ONOCR(tty
) && tty
->column
== 0)
436 tty
->canon_column
= tty
->column
= 0;
448 if (!is_continuation(c
, tty
))
455 i
= tty
->ops
->write(tty
, buf
, i
);
457 mutex_unlock(&tty
->output_lock
);
462 * process_echoes - write pending echo characters
463 * @tty: terminal device
465 * Write previously buffered echo (and other ldisc-generated)
466 * characters to the tty.
468 * Characters generated by the ldisc (including echoes) need to
469 * be buffered because the driver's write buffer can fill during
470 * heavy program output. Echoing straight to the driver will
471 * often fail under these conditions, causing lost characters and
472 * resulting mismatches of ldisc state information.
474 * Since the ldisc state must represent the characters actually sent
475 * to the driver at the time of the write, operations like certain
476 * changes in column state are also saved in the buffer and executed
479 * A circular fifo buffer is used so that the most recent characters
480 * are prioritized. Also, when control characters are echoed with a
481 * prefixed "^", the pair is treated atomically and thus not separated.
483 * Locking: output_lock to protect column state and space left,
484 * echo_lock to protect the echo buffer
487 static void process_echoes(struct tty_struct
*tty
)
491 unsigned char *cp
, *buf_end
;
496 mutex_lock(&tty
->output_lock
);
497 mutex_lock(&tty
->echo_lock
);
499 space
= tty_write_room(tty
);
501 buf_end
= tty
->echo_buf
+ N_TTY_BUF_SIZE
;
502 cp
= tty
->echo_buf
+ tty
->echo_pos
;
506 if (c
== ECHO_OP_START
) {
509 int no_space_left
= 0;
512 * If the buffer byte is the start of a multi-byte
513 * operation, get the next byte, which is either the
514 * op code or a control character value.
518 opp
-= N_TTY_BUF_SIZE
;
522 unsigned int num_chars
, num_bs
;
524 case ECHO_OP_ERASE_TAB
:
525 if (++opp
== buf_end
)
526 opp
-= N_TTY_BUF_SIZE
;
530 * Determine how many columns to go back
531 * in order to erase the tab.
532 * This depends on the number of columns
533 * used by other characters within the tab
534 * area. If this (modulo 8) count is from
535 * the start of input rather than from a
536 * previous tab, we offset by canon column.
537 * Otherwise, tab spacing is normal.
539 if (!(num_chars
& 0x80))
540 num_chars
+= tty
->canon_column
;
541 num_bs
= 8 - (num_chars
& 7);
543 if (num_bs
> space
) {
549 tty_put_char(tty
, '\b');
557 case ECHO_OP_SET_CANON_COL
:
558 tty
->canon_column
= tty
->column
;
563 case ECHO_OP_MOVE_BACK_COL
:
571 /* This is an escaped echo op start code */
576 tty_put_char(tty
, ECHO_OP_START
);
585 * If the op is not a special byte code,
586 * it is a ctrl char tagged to be echoed
587 * as "^X" (where X is the letter
588 * representing the control char).
589 * Note that we must ensure there is
590 * enough space for the whole ctrl pair.
597 tty_put_char(tty
, '^');
598 tty_put_char(tty
, op
^ 0100);
609 !(test_bit(TTY_HW_COOK_OUT
, &tty
->flags
))) {
610 int retval
= do_output_char(c
, tty
, space
);
617 tty_put_char(tty
, c
);
624 /* When end of circular buffer reached, wrap around */
626 cp
-= N_TTY_BUF_SIZE
;
632 tty
->echo_overrun
= 0;
634 int num_processed
= tty
->echo_cnt
- nr
;
635 tty
->echo_pos
+= num_processed
;
636 tty
->echo_pos
&= N_TTY_BUF_SIZE
- 1;
638 if (num_processed
> 0)
639 tty
->echo_overrun
= 0;
642 mutex_unlock(&tty
->echo_lock
);
643 mutex_unlock(&tty
->output_lock
);
645 if (tty
->ops
->flush_chars
)
646 tty
->ops
->flush_chars(tty
);
650 * add_echo_byte - add a byte to the echo buffer
651 * @c: unicode byte to echo
652 * @tty: terminal device
654 * Add a character or operation byte to the echo buffer.
656 * Should be called under the echo lock to protect the echo buffer.
659 static void add_echo_byte(unsigned char c
, struct tty_struct
*tty
)
663 if (tty
->echo_cnt
== N_TTY_BUF_SIZE
) {
664 /* Circular buffer is already at capacity */
665 new_byte_pos
= tty
->echo_pos
;
668 * Since the buffer start position needs to be advanced,
669 * be sure to step by a whole operation byte group.
671 if (tty
->echo_buf
[tty
->echo_pos
] == ECHO_OP_START
) {
672 if (tty
->echo_buf
[(tty
->echo_pos
+ 1) &
673 (N_TTY_BUF_SIZE
- 1)] ==
684 tty
->echo_pos
&= N_TTY_BUF_SIZE
- 1;
686 tty
->echo_overrun
= 1;
688 new_byte_pos
= tty
->echo_pos
+ tty
->echo_cnt
;
689 new_byte_pos
&= N_TTY_BUF_SIZE
- 1;
693 tty
->echo_buf
[new_byte_pos
] = c
;
697 * echo_move_back_col - add operation to move back a column
698 * @tty: terminal device
700 * Add an operation to the echo buffer to move back one column.
702 * Locking: echo_lock to protect the echo buffer
705 static void echo_move_back_col(struct tty_struct
*tty
)
707 mutex_lock(&tty
->echo_lock
);
709 add_echo_byte(ECHO_OP_START
, tty
);
710 add_echo_byte(ECHO_OP_MOVE_BACK_COL
, tty
);
712 mutex_unlock(&tty
->echo_lock
);
716 * echo_set_canon_col - add operation to set the canon column
717 * @tty: terminal device
719 * Add an operation to the echo buffer to set the canon column
720 * to the current column.
722 * Locking: echo_lock to protect the echo buffer
725 static void echo_set_canon_col(struct tty_struct
*tty
)
727 mutex_lock(&tty
->echo_lock
);
729 add_echo_byte(ECHO_OP_START
, tty
);
730 add_echo_byte(ECHO_OP_SET_CANON_COL
, tty
);
732 mutex_unlock(&tty
->echo_lock
);
736 * echo_erase_tab - add operation to erase a tab
737 * @num_chars: number of character columns already used
738 * @after_tab: true if num_chars starts after a previous tab
739 * @tty: terminal device
741 * Add an operation to the echo buffer to erase a tab.
743 * Called by the eraser function, which knows how many character
744 * columns have been used since either a previous tab or the start
745 * of input. This information will be used later, along with
746 * canon column (if applicable), to go back the correct number
749 * Locking: echo_lock to protect the echo buffer
752 static void echo_erase_tab(unsigned int num_chars
, int after_tab
,
753 struct tty_struct
*tty
)
755 mutex_lock(&tty
->echo_lock
);
757 add_echo_byte(ECHO_OP_START
, tty
);
758 add_echo_byte(ECHO_OP_ERASE_TAB
, tty
);
760 /* We only need to know this modulo 8 (tab spacing) */
763 /* Set the high bit as a flag if num_chars is after a previous tab */
767 add_echo_byte(num_chars
, tty
);
769 mutex_unlock(&tty
->echo_lock
);
773 * echo_char_raw - echo a character raw
774 * @c: unicode byte to echo
775 * @tty: terminal device
777 * Echo user input back onto the screen. This must be called only when
778 * L_ECHO(tty) is true. Called from the driver receive_buf path.
780 * This variant does not treat control characters specially.
782 * Locking: echo_lock to protect the echo buffer
785 static void echo_char_raw(unsigned char c
, struct tty_struct
*tty
)
787 mutex_lock(&tty
->echo_lock
);
789 if (c
== ECHO_OP_START
) {
790 add_echo_byte(ECHO_OP_START
, tty
);
791 add_echo_byte(ECHO_OP_START
, tty
);
793 add_echo_byte(c
, tty
);
796 mutex_unlock(&tty
->echo_lock
);
800 * echo_char - echo a character
801 * @c: unicode byte to echo
802 * @tty: terminal device
804 * Echo user input back onto the screen. This must be called only when
805 * L_ECHO(tty) is true. Called from the driver receive_buf path.
807 * This variant tags control characters to be echoed as "^X"
808 * (where X is the letter representing the control char).
810 * Locking: echo_lock to protect the echo buffer
813 static void echo_char(unsigned char c
, struct tty_struct
*tty
)
815 mutex_lock(&tty
->echo_lock
);
817 if (c
== ECHO_OP_START
) {
818 add_echo_byte(ECHO_OP_START
, tty
);
819 add_echo_byte(ECHO_OP_START
, tty
);
821 if (L_ECHOCTL(tty
) && iscntrl(c
) && c
!= '\t')
822 add_echo_byte(ECHO_OP_START
, tty
);
823 add_echo_byte(c
, tty
);
826 mutex_unlock(&tty
->echo_lock
);
830 * finish_erasing - complete erase
831 * @tty: tty doing the erase
834 static inline void finish_erasing(struct tty_struct
*tty
)
837 echo_char_raw('/', tty
);
843 * eraser - handle erase function
844 * @c: character input
845 * @tty: terminal device
847 * Perform erase and necessary output when an erase character is
848 * present in the stream from the driver layer. Handles the complexities
849 * of UTF-8 multibyte symbols.
851 * Locking: read_lock for tty buffers
854 static void eraser(unsigned char c
, struct tty_struct
*tty
)
856 enum { ERASE
, WERASE
, KILL
} kill_type
;
857 int head
, seen_alnums
, cnt
;
860 /* FIXME: locking needed ? */
861 if (tty
->read_head
== tty
->canon_head
) {
862 /* process_output('\a', tty); */ /* what do you think? */
865 if (c
== ERASE_CHAR(tty
))
867 else if (c
== WERASE_CHAR(tty
))
871 spin_lock_irqsave(&tty
->read_lock
, flags
);
872 tty
->read_cnt
-= ((tty
->read_head
- tty
->canon_head
) &
873 (N_TTY_BUF_SIZE
- 1));
874 tty
->read_head
= tty
->canon_head
;
875 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
878 if (!L_ECHOK(tty
) || !L_ECHOKE(tty
) || !L_ECHOE(tty
)) {
879 spin_lock_irqsave(&tty
->read_lock
, flags
);
880 tty
->read_cnt
-= ((tty
->read_head
- tty
->canon_head
) &
881 (N_TTY_BUF_SIZE
- 1));
882 tty
->read_head
= tty
->canon_head
;
883 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
885 echo_char(KILL_CHAR(tty
), tty
);
886 /* Add a newline if ECHOK is on and ECHOKE is off. */
888 echo_char_raw('\n', tty
);
895 /* FIXME: Locking ?? */
896 while (tty
->read_head
!= tty
->canon_head
) {
897 head
= tty
->read_head
;
899 /* erase a single possibly multibyte character */
901 head
= (head
- 1) & (N_TTY_BUF_SIZE
-1);
902 c
= tty
->read_buf
[head
];
903 } while (is_continuation(c
, tty
) && head
!= tty
->canon_head
);
905 /* do not partially erase */
906 if (is_continuation(c
, tty
))
909 if (kill_type
== WERASE
) {
910 /* Equivalent to BSD's ALTWERASE. */
911 if (isalnum(c
) || c
== '_')
913 else if (seen_alnums
)
916 cnt
= (tty
->read_head
- head
) & (N_TTY_BUF_SIZE
-1);
917 spin_lock_irqsave(&tty
->read_lock
, flags
);
918 tty
->read_head
= head
;
919 tty
->read_cnt
-= cnt
;
920 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
922 if (L_ECHOPRT(tty
)) {
924 echo_char_raw('\\', tty
);
927 /* if cnt > 1, output a multi-byte character */
930 head
= (head
+1) & (N_TTY_BUF_SIZE
-1);
931 echo_char_raw(tty
->read_buf
[head
], tty
);
932 echo_move_back_col(tty
);
934 } else if (kill_type
== ERASE
&& !L_ECHOE(tty
)) {
935 echo_char(ERASE_CHAR(tty
), tty
);
936 } else if (c
== '\t') {
937 unsigned int num_chars
= 0;
939 unsigned long tail
= tty
->read_head
;
942 * Count the columns used for characters
943 * since the start of input or after a
945 * This info is used to go back the correct
948 while (tail
!= tty
->canon_head
) {
949 tail
= (tail
-1) & (N_TTY_BUF_SIZE
-1);
950 c
= tty
->read_buf
[tail
];
954 } else if (iscntrl(c
)) {
957 } else if (!is_continuation(c
, tty
)) {
961 echo_erase_tab(num_chars
, after_tab
, tty
);
963 if (iscntrl(c
) && L_ECHOCTL(tty
)) {
964 echo_char_raw('\b', tty
);
965 echo_char_raw(' ', tty
);
966 echo_char_raw('\b', tty
);
968 if (!iscntrl(c
) || L_ECHOCTL(tty
)) {
969 echo_char_raw('\b', tty
);
970 echo_char_raw(' ', tty
);
971 echo_char_raw('\b', tty
);
975 if (kill_type
== ERASE
)
978 if (tty
->read_head
== tty
->canon_head
&& L_ECHO(tty
))
983 * isig - handle the ISIG optio
986 * @flush: force flush
988 * Called when a signal is being sent due to terminal input. This
989 * may caus terminal flushing to take place according to the termios
990 * settings and character used. Called from the driver receive_buf
991 * path so serialized.
993 * Locking: ctrl_lock, read_lock (both via flush buffer)
996 static inline void isig(int sig
, struct tty_struct
*tty
, int flush
)
999 kill_pgrp(tty
->pgrp
, sig
, 1);
1000 if (flush
|| !L_NOFLSH(tty
)) {
1001 n_tty_flush_buffer(tty
);
1002 tty_driver_flush_buffer(tty
);
1007 * n_tty_receive_break - handle break
1010 * An RS232 break event has been hit in the incoming bitstream. This
1011 * can cause a variety of events depending upon the termios settings.
1013 * Called from the receive_buf path so single threaded.
1016 static inline void n_tty_receive_break(struct tty_struct
*tty
)
1020 if (I_BRKINT(tty
)) {
1021 isig(SIGINT
, tty
, 1);
1024 if (I_PARMRK(tty
)) {
1025 put_tty_queue('\377', tty
);
1026 put_tty_queue('\0', tty
);
1028 put_tty_queue('\0', tty
);
1029 wake_up_interruptible(&tty
->read_wait
);
1033 * n_tty_receive_overrun - handle overrun reporting
1036 * Data arrived faster than we could process it. While the tty
1037 * driver has flagged this the bits that were missed are gone
1040 * Called from the receive_buf path so single threaded. Does not
1041 * need locking as num_overrun and overrun_time are function
1045 static inline void n_tty_receive_overrun(struct tty_struct
*tty
)
1050 if (time_before(tty
->overrun_time
, jiffies
- HZ
) ||
1051 time_after(tty
->overrun_time
, jiffies
)) {
1052 printk(KERN_WARNING
"%s: %d input overrun(s)\n",
1055 tty
->overrun_time
= jiffies
;
1056 tty
->num_overrun
= 0;
1061 * n_tty_receive_parity_error - error notifier
1062 * @tty: terminal device
1065 * Process a parity error and queue the right data to indicate
1066 * the error case if necessary. Locking as per n_tty_receive_buf.
1068 static inline void n_tty_receive_parity_error(struct tty_struct
*tty
,
1073 if (I_PARMRK(tty
)) {
1074 put_tty_queue('\377', tty
);
1075 put_tty_queue('\0', tty
);
1076 put_tty_queue(c
, tty
);
1077 } else if (I_INPCK(tty
))
1078 put_tty_queue('\0', tty
);
1080 put_tty_queue(c
, tty
);
1081 wake_up_interruptible(&tty
->read_wait
);
1085 * n_tty_receive_char - perform processing
1086 * @tty: terminal device
1089 * Process an individual character of input received from the driver.
1090 * This is serialized with respect to itself by the rules for the
1094 static inline void n_tty_receive_char(struct tty_struct
*tty
, unsigned char c
)
1096 unsigned long flags
;
1100 put_tty_queue(c
, tty
);
1106 if (I_IUCLC(tty
) && L_IEXTEN(tty
))
1109 if (L_EXTPROC(tty
)) {
1110 put_tty_queue(c
, tty
);
1114 if (tty
->stopped
&& !tty
->flow_stopped
&& I_IXON(tty
) &&
1115 I_IXANY(tty
) && c
!= START_CHAR(tty
) && c
!= STOP_CHAR(tty
) &&
1116 c
!= INTR_CHAR(tty
) && c
!= QUIT_CHAR(tty
) && c
!= SUSP_CHAR(tty
)) {
1118 process_echoes(tty
);
1123 if (c
== START_CHAR(tty
)) {
1125 process_echoes(tty
);
1126 } else if (c
== STOP_CHAR(tty
))
1133 * If the previous character was LNEXT, or we know that this
1134 * character is not one of the characters that we'll have to
1135 * handle specially, do shortcut processing to speed things
1138 if (!test_bit(c
, tty
->process_char_map
) || tty
->lnext
) {
1140 parmrk
= (c
== (unsigned char) '\377' && I_PARMRK(tty
)) ? 1 : 0;
1141 if (tty
->read_cnt
>= (N_TTY_BUF_SIZE
- parmrk
- 1)) {
1142 /* beep if no space */
1144 process_output('\a', tty
);
1148 finish_erasing(tty
);
1149 /* Record the column of first canon char. */
1150 if (tty
->canon_head
== tty
->read_head
)
1151 echo_set_canon_col(tty
);
1153 process_echoes(tty
);
1156 put_tty_queue(c
, tty
);
1157 put_tty_queue(c
, tty
);
1162 if (c
== START_CHAR(tty
)) {
1164 process_echoes(tty
);
1167 if (c
== STOP_CHAR(tty
)) {
1176 if (c
== INTR_CHAR(tty
))
1179 if (c
== QUIT_CHAR(tty
))
1182 if (c
== SUSP_CHAR(tty
)) {
1185 * Note that we do not use isig() here because we want
1187 * 1) flush, 2) echo, 3) signal
1189 if (!L_NOFLSH(tty
)) {
1190 n_tty_flush_buffer(tty
);
1191 tty_driver_flush_buffer(tty
);
1197 process_echoes(tty
);
1200 kill_pgrp(tty
->pgrp
, signal
, 1);
1210 } else if (c
== '\n' && I_INLCR(tty
))
1214 if (c
== ERASE_CHAR(tty
) || c
== KILL_CHAR(tty
) ||
1215 (c
== WERASE_CHAR(tty
) && L_IEXTEN(tty
))) {
1217 process_echoes(tty
);
1220 if (c
== LNEXT_CHAR(tty
) && L_IEXTEN(tty
)) {
1223 finish_erasing(tty
);
1224 if (L_ECHOCTL(tty
)) {
1225 echo_char_raw('^', tty
);
1226 echo_char_raw('\b', tty
);
1227 process_echoes(tty
);
1232 if (c
== REPRINT_CHAR(tty
) && L_ECHO(tty
) &&
1234 unsigned long tail
= tty
->canon_head
;
1236 finish_erasing(tty
);
1238 echo_char_raw('\n', tty
);
1239 while (tail
!= tty
->read_head
) {
1240 echo_char(tty
->read_buf
[tail
], tty
);
1241 tail
= (tail
+1) & (N_TTY_BUF_SIZE
-1);
1243 process_echoes(tty
);
1247 if (tty
->read_cnt
>= N_TTY_BUF_SIZE
) {
1249 process_output('\a', tty
);
1252 if (L_ECHO(tty
) || L_ECHONL(tty
)) {
1253 echo_char_raw('\n', tty
);
1254 process_echoes(tty
);
1256 goto handle_newline
;
1258 if (c
== EOF_CHAR(tty
)) {
1259 if (tty
->read_cnt
>= N_TTY_BUF_SIZE
)
1261 if (tty
->canon_head
!= tty
->read_head
)
1262 set_bit(TTY_PUSH
, &tty
->flags
);
1263 c
= __DISABLED_CHAR
;
1264 goto handle_newline
;
1266 if ((c
== EOL_CHAR(tty
)) ||
1267 (c
== EOL2_CHAR(tty
) && L_IEXTEN(tty
))) {
1268 parmrk
= (c
== (unsigned char) '\377' && I_PARMRK(tty
))
1270 if (tty
->read_cnt
>= (N_TTY_BUF_SIZE
- parmrk
)) {
1272 process_output('\a', tty
);
1276 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1279 /* Record the column of first canon char. */
1280 if (tty
->canon_head
== tty
->read_head
)
1281 echo_set_canon_col(tty
);
1283 process_echoes(tty
);
1286 * XXX does PARMRK doubling happen for
1287 * EOL_CHAR and EOL2_CHAR?
1290 put_tty_queue(c
, tty
);
1293 spin_lock_irqsave(&tty
->read_lock
, flags
);
1294 set_bit(tty
->read_head
, tty
->read_flags
);
1295 put_tty_queue_nolock(c
, tty
);
1296 tty
->canon_head
= tty
->read_head
;
1298 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
1299 kill_fasync(&tty
->fasync
, SIGIO
, POLL_IN
);
1300 if (waitqueue_active(&tty
->read_wait
))
1301 wake_up_interruptible(&tty
->read_wait
);
1306 parmrk
= (c
== (unsigned char) '\377' && I_PARMRK(tty
)) ? 1 : 0;
1307 if (tty
->read_cnt
>= (N_TTY_BUF_SIZE
- parmrk
- 1)) {
1308 /* beep if no space */
1310 process_output('\a', tty
);
1314 finish_erasing(tty
);
1316 echo_char_raw('\n', tty
);
1318 /* Record the column of first canon char. */
1319 if (tty
->canon_head
== tty
->read_head
)
1320 echo_set_canon_col(tty
);
1323 process_echoes(tty
);
1327 put_tty_queue(c
, tty
);
1329 put_tty_queue(c
, tty
);
1334 * n_tty_write_wakeup - asynchronous I/O notifier
1337 * Required for the ptys, serial driver etc. since processes
1338 * that attach themselves to the master and rely on ASYNC
1339 * IO must be woken up
1342 static void n_tty_write_wakeup(struct tty_struct
*tty
)
1344 if (tty
->fasync
&& test_and_clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
))
1345 kill_fasync(&tty
->fasync
, SIGIO
, POLL_OUT
);
1349 * n_tty_receive_buf - data receive
1350 * @tty: terminal device
1353 * @count: characters
1355 * Called by the terminal driver when a block of characters has
1356 * been received. This function must be called from soft contexts
1357 * not from interrupt context. The driver is responsible for making
1358 * calls one at a time and in order (or using flush_to_ldisc)
1361 static void n_tty_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
1362 char *fp
, int count
)
1364 const unsigned char *p
;
1365 char *f
, flags
= TTY_NORMAL
;
1368 unsigned long cpuflags
;
1373 if (tty
->real_raw
) {
1374 spin_lock_irqsave(&tty
->read_lock
, cpuflags
);
1375 i
= min(N_TTY_BUF_SIZE
- tty
->read_cnt
,
1376 N_TTY_BUF_SIZE
- tty
->read_head
);
1378 memcpy(tty
->read_buf
+ tty
->read_head
, cp
, i
);
1379 tty
->read_head
= (tty
->read_head
+ i
) & (N_TTY_BUF_SIZE
-1);
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);
1390 spin_unlock_irqrestore(&tty
->read_lock
, cpuflags
);
1392 for (i
= count
, p
= cp
, f
= fp
; i
; i
--, p
++) {
1397 n_tty_receive_char(tty
, *p
);
1400 n_tty_receive_break(tty
);
1404 n_tty_receive_parity_error(tty
, *p
);
1407 n_tty_receive_overrun(tty
);
1410 printk(KERN_ERR
"%s: unknown flag %d\n",
1411 tty_name(tty
, buf
), flags
);
1415 if (tty
->ops
->flush_chars
)
1416 tty
->ops
->flush_chars(tty
);
1419 n_tty_set_room(tty
);
1421 if ((!tty
->icanon
&& (tty
->read_cnt
>= tty
->minimum_to_wake
)) ||
1423 kill_fasync(&tty
->fasync
, SIGIO
, POLL_IN
);
1424 if (waitqueue_active(&tty
->read_wait
))
1425 wake_up_interruptible(&tty
->read_wait
);
1429 * Check the remaining room for the input canonicalization
1430 * mode. We don't want to throttle the driver if we're in
1431 * canonical mode and don't have a newline yet!
1433 if (tty
->receive_room
< TTY_THRESHOLD_THROTTLE
)
1436 /* FIXME: there is a tiny race here if the receive room check runs
1437 before the other work executes and empties the buffer (upping
1438 the receiving room and unthrottling. We then throttle and get
1439 stuck. This has been observed and traced down by Vincent Pillet/
1440 We need to address this when we sort out out the rx path locking */
1443 int is_ignored(int sig
)
1445 return (sigismember(¤t
->blocked
, sig
) ||
1446 current
->sighand
->action
[sig
-1].sa
.sa_handler
== SIG_IGN
);
1450 * n_tty_set_termios - termios data changed
1452 * @old: previous data
1454 * Called by the tty layer when the user changes termios flags so
1455 * that the line discipline can plan ahead. This function cannot sleep
1456 * and is protected from re-entry by the tty layer. The user is
1457 * guaranteed that this function will not be re-entered or in progress
1458 * when the ldisc is closed.
1460 * Locking: Caller holds tty->termios_mutex
1463 static void n_tty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
1465 int canon_change
= 1;
1469 canon_change
= (old
->c_lflag
^ tty
->termios
.c_lflag
) & ICANON
;
1471 memset(&tty
->read_flags
, 0, sizeof tty
->read_flags
);
1472 tty
->canon_head
= tty
->read_tail
;
1473 tty
->canon_data
= 0;
1477 if (canon_change
&& !L_ICANON(tty
) && tty
->read_cnt
)
1478 wake_up_interruptible(&tty
->read_wait
);
1480 tty
->icanon
= (L_ICANON(tty
) != 0);
1481 if (test_bit(TTY_HW_COOK_IN
, &tty
->flags
)) {
1484 n_tty_set_room(tty
);
1487 if (I_ISTRIP(tty
) || I_IUCLC(tty
) || I_IGNCR(tty
) ||
1488 I_ICRNL(tty
) || I_INLCR(tty
) || L_ICANON(tty
) ||
1489 I_IXON(tty
) || L_ISIG(tty
) || L_ECHO(tty
) ||
1491 memset(tty
->process_char_map
, 0, 256/8);
1493 if (I_IGNCR(tty
) || I_ICRNL(tty
))
1494 set_bit('\r', tty
->process_char_map
);
1496 set_bit('\n', tty
->process_char_map
);
1498 if (L_ICANON(tty
)) {
1499 set_bit(ERASE_CHAR(tty
), tty
->process_char_map
);
1500 set_bit(KILL_CHAR(tty
), tty
->process_char_map
);
1501 set_bit(EOF_CHAR(tty
), tty
->process_char_map
);
1502 set_bit('\n', tty
->process_char_map
);
1503 set_bit(EOL_CHAR(tty
), tty
->process_char_map
);
1504 if (L_IEXTEN(tty
)) {
1505 set_bit(WERASE_CHAR(tty
),
1506 tty
->process_char_map
);
1507 set_bit(LNEXT_CHAR(tty
),
1508 tty
->process_char_map
);
1509 set_bit(EOL2_CHAR(tty
),
1510 tty
->process_char_map
);
1512 set_bit(REPRINT_CHAR(tty
),
1513 tty
->process_char_map
);
1517 set_bit(START_CHAR(tty
), tty
->process_char_map
);
1518 set_bit(STOP_CHAR(tty
), tty
->process_char_map
);
1521 set_bit(INTR_CHAR(tty
), tty
->process_char_map
);
1522 set_bit(QUIT_CHAR(tty
), tty
->process_char_map
);
1523 set_bit(SUSP_CHAR(tty
), tty
->process_char_map
);
1525 clear_bit(__DISABLED_CHAR
, tty
->process_char_map
);
1530 if ((I_IGNBRK(tty
) || (!I_BRKINT(tty
) && !I_PARMRK(tty
))) &&
1531 (I_IGNPAR(tty
) || !I_INPCK(tty
)) &&
1532 (tty
->driver
->flags
& TTY_DRIVER_REAL_RAW
))
1537 n_tty_set_room(tty
);
1538 /* The termios change make the tty ready for I/O */
1539 wake_up_interruptible(&tty
->write_wait
);
1540 wake_up_interruptible(&tty
->read_wait
);
1544 * n_tty_close - close the ldisc for this tty
1547 * Called from the terminal layer when this line discipline is
1548 * being shut down, either because of a close or becsuse of a
1549 * discipline change. The function will not be called while other
1550 * ldisc methods are in progress.
1553 static void n_tty_close(struct tty_struct
*tty
)
1555 n_tty_flush_buffer(tty
);
1556 if (tty
->read_buf
) {
1557 kfree(tty
->read_buf
);
1558 tty
->read_buf
= NULL
;
1560 if (tty
->echo_buf
) {
1561 kfree(tty
->echo_buf
);
1562 tty
->echo_buf
= NULL
;
1567 * n_tty_open - open an ldisc
1568 * @tty: terminal to open
1570 * Called when this line discipline is being attached to the
1571 * terminal device. Can sleep. Called serialized so that no
1572 * other events will occur in parallel. No further open will occur
1576 static int n_tty_open(struct tty_struct
*tty
)
1581 /* These are ugly. Currently a malloc failure here can panic */
1582 if (!tty
->read_buf
) {
1583 tty
->read_buf
= kzalloc(N_TTY_BUF_SIZE
, GFP_KERNEL
);
1587 if (!tty
->echo_buf
) {
1588 tty
->echo_buf
= kzalloc(N_TTY_BUF_SIZE
, GFP_KERNEL
);
1593 reset_buffer_flags(tty
);
1594 tty_unthrottle(tty
);
1596 n_tty_set_termios(tty
, NULL
);
1597 tty
->minimum_to_wake
= 1;
1602 static inline int input_available_p(struct tty_struct
*tty
, int amt
)
1604 tty_flush_to_ldisc(tty
);
1605 if (tty
->icanon
&& !L_EXTPROC(tty
)) {
1606 if (tty
->canon_data
)
1608 } else if (tty
->read_cnt
>= (amt
? amt
: 1))
1615 * copy_from_read_buf - copy read data directly
1616 * @tty: terminal device
1620 * Helper function to speed up n_tty_read. It is only called when
1621 * ICANON is off; it copies characters straight from the tty queue to
1622 * user space directly. It can be profitably called twice; once to
1623 * drain the space from the tail pointer to the (physical) end of the
1624 * buffer, and once to drain the space from the (physical) beginning of
1625 * the buffer to head pointer.
1627 * Called under the tty->atomic_read_lock sem
1631 static int copy_from_read_buf(struct tty_struct
*tty
,
1632 unsigned char __user
**b
,
1638 unsigned long flags
;
1642 spin_lock_irqsave(&tty
->read_lock
, flags
);
1643 n
= min(tty
->read_cnt
, N_TTY_BUF_SIZE
- tty
->read_tail
);
1645 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
1647 retval
= copy_to_user(*b
, &tty
->read_buf
[tty
->read_tail
], n
);
1650 tty
->read_buf
[tty
->read_tail
] == EOF_CHAR(tty
);
1651 tty_audit_add_data(tty
, &tty
->read_buf
[tty
->read_tail
], n
);
1652 spin_lock_irqsave(&tty
->read_lock
, flags
);
1653 tty
->read_tail
= (tty
->read_tail
+ n
) & (N_TTY_BUF_SIZE
-1);
1655 /* Turn single EOF into zero-length read */
1656 if (L_EXTPROC(tty
) && tty
->icanon
&& is_eof
&& !tty
->read_cnt
)
1658 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
1665 extern ssize_t
redirected_tty_write(struct file
*, const char __user
*,
1669 * job_control - check job control
1671 * @file: file handle
1673 * Perform job control management checks on this file/tty descriptor
1674 * and if appropriate send any needed signals and return a negative
1675 * error code if action should be taken.
1678 * Locking: None - redirected write test is safe, testing
1679 * current->signal should possibly lock current->sighand
1683 static int job_control(struct tty_struct
*tty
, struct file
*file
)
1685 /* Job control check -- must be done at start and after
1686 every sleep (POSIX.1 7.1.1.4). */
1687 /* NOTE: not yet done after every sleep pending a thorough
1688 check of the logic of this change. -- jlc */
1689 /* don't stop on /dev/console */
1690 if (file
->f_op
->write
!= redirected_tty_write
&&
1691 current
->signal
->tty
== tty
) {
1693 printk(KERN_ERR
"n_tty_read: no tty->pgrp!\n");
1694 else if (task_pgrp(current
) != tty
->pgrp
) {
1695 if (is_ignored(SIGTTIN
) ||
1696 is_current_pgrp_orphaned())
1698 kill_pgrp(task_pgrp(current
), SIGTTIN
, 1);
1699 set_thread_flag(TIF_SIGPENDING
);
1700 return -ERESTARTSYS
;
1708 * n_tty_read - read function for tty
1710 * @file: file object
1711 * @buf: userspace buffer pointer
1714 * Perform reads for the line discipline. We are guaranteed that the
1715 * line discipline will not be closed under us but we may get multiple
1716 * parallel readers and must handle this ourselves. We may also get
1717 * a hangup. Always called in user context, may sleep.
1719 * This code must be sure never to sleep through a hangup.
1722 static ssize_t
n_tty_read(struct tty_struct
*tty
, struct file
*file
,
1723 unsigned char __user
*buf
, size_t nr
)
1725 unsigned char __user
*b
= buf
;
1726 DECLARE_WAITQUEUE(wait
, current
);
1732 unsigned long flags
;
1737 BUG_ON(!tty
->read_buf
);
1739 c
= job_control(tty
, file
);
1744 timeout
= MAX_SCHEDULE_TIMEOUT
;
1746 time
= (HZ
/ 10) * TIME_CHAR(tty
);
1747 minimum
= MIN_CHAR(tty
);
1750 tty
->minimum_to_wake
= 1;
1751 else if (!waitqueue_active(&tty
->read_wait
) ||
1752 (tty
->minimum_to_wake
> minimum
))
1753 tty
->minimum_to_wake
= minimum
;
1760 tty
->minimum_to_wake
= minimum
= 1;
1765 * Internal serialization of reads.
1767 if (file
->f_flags
& O_NONBLOCK
) {
1768 if (!mutex_trylock(&tty
->atomic_read_lock
))
1771 if (mutex_lock_interruptible(&tty
->atomic_read_lock
))
1772 return -ERESTARTSYS
;
1774 packet
= tty
->packet
;
1776 add_wait_queue(&tty
->read_wait
, &wait
);
1778 /* First test for status change. */
1779 if (packet
&& tty
->link
->ctrl_status
) {
1783 spin_lock_irqsave(&tty
->link
->ctrl_lock
, flags
);
1784 cs
= tty
->link
->ctrl_status
;
1785 tty
->link
->ctrl_status
= 0;
1786 spin_unlock_irqrestore(&tty
->link
->ctrl_lock
, flags
);
1787 if (tty_put_user(tty
, cs
, b
++)) {
1795 /* This statement must be first before checking for input
1796 so that any interrupt will set the state back to
1798 set_current_state(TASK_INTERRUPTIBLE
);
1800 if (((minimum
- (b
- buf
)) < tty
->minimum_to_wake
) &&
1801 ((minimum
- (b
- buf
)) >= 1))
1802 tty
->minimum_to_wake
= (minimum
- (b
- buf
));
1804 if (!input_available_p(tty
, 0)) {
1805 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
)) {
1809 if (tty_hung_up_p(file
))
1813 if (file
->f_flags
& O_NONBLOCK
) {
1817 if (signal_pending(current
)) {
1818 retval
= -ERESTARTSYS
;
1821 /* FIXME: does n_tty_set_room need locking ? */
1822 n_tty_set_room(tty
);
1823 timeout
= schedule_timeout(timeout
);
1824 BUG_ON(!tty
->read_buf
);
1827 __set_current_state(TASK_RUNNING
);
1829 /* Deal with packet mode. */
1830 if (packet
&& b
== buf
) {
1831 if (tty_put_user(tty
, TIOCPKT_DATA
, b
++)) {
1839 if (tty
->icanon
&& !L_EXTPROC(tty
)) {
1840 /* N.B. avoid overrun if nr == 0 */
1841 while (nr
&& tty
->read_cnt
) {
1844 eol
= test_and_clear_bit(tty
->read_tail
,
1846 c
= tty
->read_buf
[tty
->read_tail
];
1847 spin_lock_irqsave(&tty
->read_lock
, flags
);
1848 tty
->read_tail
= ((tty
->read_tail
+1) &
1849 (N_TTY_BUF_SIZE
-1));
1852 /* this test should be redundant:
1853 * we shouldn't be reading data if
1856 if (--tty
->canon_data
< 0)
1857 tty
->canon_data
= 0;
1859 spin_unlock_irqrestore(&tty
->read_lock
, flags
);
1861 if (!eol
|| (c
!= __DISABLED_CHAR
)) {
1862 if (tty_put_user(tty
, c
, b
++)) {
1870 tty_audit_push(tty
);
1878 /* The copy function takes the read lock and handles
1879 locking internally for this case */
1880 uncopied
= copy_from_read_buf(tty
, &b
, &nr
);
1881 uncopied
+= copy_from_read_buf(tty
, &b
, &nr
);
1888 /* If there is enough space in the read buffer now, let the
1889 * low-level driver know. We use n_tty_chars_in_buffer() to
1890 * check the buffer, as it now knows about canonical mode.
1891 * Otherwise, if the driver is throttled and the line is
1892 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
1893 * we won't get any more characters.
1895 if (n_tty_chars_in_buffer(tty
) <= TTY_THRESHOLD_UNTHROTTLE
) {
1896 n_tty_set_room(tty
);
1897 check_unthrottle(tty
);
1900 if (b
- buf
>= minimum
)
1905 mutex_unlock(&tty
->atomic_read_lock
);
1906 remove_wait_queue(&tty
->read_wait
, &wait
);
1908 if (!waitqueue_active(&tty
->read_wait
))
1909 tty
->minimum_to_wake
= minimum
;
1911 __set_current_state(TASK_RUNNING
);
1916 clear_bit(TTY_PUSH
, &tty
->flags
);
1917 } else if (test_and_clear_bit(TTY_PUSH
, &tty
->flags
))
1920 n_tty_set_room(tty
);
1925 * n_tty_write - write function for tty
1927 * @file: file object
1928 * @buf: userspace buffer pointer
1931 * Write function of the terminal device. This is serialized with
1932 * respect to other write callers but not to termios changes, reads
1933 * and other such events. Since the receive code will echo characters,
1934 * thus calling driver write methods, the output_lock is used in
1935 * the output processing functions called here as well as in the
1936 * echo processing function to protect the column state and space
1937 * left in the buffer.
1939 * This code must be sure never to sleep through a hangup.
1941 * Locking: output_lock to protect column state and space left
1942 * (note that the process_output*() functions take this
1946 static ssize_t
n_tty_write(struct tty_struct
*tty
, struct file
*file
,
1947 const unsigned char *buf
, size_t nr
)
1949 const unsigned char *b
= buf
;
1950 DECLARE_WAITQUEUE(wait
, current
);
1954 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
1955 if (L_TOSTOP(tty
) && file
->f_op
->write
!= redirected_tty_write
) {
1956 retval
= tty_check_change(tty
);
1961 /* Write out any echoed characters that are still pending */
1962 process_echoes(tty
);
1964 add_wait_queue(&tty
->write_wait
, &wait
);
1966 set_current_state(TASK_INTERRUPTIBLE
);
1967 if (signal_pending(current
)) {
1968 retval
= -ERESTARTSYS
;
1971 if (tty_hung_up_p(file
) || (tty
->link
&& !tty
->link
->count
)) {
1975 if (O_OPOST(tty
) && !(test_bit(TTY_HW_COOK_OUT
, &tty
->flags
))) {
1977 ssize_t num
= process_output_block(tty
, b
, nr
);
1989 if (process_output(c
, tty
) < 0)
1993 if (tty
->ops
->flush_chars
)
1994 tty
->ops
->flush_chars(tty
);
1997 c
= tty
->ops
->write(tty
, b
, nr
);
2010 if (file
->f_flags
& O_NONBLOCK
) {
2017 __set_current_state(TASK_RUNNING
);
2018 remove_wait_queue(&tty
->write_wait
, &wait
);
2019 if (b
- buf
!= nr
&& tty
->fasync
)
2020 set_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
2021 return (b
- buf
) ? b
- buf
: retval
;
2025 * n_tty_poll - poll method for N_TTY
2026 * @tty: terminal device
2027 * @file: file accessing it
2030 * Called when the line discipline is asked to poll() for data or
2031 * for special events. This code is not serialized with respect to
2032 * other events save open/close.
2034 * This code must be sure never to sleep through a hangup.
2035 * Called without the kernel lock held - fine
2038 static unsigned int n_tty_poll(struct tty_struct
*tty
, struct file
*file
,
2041 unsigned int mask
= 0;
2043 poll_wait(file
, &tty
->read_wait
, wait
);
2044 poll_wait(file
, &tty
->write_wait
, wait
);
2045 if (input_available_p(tty
, TIME_CHAR(tty
) ? 0 : MIN_CHAR(tty
)))
2046 mask
|= POLLIN
| POLLRDNORM
;
2047 if (tty
->packet
&& tty
->link
->ctrl_status
)
2048 mask
|= POLLPRI
| POLLIN
| POLLRDNORM
;
2049 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
))
2051 if (tty_hung_up_p(file
))
2053 if (!(mask
& (POLLHUP
| POLLIN
| POLLRDNORM
))) {
2054 if (MIN_CHAR(tty
) && !TIME_CHAR(tty
))
2055 tty
->minimum_to_wake
= MIN_CHAR(tty
);
2057 tty
->minimum_to_wake
= 1;
2059 if (tty
->ops
->write
&& !tty_is_writelocked(tty
) &&
2060 tty_chars_in_buffer(tty
) < WAKEUP_CHARS
&&
2061 tty_write_room(tty
) > 0)
2062 mask
|= POLLOUT
| POLLWRNORM
;
2066 static unsigned long inq_canon(struct tty_struct
*tty
)
2070 if (!tty
->canon_data
)
2072 head
= tty
->canon_head
;
2073 tail
= tty
->read_tail
;
2074 nr
= (head
- tail
) & (N_TTY_BUF_SIZE
-1);
2075 /* Skip EOF-chars.. */
2076 while (head
!= tail
) {
2077 if (test_bit(tail
, tty
->read_flags
) &&
2078 tty
->read_buf
[tail
] == __DISABLED_CHAR
)
2080 tail
= (tail
+1) & (N_TTY_BUF_SIZE
-1);
2085 static int n_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
2086 unsigned int cmd
, unsigned long arg
)
2092 return put_user(tty_chars_in_buffer(tty
), (int __user
*) arg
);
2094 /* FIXME: Locking */
2095 retval
= tty
->read_cnt
;
2097 retval
= inq_canon(tty
);
2098 return put_user(retval
, (unsigned int __user
*) arg
);
2100 return n_tty_ioctl_helper(tty
, file
, cmd
, arg
);
2104 struct tty_ldisc_ops tty_ldisc_N_TTY
= {
2105 .magic
= TTY_LDISC_MAGIC
,
2108 .close
= n_tty_close
,
2109 .flush_buffer
= n_tty_flush_buffer
,
2110 .chars_in_buffer
= n_tty_chars_in_buffer
,
2112 .write
= n_tty_write
,
2113 .ioctl
= n_tty_ioctl
,
2114 .set_termios
= n_tty_set_termios
,
2116 .receive_buf
= n_tty_receive_buf
,
2117 .write_wakeup
= n_tty_write_wakeup
2121 * n_tty_inherit_ops - inherit N_TTY methods
2122 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2124 * Used by a generic struct tty_ldisc_ops to easily inherit N_TTY
2128 void n_tty_inherit_ops(struct tty_ldisc_ops
*ops
)
2130 *ops
= tty_ldisc_N_TTY
;
2132 ops
->refcount
= ops
->flags
= 0;
2134 EXPORT_SYMBOL_GPL(n_tty_inherit_ops
);