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