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