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