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