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