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