1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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
55#define WAKEUP_CHARS 256
56
57
58
59
60
61
62#define TTY_THRESHOLD_THROTTLE 128
63#define TTY_THRESHOLD_UNTHROTTLE 128
64
65
66
67
68
69
70
71#define ECHO_OP_START 0xff
72#define ECHO_OP_MOVE_BACK_COL 0x80
73#define ECHO_OP_SET_CANON_COL 0x81
74#define ECHO_OP_ERASE_TAB 0x82
75
76#define ECHO_COMMIT_WATERMARK 256
77#define ECHO_BLOCK 256
78#define ECHO_DISCARD_WATERMARK N_TTY_BUF_SIZE - (ECHO_BLOCK + 32)
79
80
81#undef N_TTY_TRACE
82#ifdef N_TTY_TRACE
83# define n_tty_trace(f, args...) trace_printk(f, ##args)
84#else
85# define n_tty_trace(f, args...)
86#endif
87
88struct n_tty_data {
89
90 size_t read_head;
91 size_t commit_head;
92 size_t canon_head;
93 size_t echo_head;
94 size_t echo_commit;
95 size_t echo_mark;
96 DECLARE_BITMAP(char_map, 256);
97
98
99 unsigned long overrun_time;
100 int num_overrun;
101
102
103 bool no_room;
104
105
106 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
107 unsigned char push:1;
108
109
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
115 size_t read_tail;
116 size_t line_start;
117
118
119 unsigned int column;
120 unsigned int canon_column;
121 size_t echo_tail;
122
123 struct mutex atomic_read_lock;
124 struct mutex output_lock;
125};
126
127#define MASK(x) ((x) & (N_TTY_BUF_SIZE - 1))
128
129static inline size_t read_cnt(struct n_tty_data *ldata)
130{
131 return ldata->read_head - ldata->read_tail;
132}
133
134static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
135{
136 return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
137}
138
139static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
140{
141 return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
142}
143
144static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
145{
146 smp_rmb();
147 return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
148}
149
150static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i)
151{
152 return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
153}
154
155static int tty_copy_to_user(struct tty_struct *tty, void __user *to,
156 size_t tail, size_t n)
157{
158 struct n_tty_data *ldata = tty->disc_data;
159 size_t size = N_TTY_BUF_SIZE - tail;
160 const void *from = read_buf_addr(ldata, tail);
161 int uncopied;
162
163 if (n > size) {
164 tty_audit_add_data(tty, from, size);
165 uncopied = copy_to_user(to, from, size);
166 if (uncopied)
167 return uncopied;
168 to += size;
169 n -= size;
170 from = ldata->read_buf;
171 }
172
173 tty_audit_add_data(tty, from, n);
174 return copy_to_user(to, from, n);
175}
176
177
178
179
180
181
182
183
184
185
186
187
188
189static void n_tty_kick_worker(struct tty_struct *tty)
190{
191 struct n_tty_data *ldata = tty->disc_data;
192
193
194 if (unlikely(ldata->no_room)) {
195 ldata->no_room = 0;
196
197 WARN_RATELIMIT(tty->port->itty == NULL,
198 "scheduling with invalid itty\n");
199
200
201
202
203 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
204 "scheduling buffer work for halted ldisc\n");
205 tty_buffer_restart_work(tty->port);
206 }
207}
208
209static ssize_t chars_in_buffer(struct tty_struct *tty)
210{
211 struct n_tty_data *ldata = tty->disc_data;
212 ssize_t n = 0;
213
214 if (!ldata->icanon)
215 n = ldata->commit_head - ldata->read_tail;
216 else
217 n = ldata->canon_head - ldata->read_tail;
218 return n;
219}
220
221
222
223
224
225
226
227
228
229
230static void n_tty_write_wakeup(struct tty_struct *tty)
231{
232 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
233 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
234}
235
236static void n_tty_check_throttle(struct tty_struct *tty)
237{
238 struct n_tty_data *ldata = tty->disc_data;
239
240
241
242
243
244
245 if (ldata->icanon && ldata->canon_head == ldata->read_tail)
246 return;
247
248 while (1) {
249 int throttled;
250 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
251 if (N_TTY_BUF_SIZE - read_cnt(ldata) >= TTY_THRESHOLD_THROTTLE)
252 break;
253 throttled = tty_throttle_safe(tty);
254 if (!throttled)
255 break;
256 }
257 __tty_set_flow_change(tty, 0);
258}
259
260static void n_tty_check_unthrottle(struct tty_struct *tty)
261{
262 if (tty->driver->type == TTY_DRIVER_TYPE_PTY) {
263 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
264 return;
265 n_tty_kick_worker(tty);
266 tty_wakeup(tty->link);
267 return;
268 }
269
270
271
272
273
274
275
276
277
278 while (1) {
279 int unthrottled;
280 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
281 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
282 break;
283 n_tty_kick_worker(tty);
284 unthrottled = tty_unthrottle_safe(tty);
285 if (!unthrottled)
286 break;
287 }
288 __tty_set_flow_change(tty, 0);
289}
290
291
292
293
294
295
296
297
298
299
300
301
302static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
303{
304 *read_buf_addr(ldata, ldata->read_head) = c;
305 ldata->read_head++;
306}
307
308
309
310
311
312
313
314
315
316
317
318
319static void reset_buffer_flags(struct n_tty_data *ldata)
320{
321 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
322 ldata->commit_head = 0;
323 ldata->line_start = 0;
324
325 ldata->erasing = 0;
326 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
327 ldata->push = 0;
328}
329
330static void n_tty_packet_mode_flush(struct tty_struct *tty)
331{
332 unsigned long flags;
333
334 if (tty->link->packet) {
335 spin_lock_irqsave(&tty->ctrl_lock, flags);
336 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
337 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
338 wake_up_interruptible(&tty->link->read_wait);
339 }
340}
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356static void n_tty_flush_buffer(struct tty_struct *tty)
357{
358 down_write(&tty->termios_rwsem);
359 reset_buffer_flags(tty->disc_data);
360 n_tty_kick_worker(tty);
361
362 if (tty->link)
363 n_tty_packet_mode_flush(tty);
364 up_write(&tty->termios_rwsem);
365}
366
367
368
369
370
371
372
373
374
375
376static inline int is_utf8_continuation(unsigned char c)
377{
378 return (c & 0xc0) == 0x80;
379}
380
381
382
383
384
385
386
387
388
389static inline int is_continuation(unsigned char c, struct tty_struct *tty)
390{
391 return I_IUTF8(tty) && is_utf8_continuation(c);
392}
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
417{
418 struct n_tty_data *ldata = tty->disc_data;
419 int spaces;
420
421 if (!space)
422 return -1;
423
424 switch (c) {
425 case '\n':
426 if (O_ONLRET(tty))
427 ldata->column = 0;
428 if (O_ONLCR(tty)) {
429 if (space < 2)
430 return -1;
431 ldata->canon_column = ldata->column = 0;
432 tty->ops->write(tty, "\r\n", 2);
433 return 2;
434 }
435 ldata->canon_column = ldata->column;
436 break;
437 case '\r':
438 if (O_ONOCR(tty) && ldata->column == 0)
439 return 0;
440 if (O_OCRNL(tty)) {
441 c = '\n';
442 if (O_ONLRET(tty))
443 ldata->canon_column = ldata->column = 0;
444 break;
445 }
446 ldata->canon_column = ldata->column = 0;
447 break;
448 case '\t':
449 spaces = 8 - (ldata->column & 7);
450 if (O_TABDLY(tty) == XTABS) {
451 if (space < spaces)
452 return -1;
453 ldata->column += spaces;
454 tty->ops->write(tty, " ", spaces);
455 return spaces;
456 }
457 ldata->column += spaces;
458 break;
459 case '\b':
460 if (ldata->column > 0)
461 ldata->column--;
462 break;
463 default:
464 if (!iscntrl(c)) {
465 if (O_OLCUC(tty))
466 c = toupper(c);
467 if (!is_continuation(c, tty))
468 ldata->column++;
469 }
470 break;
471 }
472
473 tty_put_char(tty, c);
474 return 1;
475}
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491static int process_output(unsigned char c, struct tty_struct *tty)
492{
493 struct n_tty_data *ldata = tty->disc_data;
494 int space, retval;
495
496 mutex_lock(&ldata->output_lock);
497
498 space = tty_write_room(tty);
499 retval = do_output_char(c, tty, space);
500
501 mutex_unlock(&ldata->output_lock);
502 if (retval < 0)
503 return -1;
504 else
505 return 0;
506}
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527static ssize_t process_output_block(struct tty_struct *tty,
528 const unsigned char *buf, unsigned int nr)
529{
530 struct n_tty_data *ldata = tty->disc_data;
531 int space;
532 int i;
533 const unsigned char *cp;
534
535 mutex_lock(&ldata->output_lock);
536
537 space = tty_write_room(tty);
538 if (!space) {
539 mutex_unlock(&ldata->output_lock);
540 return 0;
541 }
542 if (nr > space)
543 nr = space;
544
545 for (i = 0, cp = buf; i < nr; i++, cp++) {
546 unsigned char c = *cp;
547
548 switch (c) {
549 case '\n':
550 if (O_ONLRET(tty))
551 ldata->column = 0;
552 if (O_ONLCR(tty))
553 goto break_out;
554 ldata->canon_column = ldata->column;
555 break;
556 case '\r':
557 if (O_ONOCR(tty) && ldata->column == 0)
558 goto break_out;
559 if (O_OCRNL(tty))
560 goto break_out;
561 ldata->canon_column = ldata->column = 0;
562 break;
563 case '\t':
564 goto break_out;
565 case '\b':
566 if (ldata->column > 0)
567 ldata->column--;
568 break;
569 default:
570 if (!iscntrl(c)) {
571 if (O_OLCUC(tty))
572 goto break_out;
573 if (!is_continuation(c, tty))
574 ldata->column++;
575 }
576 break;
577 }
578 }
579break_out:
580 i = tty->ops->write(tty, buf, i);
581
582 mutex_unlock(&ldata->output_lock);
583 return i;
584}
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611static size_t __process_echoes(struct tty_struct *tty)
612{
613 struct n_tty_data *ldata = tty->disc_data;
614 int space, old_space;
615 size_t tail;
616 unsigned char c;
617
618 old_space = space = tty_write_room(tty);
619
620 tail = ldata->echo_tail;
621 while (MASK(ldata->echo_commit) != MASK(tail)) {
622 c = echo_buf(ldata, tail);
623 if (c == ECHO_OP_START) {
624 unsigned char op;
625 int no_space_left = 0;
626
627
628
629
630
631
632 if (MASK(ldata->echo_commit) == MASK(tail + 1))
633 goto not_yet_stored;
634
635
636
637
638
639 op = echo_buf(ldata, tail + 1);
640
641 switch (op) {
642 unsigned int num_chars, num_bs;
643
644 case ECHO_OP_ERASE_TAB:
645 if (MASK(ldata->echo_commit) == MASK(tail + 2))
646 goto not_yet_stored;
647 num_chars = echo_buf(ldata, tail + 2);
648
649
650
651
652
653
654
655
656
657
658
659 if (!(num_chars & 0x80))
660 num_chars += ldata->canon_column;
661 num_bs = 8 - (num_chars & 7);
662
663 if (num_bs > space) {
664 no_space_left = 1;
665 break;
666 }
667 space -= num_bs;
668 while (num_bs--) {
669 tty_put_char(tty, '\b');
670 if (ldata->column > 0)
671 ldata->column--;
672 }
673 tail += 3;
674 break;
675
676 case ECHO_OP_SET_CANON_COL:
677 ldata->canon_column = ldata->column;
678 tail += 2;
679 break;
680
681 case ECHO_OP_MOVE_BACK_COL:
682 if (ldata->column > 0)
683 ldata->column--;
684 tail += 2;
685 break;
686
687 case ECHO_OP_START:
688
689 if (!space) {
690 no_space_left = 1;
691 break;
692 }
693 tty_put_char(tty, ECHO_OP_START);
694 ldata->column++;
695 space--;
696 tail += 2;
697 break;
698
699 default:
700
701
702
703
704
705
706
707
708
709 if (space < 2) {
710 no_space_left = 1;
711 break;
712 }
713 tty_put_char(tty, '^');
714 tty_put_char(tty, op ^ 0100);
715 ldata->column += 2;
716 space -= 2;
717 tail += 2;
718 }
719
720 if (no_space_left)
721 break;
722 } else {
723 if (O_OPOST(tty)) {
724 int retval = do_output_char(c, tty, space);
725 if (retval < 0)
726 break;
727 space -= retval;
728 } else {
729 if (!space)
730 break;
731 tty_put_char(tty, c);
732 space -= 1;
733 }
734 tail += 1;
735 }
736 }
737
738
739
740
741 while (ldata->echo_commit > tail &&
742 ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
743 if (echo_buf(ldata, tail) == ECHO_OP_START) {
744 if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
745 tail += 3;
746 else
747 tail += 2;
748 } else
749 tail++;
750 }
751
752 not_yet_stored:
753 ldata->echo_tail = tail;
754 return old_space - space;
755}
756
757static void commit_echoes(struct tty_struct *tty)
758{
759 struct n_tty_data *ldata = tty->disc_data;
760 size_t nr, old, echoed;
761 size_t head;
762
763 mutex_lock(&ldata->output_lock);
764 head = ldata->echo_head;
765 ldata->echo_mark = head;
766 old = ldata->echo_commit - ldata->echo_tail;
767
768
769
770
771 nr = head - ldata->echo_tail;
772 if (nr < ECHO_COMMIT_WATERMARK ||
773 (nr % ECHO_BLOCK > old % ECHO_BLOCK)) {
774 mutex_unlock(&ldata->output_lock);
775 return;
776 }
777
778 ldata->echo_commit = head;
779 echoed = __process_echoes(tty);
780 mutex_unlock(&ldata->output_lock);
781
782 if (echoed && tty->ops->flush_chars)
783 tty->ops->flush_chars(tty);
784}
785
786static void process_echoes(struct tty_struct *tty)
787{
788 struct n_tty_data *ldata = tty->disc_data;
789 size_t echoed;
790
791 if (ldata->echo_mark == ldata->echo_tail)
792 return;
793
794 mutex_lock(&ldata->output_lock);
795 ldata->echo_commit = ldata->echo_mark;
796 echoed = __process_echoes(tty);
797 mutex_unlock(&ldata->output_lock);
798
799 if (echoed && tty->ops->flush_chars)
800 tty->ops->flush_chars(tty);
801}
802
803
804static void flush_echoes(struct tty_struct *tty)
805{
806 struct n_tty_data *ldata = tty->disc_data;
807
808 if ((!L_ECHO(tty) && !L_ECHONL(tty)) ||
809 ldata->echo_commit == ldata->echo_head)
810 return;
811
812 mutex_lock(&ldata->output_lock);
813 ldata->echo_commit = ldata->echo_head;
814 __process_echoes(tty);
815 mutex_unlock(&ldata->output_lock);
816}
817
818
819
820
821
822
823
824
825
826static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
827{
828 *echo_buf_addr(ldata, ldata->echo_head) = c;
829 smp_wmb();
830 ldata->echo_head++;
831}
832
833
834
835
836
837
838
839
840static void echo_move_back_col(struct n_tty_data *ldata)
841{
842 add_echo_byte(ECHO_OP_START, ldata);
843 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
844}
845
846
847
848
849
850
851
852
853
854static void echo_set_canon_col(struct n_tty_data *ldata)
855{
856 add_echo_byte(ECHO_OP_START, ldata);
857 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
858}
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875static void echo_erase_tab(unsigned int num_chars, int after_tab,
876 struct n_tty_data *ldata)
877{
878 add_echo_byte(ECHO_OP_START, ldata);
879 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
880
881
882 num_chars &= 7;
883
884
885 if (after_tab)
886 num_chars |= 0x80;
887
888 add_echo_byte(num_chars, ldata);
889}
890
891
892
893
894
895
896
897
898
899
900
901
902static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
903{
904 if (c == ECHO_OP_START) {
905 add_echo_byte(ECHO_OP_START, ldata);
906 add_echo_byte(ECHO_OP_START, ldata);
907 } else {
908 add_echo_byte(c, ldata);
909 }
910}
911
912
913
914
915
916
917
918
919
920
921
922
923
924static void echo_char(unsigned char c, struct tty_struct *tty)
925{
926 struct n_tty_data *ldata = tty->disc_data;
927
928 if (c == ECHO_OP_START) {
929 add_echo_byte(ECHO_OP_START, ldata);
930 add_echo_byte(ECHO_OP_START, ldata);
931 } else {
932 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
933 add_echo_byte(ECHO_OP_START, ldata);
934 add_echo_byte(c, ldata);
935 }
936}
937
938
939
940
941
942
943static inline void finish_erasing(struct n_tty_data *ldata)
944{
945 if (ldata->erasing) {
946 echo_char_raw('/', ldata);
947 ldata->erasing = 0;
948 }
949}
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964static void eraser(unsigned char c, struct tty_struct *tty)
965{
966 struct n_tty_data *ldata = tty->disc_data;
967 enum { ERASE, WERASE, KILL } kill_type;
968 size_t head;
969 size_t cnt;
970 int seen_alnums;
971
972 if (ldata->read_head == ldata->canon_head) {
973
974 return;
975 }
976 if (c == ERASE_CHAR(tty))
977 kill_type = ERASE;
978 else if (c == WERASE_CHAR(tty))
979 kill_type = WERASE;
980 else {
981 if (!L_ECHO(tty)) {
982 ldata->read_head = ldata->canon_head;
983 return;
984 }
985 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
986 ldata->read_head = ldata->canon_head;
987 finish_erasing(ldata);
988 echo_char(KILL_CHAR(tty), tty);
989
990 if (L_ECHOK(tty))
991 echo_char_raw('\n', ldata);
992 return;
993 }
994 kill_type = KILL;
995 }
996
997 seen_alnums = 0;
998 while (MASK(ldata->read_head) != MASK(ldata->canon_head)) {
999 head = ldata->read_head;
1000
1001
1002 do {
1003 head--;
1004 c = read_buf(ldata, head);
1005 } while (is_continuation(c, tty) &&
1006 MASK(head) != MASK(ldata->canon_head));
1007
1008
1009 if (is_continuation(c, tty))
1010 break;
1011
1012 if (kill_type == WERASE) {
1013
1014 if (isalnum(c) || c == '_')
1015 seen_alnums++;
1016 else if (seen_alnums)
1017 break;
1018 }
1019 cnt = ldata->read_head - head;
1020 ldata->read_head = head;
1021 if (L_ECHO(tty)) {
1022 if (L_ECHOPRT(tty)) {
1023 if (!ldata->erasing) {
1024 echo_char_raw('\\', ldata);
1025 ldata->erasing = 1;
1026 }
1027
1028 echo_char(c, tty);
1029 while (--cnt > 0) {
1030 head++;
1031 echo_char_raw(read_buf(ldata, head), ldata);
1032 echo_move_back_col(ldata);
1033 }
1034 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1035 echo_char(ERASE_CHAR(tty), tty);
1036 } else if (c == '\t') {
1037 unsigned int num_chars = 0;
1038 int after_tab = 0;
1039 size_t tail = ldata->read_head;
1040
1041
1042
1043
1044
1045
1046
1047
1048 while (MASK(tail) != MASK(ldata->canon_head)) {
1049 tail--;
1050 c = read_buf(ldata, tail);
1051 if (c == '\t') {
1052 after_tab = 1;
1053 break;
1054 } else if (iscntrl(c)) {
1055 if (L_ECHOCTL(tty))
1056 num_chars += 2;
1057 } else if (!is_continuation(c, tty)) {
1058 num_chars++;
1059 }
1060 }
1061 echo_erase_tab(num_chars, after_tab, ldata);
1062 } else {
1063 if (iscntrl(c) && L_ECHOCTL(tty)) {
1064 echo_char_raw('\b', ldata);
1065 echo_char_raw(' ', ldata);
1066 echo_char_raw('\b', ldata);
1067 }
1068 if (!iscntrl(c) || L_ECHOCTL(tty)) {
1069 echo_char_raw('\b', ldata);
1070 echo_char_raw(' ', ldata);
1071 echo_char_raw('\b', ldata);
1072 }
1073 }
1074 }
1075 if (kill_type == ERASE)
1076 break;
1077 }
1078 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
1079 finish_erasing(ldata);
1080}
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097static void __isig(int sig, struct tty_struct *tty)
1098{
1099 struct pid *tty_pgrp = tty_get_pgrp(tty);
1100 if (tty_pgrp) {
1101 kill_pgrp(tty_pgrp, sig, 1);
1102 put_pid(tty_pgrp);
1103 }
1104}
1105
1106static void isig(int sig, struct tty_struct *tty)
1107{
1108 struct n_tty_data *ldata = tty->disc_data;
1109
1110 if (L_NOFLSH(tty)) {
1111
1112 __isig(sig, tty);
1113
1114 } else {
1115 up_read(&tty->termios_rwsem);
1116 down_write(&tty->termios_rwsem);
1117
1118 __isig(sig, tty);
1119
1120
1121 mutex_lock(&ldata->output_lock);
1122 ldata->echo_head = ldata->echo_tail = 0;
1123 ldata->echo_mark = ldata->echo_commit = 0;
1124 mutex_unlock(&ldata->output_lock);
1125
1126
1127 tty_driver_flush_buffer(tty);
1128
1129
1130 reset_buffer_flags(tty->disc_data);
1131
1132
1133 if (tty->link)
1134 n_tty_packet_mode_flush(tty);
1135
1136 up_write(&tty->termios_rwsem);
1137 down_read(&tty->termios_rwsem);
1138 }
1139}
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154static void n_tty_receive_break(struct tty_struct *tty)
1155{
1156 struct n_tty_data *ldata = tty->disc_data;
1157
1158 if (I_IGNBRK(tty))
1159 return;
1160 if (I_BRKINT(tty)) {
1161 isig(SIGINT, tty);
1162 return;
1163 }
1164 if (I_PARMRK(tty)) {
1165 put_tty_queue('\377', ldata);
1166 put_tty_queue('\0', ldata);
1167 }
1168 put_tty_queue('\0', ldata);
1169}
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184static void n_tty_receive_overrun(struct tty_struct *tty)
1185{
1186 struct n_tty_data *ldata = tty->disc_data;
1187
1188 ldata->num_overrun++;
1189 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1190 time_after(ldata->overrun_time, jiffies)) {
1191 tty_warn(tty, "%d input overrun(s)\n", ldata->num_overrun);
1192 ldata->overrun_time = jiffies;
1193 ldata->num_overrun = 0;
1194 }
1195}
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208static void n_tty_receive_parity_error(struct tty_struct *tty, unsigned char c)
1209{
1210 struct n_tty_data *ldata = tty->disc_data;
1211
1212 if (I_INPCK(tty)) {
1213 if (I_IGNPAR(tty))
1214 return;
1215 if (I_PARMRK(tty)) {
1216 put_tty_queue('\377', ldata);
1217 put_tty_queue('\0', ldata);
1218 put_tty_queue(c, ldata);
1219 } else
1220 put_tty_queue('\0', ldata);
1221 } else
1222 put_tty_queue(c, ldata);
1223}
1224
1225static void
1226n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c)
1227{
1228 isig(signal, tty);
1229 if (I_IXON(tty))
1230 start_tty(tty);
1231 if (L_ECHO(tty)) {
1232 echo_char(c, tty);
1233 commit_echoes(tty);
1234 } else
1235 process_echoes(tty);
1236 return;
1237}
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255static int
1256n_tty_receive_char_special(struct tty_struct *tty, unsigned char c)
1257{
1258 struct n_tty_data *ldata = tty->disc_data;
1259
1260 if (I_IXON(tty)) {
1261 if (c == START_CHAR(tty)) {
1262 start_tty(tty);
1263 process_echoes(tty);
1264 return 0;
1265 }
1266 if (c == STOP_CHAR(tty)) {
1267 stop_tty(tty);
1268 return 0;
1269 }
1270 }
1271
1272 if (L_ISIG(tty)) {
1273 if (c == INTR_CHAR(tty)) {
1274 n_tty_receive_signal_char(tty, SIGINT, c);
1275 return 0;
1276 } else if (c == QUIT_CHAR(tty)) {
1277 n_tty_receive_signal_char(tty, SIGQUIT, c);
1278 return 0;
1279 } else if (c == SUSP_CHAR(tty)) {
1280 n_tty_receive_signal_char(tty, SIGTSTP, c);
1281 return 0;
1282 }
1283 }
1284
1285 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1286 start_tty(tty);
1287 process_echoes(tty);
1288 }
1289
1290 if (c == '\r') {
1291 if (I_IGNCR(tty))
1292 return 0;
1293 if (I_ICRNL(tty))
1294 c = '\n';
1295 } else if (c == '\n' && I_INLCR(tty))
1296 c = '\r';
1297
1298 if (ldata->icanon) {
1299 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1300 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1301 eraser(c, tty);
1302 commit_echoes(tty);
1303 return 0;
1304 }
1305 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1306 ldata->lnext = 1;
1307 if (L_ECHO(tty)) {
1308 finish_erasing(ldata);
1309 if (L_ECHOCTL(tty)) {
1310 echo_char_raw('^', ldata);
1311 echo_char_raw('\b', ldata);
1312 commit_echoes(tty);
1313 }
1314 }
1315 return 1;
1316 }
1317 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && L_IEXTEN(tty)) {
1318 size_t tail = ldata->canon_head;
1319
1320 finish_erasing(ldata);
1321 echo_char(c, tty);
1322 echo_char_raw('\n', ldata);
1323 while (MASK(tail) != MASK(ldata->read_head)) {
1324 echo_char(read_buf(ldata, tail), tty);
1325 tail++;
1326 }
1327 commit_echoes(tty);
1328 return 0;
1329 }
1330 if (c == '\n') {
1331 if (L_ECHO(tty) || L_ECHONL(tty)) {
1332 echo_char_raw('\n', ldata);
1333 commit_echoes(tty);
1334 }
1335 goto handle_newline;
1336 }
1337 if (c == EOF_CHAR(tty)) {
1338 c = __DISABLED_CHAR;
1339 goto handle_newline;
1340 }
1341 if ((c == EOL_CHAR(tty)) ||
1342 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1343
1344
1345
1346 if (L_ECHO(tty)) {
1347
1348 if (ldata->canon_head == ldata->read_head)
1349 echo_set_canon_col(ldata);
1350 echo_char(c, tty);
1351 commit_echoes(tty);
1352 }
1353
1354
1355
1356
1357 if (c == (unsigned char) '\377' && I_PARMRK(tty))
1358 put_tty_queue(c, ldata);
1359
1360handle_newline:
1361 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
1362 put_tty_queue(c, ldata);
1363 smp_store_release(&ldata->canon_head, ldata->read_head);
1364 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1365 wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
1366 return 0;
1367 }
1368 }
1369
1370 if (L_ECHO(tty)) {
1371 finish_erasing(ldata);
1372 if (c == '\n')
1373 echo_char_raw('\n', ldata);
1374 else {
1375
1376 if (ldata->canon_head == ldata->read_head)
1377 echo_set_canon_col(ldata);
1378 echo_char(c, tty);
1379 }
1380 commit_echoes(tty);
1381 }
1382
1383
1384 if (c == (unsigned char) '\377' && I_PARMRK(tty))
1385 put_tty_queue(c, ldata);
1386
1387 put_tty_queue(c, ldata);
1388 return 0;
1389}
1390
1391static inline void
1392n_tty_receive_char_inline(struct tty_struct *tty, unsigned char c)
1393{
1394 struct n_tty_data *ldata = tty->disc_data;
1395
1396 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1397 start_tty(tty);
1398 process_echoes(tty);
1399 }
1400 if (L_ECHO(tty)) {
1401 finish_erasing(ldata);
1402
1403 if (ldata->canon_head == ldata->read_head)
1404 echo_set_canon_col(ldata);
1405 echo_char(c, tty);
1406 commit_echoes(tty);
1407 }
1408
1409 if (c == (unsigned char) '\377' && I_PARMRK(tty))
1410 put_tty_queue(c, ldata);
1411 put_tty_queue(c, ldata);
1412}
1413
1414static void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1415{
1416 n_tty_receive_char_inline(tty, c);
1417}
1418
1419static inline void
1420n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c)
1421{
1422 struct n_tty_data *ldata = tty->disc_data;
1423
1424 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1425 start_tty(tty);
1426 process_echoes(tty);
1427 }
1428 if (L_ECHO(tty)) {
1429 finish_erasing(ldata);
1430
1431 if (ldata->canon_head == ldata->read_head)
1432 echo_set_canon_col(ldata);
1433 echo_char(c, tty);
1434 commit_echoes(tty);
1435 }
1436 put_tty_queue(c, ldata);
1437}
1438
1439static void n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c)
1440{
1441 if (I_ISTRIP(tty))
1442 c &= 0x7f;
1443 if (I_IUCLC(tty) && L_IEXTEN(tty))
1444 c = tolower(c);
1445
1446 if (I_IXON(tty)) {
1447 if (c == STOP_CHAR(tty))
1448 stop_tty(tty);
1449 else if (c == START_CHAR(tty) ||
1450 (tty->stopped && !tty->flow_stopped && I_IXANY(tty) &&
1451 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) &&
1452 c != SUSP_CHAR(tty))) {
1453 start_tty(tty);
1454 process_echoes(tty);
1455 }
1456 }
1457}
1458
1459static void
1460n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag)
1461{
1462 switch (flag) {
1463 case TTY_BREAK:
1464 n_tty_receive_break(tty);
1465 break;
1466 case TTY_PARITY:
1467 case TTY_FRAME:
1468 n_tty_receive_parity_error(tty, c);
1469 break;
1470 case TTY_OVERRUN:
1471 n_tty_receive_overrun(tty);
1472 break;
1473 default:
1474 tty_err(tty, "unknown flag %d\n", flag);
1475 break;
1476 }
1477}
1478
1479static void
1480n_tty_receive_char_lnext(struct tty_struct *tty, unsigned char c, char flag)
1481{
1482 struct n_tty_data *ldata = tty->disc_data;
1483
1484 ldata->lnext = 0;
1485 if (likely(flag == TTY_NORMAL)) {
1486 if (I_ISTRIP(tty))
1487 c &= 0x7f;
1488 if (I_IUCLC(tty) && L_IEXTEN(tty))
1489 c = tolower(c);
1490 n_tty_receive_char(tty, c);
1491 } else
1492 n_tty_receive_char_flagged(tty, c, flag);
1493}
1494
1495static void
1496n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp,
1497 char *fp, int count)
1498{
1499 struct n_tty_data *ldata = tty->disc_data;
1500 size_t n, head;
1501
1502 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1503 n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
1504 memcpy(read_buf_addr(ldata, head), cp, n);
1505 ldata->read_head += n;
1506 cp += n;
1507 count -= n;
1508
1509 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1510 n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
1511 memcpy(read_buf_addr(ldata, head), cp, n);
1512 ldata->read_head += n;
1513}
1514
1515static void
1516n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp,
1517 char *fp, int count)
1518{
1519 struct n_tty_data *ldata = tty->disc_data;
1520 char flag = TTY_NORMAL;
1521
1522 while (count--) {
1523 if (fp)
1524 flag = *fp++;
1525 if (likely(flag == TTY_NORMAL))
1526 put_tty_queue(*cp++, ldata);
1527 else
1528 n_tty_receive_char_flagged(tty, *cp++, flag);
1529 }
1530}
1531
1532static void
1533n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp,
1534 char *fp, int count)
1535{
1536 char flag = TTY_NORMAL;
1537
1538 while (count--) {
1539 if (fp)
1540 flag = *fp++;
1541 if (likely(flag == TTY_NORMAL))
1542 n_tty_receive_char_closing(tty, *cp++);
1543 }
1544}
1545
1546static void
1547n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp,
1548 char *fp, int count)
1549{
1550 struct n_tty_data *ldata = tty->disc_data;
1551 char flag = TTY_NORMAL;
1552
1553 while (count--) {
1554 if (fp)
1555 flag = *fp++;
1556 if (likely(flag == TTY_NORMAL)) {
1557 unsigned char c = *cp++;
1558
1559 if (I_ISTRIP(tty))
1560 c &= 0x7f;
1561 if (I_IUCLC(tty) && L_IEXTEN(tty))
1562 c = tolower(c);
1563 if (L_EXTPROC(tty)) {
1564 put_tty_queue(c, ldata);
1565 continue;
1566 }
1567 if (!test_bit(c, ldata->char_map))
1568 n_tty_receive_char_inline(tty, c);
1569 else if (n_tty_receive_char_special(tty, c) && count) {
1570 if (fp)
1571 flag = *fp++;
1572 n_tty_receive_char_lnext(tty, *cp++, flag);
1573 count--;
1574 }
1575 } else
1576 n_tty_receive_char_flagged(tty, *cp++, flag);
1577 }
1578}
1579
1580static void
1581n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp,
1582 char *fp, int count)
1583{
1584 struct n_tty_data *ldata = tty->disc_data;
1585 char flag = TTY_NORMAL;
1586
1587 while (count--) {
1588 if (fp)
1589 flag = *fp++;
1590 if (likely(flag == TTY_NORMAL)) {
1591 unsigned char c = *cp++;
1592
1593 if (!test_bit(c, ldata->char_map))
1594 n_tty_receive_char_fast(tty, c);
1595 else if (n_tty_receive_char_special(tty, c) && count) {
1596 if (fp)
1597 flag = *fp++;
1598 n_tty_receive_char_lnext(tty, *cp++, flag);
1599 count--;
1600 }
1601 } else
1602 n_tty_receive_char_flagged(tty, *cp++, flag);
1603 }
1604}
1605
1606static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1607 char *fp, int count)
1608{
1609 struct n_tty_data *ldata = tty->disc_data;
1610 bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty));
1611
1612 if (ldata->real_raw)
1613 n_tty_receive_buf_real_raw(tty, cp, fp, count);
1614 else if (ldata->raw || (L_EXTPROC(tty) && !preops))
1615 n_tty_receive_buf_raw(tty, cp, fp, count);
1616 else if (tty->closing && !L_EXTPROC(tty))
1617 n_tty_receive_buf_closing(tty, cp, fp, count);
1618 else {
1619 if (ldata->lnext) {
1620 char flag = TTY_NORMAL;
1621
1622 if (fp)
1623 flag = *fp++;
1624 n_tty_receive_char_lnext(tty, *cp++, flag);
1625 count--;
1626 }
1627
1628 if (!preops && !I_PARMRK(tty))
1629 n_tty_receive_buf_fast(tty, cp, fp, count);
1630 else
1631 n_tty_receive_buf_standard(tty, cp, fp, count);
1632
1633 flush_echoes(tty);
1634 if (tty->ops->flush_chars)
1635 tty->ops->flush_chars(tty);
1636 }
1637
1638 if (ldata->icanon && !L_EXTPROC(tty))
1639 return;
1640
1641
1642 smp_store_release(&ldata->commit_head, ldata->read_head);
1643
1644 if (read_cnt(ldata)) {
1645 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1646 wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
1647 }
1648}
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683static int
1684n_tty_receive_buf_common(struct tty_struct *tty, const unsigned char *cp,
1685 char *fp, int count, int flow)
1686{
1687 struct n_tty_data *ldata = tty->disc_data;
1688 int room, n, rcvd = 0, overflow;
1689
1690 down_read(&tty->termios_rwsem);
1691
1692 while (1) {
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706 size_t tail = smp_load_acquire(&ldata->read_tail);
1707
1708 room = N_TTY_BUF_SIZE - (ldata->read_head - tail);
1709 if (I_PARMRK(tty))
1710 room = (room + 2) / 3;
1711 room--;
1712 if (room <= 0) {
1713 overflow = ldata->icanon && ldata->canon_head == tail;
1714 if (overflow && room < 0)
1715 ldata->read_head--;
1716 room = overflow;
1717 ldata->no_room = flow && !room;
1718 } else
1719 overflow = 0;
1720
1721 n = min(count, room);
1722 if (!n)
1723 break;
1724
1725
1726 if (!overflow || !fp || *fp != TTY_PARITY)
1727 __receive_buf(tty, cp, fp, n);
1728
1729 cp += n;
1730 if (fp)
1731 fp += n;
1732 count -= n;
1733 rcvd += n;
1734 }
1735
1736 tty->receive_room = room;
1737
1738
1739 if (tty->driver->type == TTY_DRIVER_TYPE_PTY) {
1740 if (overflow) {
1741 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
1742 tty_unthrottle_safe(tty);
1743 __tty_set_flow_change(tty, 0);
1744 }
1745 } else
1746 n_tty_check_throttle(tty);
1747
1748 up_read(&tty->termios_rwsem);
1749
1750 return rcvd;
1751}
1752
1753static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1754 char *fp, int count)
1755{
1756 n_tty_receive_buf_common(tty, cp, fp, count, 0);
1757}
1758
1759static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1760 char *fp, int count)
1761{
1762 return n_tty_receive_buf_common(tty, cp, fp, count, 1);
1763}
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1780{
1781 struct n_tty_data *ldata = tty->disc_data;
1782
1783 if (!old || (old->c_lflag ^ tty->termios.c_lflag) & (ICANON | EXTPROC)) {
1784 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
1785 ldata->line_start = ldata->read_tail;
1786 if (!L_ICANON(tty) || !read_cnt(ldata)) {
1787 ldata->canon_head = ldata->read_tail;
1788 ldata->push = 0;
1789 } else {
1790 set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1),
1791 ldata->read_flags);
1792 ldata->canon_head = ldata->read_head;
1793 ldata->push = 1;
1794 }
1795 ldata->commit_head = ldata->read_head;
1796 ldata->erasing = 0;
1797 ldata->lnext = 0;
1798 }
1799
1800 ldata->icanon = (L_ICANON(tty) != 0);
1801
1802 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1803 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1804 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1805 I_PARMRK(tty)) {
1806 bitmap_zero(ldata->char_map, 256);
1807
1808 if (I_IGNCR(tty) || I_ICRNL(tty))
1809 set_bit('\r', ldata->char_map);
1810 if (I_INLCR(tty))
1811 set_bit('\n', ldata->char_map);
1812
1813 if (L_ICANON(tty)) {
1814 set_bit(ERASE_CHAR(tty), ldata->char_map);
1815 set_bit(KILL_CHAR(tty), ldata->char_map);
1816 set_bit(EOF_CHAR(tty), ldata->char_map);
1817 set_bit('\n', ldata->char_map);
1818 set_bit(EOL_CHAR(tty), ldata->char_map);
1819 if (L_IEXTEN(tty)) {
1820 set_bit(WERASE_CHAR(tty), ldata->char_map);
1821 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1822 set_bit(EOL2_CHAR(tty), ldata->char_map);
1823 if (L_ECHO(tty))
1824 set_bit(REPRINT_CHAR(tty),
1825 ldata->char_map);
1826 }
1827 }
1828 if (I_IXON(tty)) {
1829 set_bit(START_CHAR(tty), ldata->char_map);
1830 set_bit(STOP_CHAR(tty), ldata->char_map);
1831 }
1832 if (L_ISIG(tty)) {
1833 set_bit(INTR_CHAR(tty), ldata->char_map);
1834 set_bit(QUIT_CHAR(tty), ldata->char_map);
1835 set_bit(SUSP_CHAR(tty), ldata->char_map);
1836 }
1837 clear_bit(__DISABLED_CHAR, ldata->char_map);
1838 ldata->raw = 0;
1839 ldata->real_raw = 0;
1840 } else {
1841 ldata->raw = 1;
1842 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1843 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1844 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1845 ldata->real_raw = 1;
1846 else
1847 ldata->real_raw = 0;
1848 }
1849
1850
1851
1852
1853 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
1854 start_tty(tty);
1855 process_echoes(tty);
1856 }
1857
1858
1859 wake_up_interruptible(&tty->write_wait);
1860 wake_up_interruptible(&tty->read_wait);
1861}
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873static void n_tty_close(struct tty_struct *tty)
1874{
1875 struct n_tty_data *ldata = tty->disc_data;
1876
1877 if (tty->link)
1878 n_tty_packet_mode_flush(tty);
1879
1880 vfree(ldata);
1881 tty->disc_data = NULL;
1882}
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894static int n_tty_open(struct tty_struct *tty)
1895{
1896 struct n_tty_data *ldata;
1897
1898
1899 ldata = vzalloc(sizeof(*ldata));
1900 if (!ldata)
1901 return -ENOMEM;
1902
1903 ldata->overrun_time = jiffies;
1904 mutex_init(&ldata->atomic_read_lock);
1905 mutex_init(&ldata->output_lock);
1906
1907 tty->disc_data = ldata;
1908 tty->closing = 0;
1909
1910 clear_bit(TTY_LDISC_HALTED, &tty->flags);
1911 n_tty_set_termios(tty, NULL);
1912 tty_unthrottle(tty);
1913 return 0;
1914}
1915
1916static inline int input_available_p(struct tty_struct *tty, int poll)
1917{
1918 struct n_tty_data *ldata = tty->disc_data;
1919 int amt = poll && !TIME_CHAR(tty) && MIN_CHAR(tty) ? MIN_CHAR(tty) : 1;
1920
1921 if (ldata->icanon && !L_EXTPROC(tty))
1922 return ldata->canon_head != ldata->read_tail;
1923 else
1924 return ldata->commit_head - ldata->read_tail >= amt;
1925}
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947static int copy_from_read_buf(struct tty_struct *tty,
1948 unsigned char __user **b,
1949 size_t *nr)
1950
1951{
1952 struct n_tty_data *ldata = tty->disc_data;
1953 int retval;
1954 size_t n;
1955 bool is_eof;
1956 size_t head = smp_load_acquire(&ldata->commit_head);
1957 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
1958
1959 retval = 0;
1960 n = min(head - ldata->read_tail, N_TTY_BUF_SIZE - tail);
1961 n = min(*nr, n);
1962 if (n) {
1963 const unsigned char *from = read_buf_addr(ldata, tail);
1964 retval = copy_to_user(*b, from, n);
1965 n -= retval;
1966 is_eof = n == 1 && *from == EOF_CHAR(tty);
1967 tty_audit_add_data(tty, from, n);
1968 smp_store_release(&ldata->read_tail, ldata->read_tail + n);
1969
1970 if (L_EXTPROC(tty) && ldata->icanon && is_eof &&
1971 (head == ldata->read_tail))
1972 n = 0;
1973 *b += n;
1974 *nr -= n;
1975 }
1976 return retval;
1977}
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002static int canon_copy_from_read_buf(struct tty_struct *tty,
2003 unsigned char __user **b,
2004 size_t *nr)
2005{
2006 struct n_tty_data *ldata = tty->disc_data;
2007 size_t n, size, more, c;
2008 size_t eol;
2009 size_t tail;
2010 int ret, found = 0;
2011
2012
2013 if (!*nr)
2014 return 0;
2015
2016 n = min(*nr + 1, smp_load_acquire(&ldata->canon_head) - ldata->read_tail);
2017
2018 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
2019 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
2020
2021 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
2022 __func__, *nr, tail, n, size);
2023
2024 eol = find_next_bit(ldata->read_flags, size, tail);
2025 more = n - (size - tail);
2026 if (eol == N_TTY_BUF_SIZE && more) {
2027
2028 eol = find_next_bit(ldata->read_flags, more, 0);
2029 found = eol != more;
2030 } else
2031 found = eol != size;
2032
2033 n = eol - tail;
2034 if (n > N_TTY_BUF_SIZE)
2035 n += N_TTY_BUF_SIZE;
2036 c = n + found;
2037
2038 if (!found || read_buf(ldata, eol) != __DISABLED_CHAR) {
2039 c = min(*nr, c);
2040 n = c;
2041 }
2042
2043 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu tail:%zu more:%zu\n",
2044 __func__, eol, found, n, c, tail, more);
2045
2046 ret = tty_copy_to_user(tty, *b, tail, n);
2047 if (ret)
2048 return -EFAULT;
2049 *b += n;
2050 *nr -= n;
2051
2052 if (found)
2053 clear_bit(eol, ldata->read_flags);
2054 smp_store_release(&ldata->read_tail, ldata->read_tail + c);
2055
2056 if (found) {
2057 if (!ldata->push)
2058 ldata->line_start = ldata->read_tail;
2059 else
2060 ldata->push = 0;
2061 tty_audit_push();
2062 }
2063 return 0;
2064}
2065
2066extern ssize_t redirected_tty_write(struct file *, const char __user *,
2067 size_t, loff_t *);
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083static int job_control(struct tty_struct *tty, struct file *file)
2084{
2085
2086
2087
2088
2089
2090 if (file->f_op->write == redirected_tty_write)
2091 return 0;
2092
2093 return __tty_check_change(tty, SIGTTIN);
2094}
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
2117 unsigned char __user *buf, size_t nr)
2118{
2119 struct n_tty_data *ldata = tty->disc_data;
2120 unsigned char __user *b = buf;
2121 DEFINE_WAIT_FUNC(wait, woken_wake_function);
2122 int c;
2123 int minimum, time;
2124 ssize_t retval = 0;
2125 long timeout;
2126 int packet;
2127 size_t tail;
2128
2129 c = job_control(tty, file);
2130 if (c < 0)
2131 return c;
2132
2133
2134
2135
2136 if (file->f_flags & O_NONBLOCK) {
2137 if (!mutex_trylock(&ldata->atomic_read_lock))
2138 return -EAGAIN;
2139 } else {
2140 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
2141 return -ERESTARTSYS;
2142 }
2143
2144 down_read(&tty->termios_rwsem);
2145
2146 minimum = time = 0;
2147 timeout = MAX_SCHEDULE_TIMEOUT;
2148 if (!ldata->icanon) {
2149 minimum = MIN_CHAR(tty);
2150 if (minimum) {
2151 time = (HZ / 10) * TIME_CHAR(tty);
2152 } else {
2153 timeout = (HZ / 10) * TIME_CHAR(tty);
2154 minimum = 1;
2155 }
2156 }
2157
2158 packet = tty->packet;
2159 tail = ldata->read_tail;
2160
2161 add_wait_queue(&tty->read_wait, &wait);
2162 while (nr) {
2163
2164 if (packet && tty->link->ctrl_status) {
2165 unsigned char cs;
2166 if (b != buf)
2167 break;
2168 spin_lock_irq(&tty->link->ctrl_lock);
2169 cs = tty->link->ctrl_status;
2170 tty->link->ctrl_status = 0;
2171 spin_unlock_irq(&tty->link->ctrl_lock);
2172 if (put_user(cs, b)) {
2173 retval = -EFAULT;
2174 break;
2175 }
2176 b++;
2177 nr--;
2178 break;
2179 }
2180
2181 if (!input_available_p(tty, 0)) {
2182 up_read(&tty->termios_rwsem);
2183 tty_buffer_flush_work(tty->port);
2184 down_read(&tty->termios_rwsem);
2185 if (!input_available_p(tty, 0)) {
2186 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
2187 retval = -EIO;
2188 break;
2189 }
2190 if (tty_hung_up_p(file))
2191 break;
2192
2193
2194
2195
2196 if (test_bit(TTY_HUPPING, &tty->flags))
2197 break;
2198 if (!timeout)
2199 break;
2200 if (file->f_flags & O_NONBLOCK) {
2201 retval = -EAGAIN;
2202 break;
2203 }
2204 if (signal_pending(current)) {
2205 retval = -ERESTARTSYS;
2206 break;
2207 }
2208 up_read(&tty->termios_rwsem);
2209
2210 timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
2211 timeout);
2212
2213 down_read(&tty->termios_rwsem);
2214 continue;
2215 }
2216 }
2217
2218 if (ldata->icanon && !L_EXTPROC(tty)) {
2219 retval = canon_copy_from_read_buf(tty, &b, &nr);
2220 if (retval)
2221 break;
2222 } else {
2223 int uncopied;
2224
2225
2226 if (packet && b == buf) {
2227 if (put_user(TIOCPKT_DATA, b)) {
2228 retval = -EFAULT;
2229 break;
2230 }
2231 b++;
2232 nr--;
2233 }
2234
2235 uncopied = copy_from_read_buf(tty, &b, &nr);
2236 uncopied += copy_from_read_buf(tty, &b, &nr);
2237 if (uncopied) {
2238 retval = -EFAULT;
2239 break;
2240 }
2241 }
2242
2243 n_tty_check_unthrottle(tty);
2244
2245 if (b - buf >= minimum)
2246 break;
2247 if (time)
2248 timeout = time;
2249 }
2250 if (tail != ldata->read_tail)
2251 n_tty_kick_worker(tty);
2252 up_read(&tty->termios_rwsem);
2253
2254 remove_wait_queue(&tty->read_wait, &wait);
2255 mutex_unlock(&ldata->atomic_read_lock);
2256
2257 if (b - buf)
2258 retval = b - buf;
2259
2260 return retval;
2261}
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
2286 const unsigned char *buf, size_t nr)
2287{
2288 const unsigned char *b = buf;
2289 DEFINE_WAIT_FUNC(wait, woken_wake_function);
2290 int c;
2291 ssize_t retval = 0;
2292
2293
2294 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2295 retval = tty_check_change(tty);
2296 if (retval)
2297 return retval;
2298 }
2299
2300 down_read(&tty->termios_rwsem);
2301
2302
2303 process_echoes(tty);
2304
2305 add_wait_queue(&tty->write_wait, &wait);
2306 while (1) {
2307 if (signal_pending(current)) {
2308 retval = -ERESTARTSYS;
2309 break;
2310 }
2311 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2312 retval = -EIO;
2313 break;
2314 }
2315 if (O_OPOST(tty)) {
2316 while (nr > 0) {
2317 ssize_t num = process_output_block(tty, b, nr);
2318 if (num < 0) {
2319 if (num == -EAGAIN)
2320 break;
2321 retval = num;
2322 goto break_out;
2323 }
2324 b += num;
2325 nr -= num;
2326 if (nr == 0)
2327 break;
2328 c = *b;
2329 if (process_output(c, tty) < 0)
2330 break;
2331 b++; nr--;
2332 }
2333 if (tty->ops->flush_chars)
2334 tty->ops->flush_chars(tty);
2335 } else {
2336 struct n_tty_data *ldata = tty->disc_data;
2337
2338 while (nr > 0) {
2339 mutex_lock(&ldata->output_lock);
2340 c = tty->ops->write(tty, b, nr);
2341 mutex_unlock(&ldata->output_lock);
2342 if (c < 0) {
2343 retval = c;
2344 goto break_out;
2345 }
2346 if (!c)
2347 break;
2348 b += c;
2349 nr -= c;
2350 }
2351 }
2352 if (!nr)
2353 break;
2354 if (file->f_flags & O_NONBLOCK) {
2355 retval = -EAGAIN;
2356 break;
2357 }
2358 up_read(&tty->termios_rwsem);
2359
2360 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
2361
2362 down_read(&tty->termios_rwsem);
2363 }
2364break_out:
2365 remove_wait_queue(&tty->write_wait, &wait);
2366 if (nr && tty->fasync)
2367 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2368 up_read(&tty->termios_rwsem);
2369 return (b - buf) ? b - buf : retval;
2370}
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386static __poll_t n_tty_poll(struct tty_struct *tty, struct file *file,
2387 poll_table *wait)
2388{
2389 __poll_t mask = 0;
2390
2391 poll_wait(file, &tty->read_wait, wait);
2392 poll_wait(file, &tty->write_wait, wait);
2393 if (input_available_p(tty, 1))
2394 mask |= EPOLLIN | EPOLLRDNORM;
2395 else {
2396 tty_buffer_flush_work(tty->port);
2397 if (input_available_p(tty, 1))
2398 mask |= EPOLLIN | EPOLLRDNORM;
2399 }
2400 if (tty->packet && tty->link->ctrl_status)
2401 mask |= EPOLLPRI | EPOLLIN | EPOLLRDNORM;
2402 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2403 mask |= EPOLLHUP;
2404 if (tty_hung_up_p(file))
2405 mask |= EPOLLHUP;
2406 if (tty->ops->write && !tty_is_writelocked(tty) &&
2407 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2408 tty_write_room(tty) > 0)
2409 mask |= EPOLLOUT | EPOLLWRNORM;
2410 return mask;
2411}
2412
2413static unsigned long inq_canon(struct n_tty_data *ldata)
2414{
2415 size_t nr, head, tail;
2416
2417 if (ldata->canon_head == ldata->read_tail)
2418 return 0;
2419 head = ldata->canon_head;
2420 tail = ldata->read_tail;
2421 nr = head - tail;
2422
2423 while (MASK(head) != MASK(tail)) {
2424 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2425 read_buf(ldata, tail) == __DISABLED_CHAR)
2426 nr--;
2427 tail++;
2428 }
2429 return nr;
2430}
2431
2432static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2433 unsigned int cmd, unsigned long arg)
2434{
2435 struct n_tty_data *ldata = tty->disc_data;
2436 int retval;
2437
2438 switch (cmd) {
2439 case TIOCOUTQ:
2440 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2441 case TIOCINQ:
2442 down_write(&tty->termios_rwsem);
2443 if (L_ICANON(tty) && !L_EXTPROC(tty))
2444 retval = inq_canon(ldata);
2445 else
2446 retval = read_cnt(ldata);
2447 up_write(&tty->termios_rwsem);
2448 return put_user(retval, (unsigned int __user *) arg);
2449 default:
2450 return n_tty_ioctl_helper(tty, file, cmd, arg);
2451 }
2452}
2453
2454static struct tty_ldisc_ops n_tty_ops = {
2455 .magic = TTY_LDISC_MAGIC,
2456 .name = "n_tty",
2457 .open = n_tty_open,
2458 .close = n_tty_close,
2459 .flush_buffer = n_tty_flush_buffer,
2460 .read = n_tty_read,
2461 .write = n_tty_write,
2462 .ioctl = n_tty_ioctl,
2463 .set_termios = n_tty_set_termios,
2464 .poll = n_tty_poll,
2465 .receive_buf = n_tty_receive_buf,
2466 .write_wakeup = n_tty_write_wakeup,
2467 .receive_buf2 = n_tty_receive_buf2,
2468};
2469
2470
2471
2472
2473
2474
2475
2476
2477void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2478{
2479 *ops = n_tty_ops;
2480 ops->owner = NULL;
2481 ops->refcount = ops->flags = 0;
2482}
2483EXPORT_SYMBOL_GPL(n_tty_inherit_ops);
2484
2485void __init n_tty_init(void)
2486{
2487 tty_register_ldisc(N_TTY, &n_tty_ops);
2488}
2489