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