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
52#include <asm/system.h>
53
54
55#define WAKEUP_CHARS 256
56
57
58
59
60
61
62#define TTY_THRESHOLD_THROTTLE 128
63#define TTY_THRESHOLD_UNTHROTTLE 128
64
65
66
67
68
69
70
71#define ECHO_OP_START 0xff
72#define ECHO_OP_MOVE_BACK_COL 0x80
73#define ECHO_OP_SET_CANON_COL 0x81
74#define ECHO_OP_ERASE_TAB 0x82
75
76static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
77 unsigned char __user *ptr)
78{
79 tty_audit_add_data(tty, &x, 1);
80 return put_user(x, ptr);
81}
82
83
84
85
86
87
88
89
90
91
92
93static void n_tty_set_room(struct tty_struct *tty)
94{
95
96 int left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
97
98
99
100
101
102
103
104 if (left <= 0)
105 left = tty->icanon && !tty->canon_data;
106 tty->receive_room = left;
107}
108
109static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
110{
111 if (tty->read_cnt < N_TTY_BUF_SIZE) {
112 tty->read_buf[tty->read_head] = c;
113 tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
114 tty->read_cnt++;
115 }
116}
117
118
119
120
121
122
123
124
125
126
127
128static void put_tty_queue(unsigned char c, struct tty_struct *tty)
129{
130 unsigned long flags;
131
132
133
134
135 spin_lock_irqsave(&tty->read_lock, flags);
136 put_tty_queue_nolock(c, tty);
137 spin_unlock_irqrestore(&tty->read_lock, flags);
138}
139
140
141
142
143
144
145
146
147
148
149static void check_unthrottle(struct tty_struct *tty)
150{
151 if (tty->count)
152 tty_unthrottle(tty);
153}
154
155
156
157
158
159
160
161
162
163
164
165
166static void reset_buffer_flags(struct tty_struct *tty)
167{
168 unsigned long flags;
169
170 spin_lock_irqsave(&tty->read_lock, flags);
171 tty->read_head = tty->read_tail = tty->read_cnt = 0;
172 spin_unlock_irqrestore(&tty->read_lock, flags);
173
174 mutex_lock(&tty->echo_lock);
175 tty->echo_pos = tty->echo_cnt = tty->echo_overrun = 0;
176 mutex_unlock(&tty->echo_lock);
177
178 tty->canon_head = tty->canon_data = tty->erasing = 0;
179 memset(&tty->read_flags, 0, sizeof tty->read_flags);
180 n_tty_set_room(tty);
181 check_unthrottle(tty);
182}
183
184
185
186
187
188
189
190
191
192
193
194
195
196static void n_tty_flush_buffer(struct tty_struct *tty)
197{
198 unsigned long flags;
199
200 reset_buffer_flags(tty);
201
202 if (!tty->link)
203 return;
204
205 spin_lock_irqsave(&tty->ctrl_lock, flags);
206 if (tty->link->packet) {
207 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
208 wake_up_interruptible(&tty->link->read_wait);
209 }
210 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
211}
212
213
214
215
216
217
218
219
220
221
222
223static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
224{
225 unsigned long flags;
226 ssize_t n = 0;
227
228 spin_lock_irqsave(&tty->read_lock, flags);
229 if (!tty->icanon) {
230 n = tty->read_cnt;
231 } else if (tty->canon_data) {
232 n = (tty->canon_head > tty->read_tail) ?
233 tty->canon_head - tty->read_tail :
234 tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail);
235 }
236 spin_unlock_irqrestore(&tty->read_lock, flags);
237 return n;
238}
239
240
241
242
243
244
245
246
247
248
249static inline int is_utf8_continuation(unsigned char c)
250{
251 return (c & 0xc0) == 0x80;
252}
253
254
255
256
257
258
259
260
261
262static inline int is_continuation(unsigned char c, struct tty_struct *tty)
263{
264 return I_IUTF8(tty) && is_utf8_continuation(c);
265}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
290{
291 int spaces;
292
293 if (!space)
294 return -1;
295
296 switch (c) {
297 case '\n':
298 if (O_ONLRET(tty))
299 tty->column = 0;
300 if (O_ONLCR(tty)) {
301 if (space < 2)
302 return -1;
303 tty->canon_column = tty->column = 0;
304 tty->ops->write(tty, "\r\n", 2);
305 return 2;
306 }
307 tty->canon_column = tty->column;
308 break;
309 case '\r':
310 if (O_ONOCR(tty) && tty->column == 0)
311 return 0;
312 if (O_OCRNL(tty)) {
313 c = '\n';
314 if (O_ONLRET(tty))
315 tty->canon_column = tty->column = 0;
316 break;
317 }
318 tty->canon_column = tty->column = 0;
319 break;
320 case '\t':
321 spaces = 8 - (tty->column & 7);
322 if (O_TABDLY(tty) == XTABS) {
323 if (space < spaces)
324 return -1;
325 tty->column += spaces;
326 tty->ops->write(tty, " ", spaces);
327 return spaces;
328 }
329 tty->column += spaces;
330 break;
331 case '\b':
332 if (tty->column > 0)
333 tty->column--;
334 break;
335 default:
336 if (!iscntrl(c)) {
337 if (O_OLCUC(tty))
338 c = toupper(c);
339 if (!is_continuation(c, tty))
340 tty->column++;
341 }
342 break;
343 }
344
345 tty_put_char(tty, c);
346 return 1;
347}
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363static int process_output(unsigned char c, struct tty_struct *tty)
364{
365 int space, retval;
366
367 mutex_lock(&tty->output_lock);
368
369 space = tty_write_room(tty);
370 retval = do_output_char(c, tty, space);
371
372 mutex_unlock(&tty->output_lock);
373 if (retval < 0)
374 return -1;
375 else
376 return 0;
377}
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398static ssize_t process_output_block(struct tty_struct *tty,
399 const unsigned char *buf, unsigned int nr)
400{
401 int space;
402 int i;
403 const unsigned char *cp;
404
405 mutex_lock(&tty->output_lock);
406
407 space = tty_write_room(tty);
408 if (!space) {
409 mutex_unlock(&tty->output_lock);
410 return 0;
411 }
412 if (nr > space)
413 nr = space;
414
415 for (i = 0, cp = buf; i < nr; i++, cp++) {
416 unsigned char c = *cp;
417
418 switch (c) {
419 case '\n':
420 if (O_ONLRET(tty))
421 tty->column = 0;
422 if (O_ONLCR(tty))
423 goto break_out;
424 tty->canon_column = tty->column;
425 break;
426 case '\r':
427 if (O_ONOCR(tty) && tty->column == 0)
428 goto break_out;
429 if (O_OCRNL(tty))
430 goto break_out;
431 tty->canon_column = tty->column = 0;
432 break;
433 case '\t':
434 goto break_out;
435 case '\b':
436 if (tty->column > 0)
437 tty->column--;
438 break;
439 default:
440 if (!iscntrl(c)) {
441 if (O_OLCUC(tty))
442 goto break_out;
443 if (!is_continuation(c, tty))
444 tty->column++;
445 }
446 break;
447 }
448 }
449break_out:
450 i = tty->ops->write(tty, buf, i);
451
452 mutex_unlock(&tty->output_lock);
453 return i;
454}
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482static void process_echoes(struct tty_struct *tty)
483{
484 int space, nr;
485 unsigned char c;
486 unsigned char *cp, *buf_end;
487
488 if (!tty->echo_cnt)
489 return;
490
491 mutex_lock(&tty->output_lock);
492 mutex_lock(&tty->echo_lock);
493
494 space = tty_write_room(tty);
495
496 buf_end = tty->echo_buf + N_TTY_BUF_SIZE;
497 cp = tty->echo_buf + tty->echo_pos;
498 nr = tty->echo_cnt;
499 while (nr > 0) {
500 c = *cp;
501 if (c == ECHO_OP_START) {
502 unsigned char op;
503 unsigned char *opp;
504 int no_space_left = 0;
505
506
507
508
509
510
511 opp = cp + 1;
512 if (opp == buf_end)
513 opp -= N_TTY_BUF_SIZE;
514 op = *opp;
515
516 switch (op) {
517 unsigned int num_chars, num_bs;
518
519 case ECHO_OP_ERASE_TAB:
520 if (++opp == buf_end)
521 opp -= N_TTY_BUF_SIZE;
522 num_chars = *opp;
523
524
525
526
527
528
529
530
531
532
533
534 if (!(num_chars & 0x80))
535 num_chars += tty->canon_column;
536 num_bs = 8 - (num_chars & 7);
537
538 if (num_bs > space) {
539 no_space_left = 1;
540 break;
541 }
542 space -= num_bs;
543 while (num_bs--) {
544 tty_put_char(tty, '\b');
545 if (tty->column > 0)
546 tty->column--;
547 }
548 cp += 3;
549 nr -= 3;
550 break;
551
552 case ECHO_OP_SET_CANON_COL:
553 tty->canon_column = tty->column;
554 cp += 2;
555 nr -= 2;
556 break;
557
558 case ECHO_OP_MOVE_BACK_COL:
559 if (tty->column > 0)
560 tty->column--;
561 cp += 2;
562 nr -= 2;
563 break;
564
565 case ECHO_OP_START:
566
567 if (!space) {
568 no_space_left = 1;
569 break;
570 }
571 tty_put_char(tty, ECHO_OP_START);
572 tty->column++;
573 space--;
574 cp += 2;
575 nr -= 2;
576 break;
577
578 default:
579
580
581
582
583
584
585
586
587
588 if (space < 2) {
589 no_space_left = 1;
590 break;
591 }
592 tty_put_char(tty, '^');
593 tty_put_char(tty, op ^ 0100);
594 tty->column += 2;
595 space -= 2;
596 cp += 2;
597 nr -= 2;
598 }
599
600 if (no_space_left)
601 break;
602 } else {
603 if (O_OPOST(tty) &&
604 !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
605 int retval = do_output_char(c, tty, space);
606 if (retval < 0)
607 break;
608 space -= retval;
609 } else {
610 if (!space)
611 break;
612 tty_put_char(tty, c);
613 space -= 1;
614 }
615 cp += 1;
616 nr -= 1;
617 }
618
619
620 if (cp >= buf_end)
621 cp -= N_TTY_BUF_SIZE;
622 }
623
624 if (nr == 0) {
625 tty->echo_pos = 0;
626 tty->echo_cnt = 0;
627 tty->echo_overrun = 0;
628 } else {
629 int num_processed = tty->echo_cnt - nr;
630 tty->echo_pos += num_processed;
631 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
632 tty->echo_cnt = nr;
633 if (num_processed > 0)
634 tty->echo_overrun = 0;
635 }
636
637 mutex_unlock(&tty->echo_lock);
638 mutex_unlock(&tty->output_lock);
639
640 if (tty->ops->flush_chars)
641 tty->ops->flush_chars(tty);
642}
643
644
645
646
647
648
649
650
651
652
653
654static void add_echo_byte(unsigned char c, struct tty_struct *tty)
655{
656 int new_byte_pos;
657
658 if (tty->echo_cnt == N_TTY_BUF_SIZE) {
659
660 new_byte_pos = tty->echo_pos;
661
662
663
664
665
666 if (tty->echo_buf[tty->echo_pos] == ECHO_OP_START) {
667 if (tty->echo_buf[(tty->echo_pos + 1) &
668 (N_TTY_BUF_SIZE - 1)] ==
669 ECHO_OP_ERASE_TAB) {
670 tty->echo_pos += 3;
671 tty->echo_cnt -= 2;
672 } else {
673 tty->echo_pos += 2;
674 tty->echo_cnt -= 1;
675 }
676 } else {
677 tty->echo_pos++;
678 }
679 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
680
681 tty->echo_overrun = 1;
682 } else {
683 new_byte_pos = tty->echo_pos + tty->echo_cnt;
684 new_byte_pos &= N_TTY_BUF_SIZE - 1;
685 tty->echo_cnt++;
686 }
687
688 tty->echo_buf[new_byte_pos] = c;
689}
690
691
692
693
694
695
696
697
698
699
700static void echo_move_back_col(struct tty_struct *tty)
701{
702 mutex_lock(&tty->echo_lock);
703
704 add_echo_byte(ECHO_OP_START, tty);
705 add_echo_byte(ECHO_OP_MOVE_BACK_COL, tty);
706
707 mutex_unlock(&tty->echo_lock);
708}
709
710
711
712
713
714
715
716
717
718
719
720static void echo_set_canon_col(struct tty_struct *tty)
721{
722 mutex_lock(&tty->echo_lock);
723
724 add_echo_byte(ECHO_OP_START, tty);
725 add_echo_byte(ECHO_OP_SET_CANON_COL, tty);
726
727 mutex_unlock(&tty->echo_lock);
728}
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747static void echo_erase_tab(unsigned int num_chars, int after_tab,
748 struct tty_struct *tty)
749{
750 mutex_lock(&tty->echo_lock);
751
752 add_echo_byte(ECHO_OP_START, tty);
753 add_echo_byte(ECHO_OP_ERASE_TAB, tty);
754
755
756 num_chars &= 7;
757
758
759 if (after_tab)
760 num_chars |= 0x80;
761
762 add_echo_byte(num_chars, tty);
763
764 mutex_unlock(&tty->echo_lock);
765}
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780static void echo_char_raw(unsigned char c, struct tty_struct *tty)
781{
782 mutex_lock(&tty->echo_lock);
783
784 if (c == ECHO_OP_START) {
785 add_echo_byte(ECHO_OP_START, tty);
786 add_echo_byte(ECHO_OP_START, tty);
787 } else {
788 add_echo_byte(c, tty);
789 }
790
791 mutex_unlock(&tty->echo_lock);
792}
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808static void echo_char(unsigned char c, struct tty_struct *tty)
809{
810 mutex_lock(&tty->echo_lock);
811
812 if (c == ECHO_OP_START) {
813 add_echo_byte(ECHO_OP_START, tty);
814 add_echo_byte(ECHO_OP_START, tty);
815 } else {
816 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
817 add_echo_byte(ECHO_OP_START, tty);
818 add_echo_byte(c, tty);
819 }
820
821 mutex_unlock(&tty->echo_lock);
822}
823
824
825
826
827
828
829static inline void finish_erasing(struct tty_struct *tty)
830{
831 if (tty->erasing) {
832 echo_char_raw('/', tty);
833 tty->erasing = 0;
834 }
835}
836
837
838
839
840
841
842
843
844
845
846
847
848
849static void eraser(unsigned char c, struct tty_struct *tty)
850{
851 enum { ERASE, WERASE, KILL } kill_type;
852 int head, seen_alnums, cnt;
853 unsigned long flags;
854
855
856 if (tty->read_head == tty->canon_head) {
857
858 return;
859 }
860 if (c == ERASE_CHAR(tty))
861 kill_type = ERASE;
862 else if (c == WERASE_CHAR(tty))
863 kill_type = WERASE;
864 else {
865 if (!L_ECHO(tty)) {
866 spin_lock_irqsave(&tty->read_lock, flags);
867 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
868 (N_TTY_BUF_SIZE - 1));
869 tty->read_head = tty->canon_head;
870 spin_unlock_irqrestore(&tty->read_lock, flags);
871 return;
872 }
873 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
874 spin_lock_irqsave(&tty->read_lock, flags);
875 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
876 (N_TTY_BUF_SIZE - 1));
877 tty->read_head = tty->canon_head;
878 spin_unlock_irqrestore(&tty->read_lock, flags);
879 finish_erasing(tty);
880 echo_char(KILL_CHAR(tty), tty);
881
882 if (L_ECHOK(tty))
883 echo_char_raw('\n', tty);
884 return;
885 }
886 kill_type = KILL;
887 }
888
889 seen_alnums = 0;
890
891 while (tty->read_head != tty->canon_head) {
892 head = tty->read_head;
893
894
895 do {
896 head = (head - 1) & (N_TTY_BUF_SIZE-1);
897 c = tty->read_buf[head];
898 } while (is_continuation(c, tty) && head != tty->canon_head);
899
900
901 if (is_continuation(c, tty))
902 break;
903
904 if (kill_type == WERASE) {
905
906 if (isalnum(c) || c == '_')
907 seen_alnums++;
908 else if (seen_alnums)
909 break;
910 }
911 cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1);
912 spin_lock_irqsave(&tty->read_lock, flags);
913 tty->read_head = head;
914 tty->read_cnt -= cnt;
915 spin_unlock_irqrestore(&tty->read_lock, flags);
916 if (L_ECHO(tty)) {
917 if (L_ECHOPRT(tty)) {
918 if (!tty->erasing) {
919 echo_char_raw('\\', tty);
920 tty->erasing = 1;
921 }
922
923 echo_char(c, tty);
924 while (--cnt > 0) {
925 head = (head+1) & (N_TTY_BUF_SIZE-1);
926 echo_char_raw(tty->read_buf[head], tty);
927 echo_move_back_col(tty);
928 }
929 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
930 echo_char(ERASE_CHAR(tty), tty);
931 } else if (c == '\t') {
932 unsigned int num_chars = 0;
933 int after_tab = 0;
934 unsigned long tail = tty->read_head;
935
936
937
938
939
940
941
942
943 while (tail != tty->canon_head) {
944 tail = (tail-1) & (N_TTY_BUF_SIZE-1);
945 c = tty->read_buf[tail];
946 if (c == '\t') {
947 after_tab = 1;
948 break;
949 } else if (iscntrl(c)) {
950 if (L_ECHOCTL(tty))
951 num_chars += 2;
952 } else if (!is_continuation(c, tty)) {
953 num_chars++;
954 }
955 }
956 echo_erase_tab(num_chars, after_tab, tty);
957 } else {
958 if (iscntrl(c) && L_ECHOCTL(tty)) {
959 echo_char_raw('\b', tty);
960 echo_char_raw(' ', tty);
961 echo_char_raw('\b', tty);
962 }
963 if (!iscntrl(c) || L_ECHOCTL(tty)) {
964 echo_char_raw('\b', tty);
965 echo_char_raw(' ', tty);
966 echo_char_raw('\b', tty);
967 }
968 }
969 }
970 if (kill_type == ERASE)
971 break;
972 }
973 if (tty->read_head == tty->canon_head && L_ECHO(tty))
974 finish_erasing(tty);
975}
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991static inline void isig(int sig, struct tty_struct *tty, int flush)
992{
993 if (tty->pgrp)
994 kill_pgrp(tty->pgrp, sig, 1);
995 if (flush || !L_NOFLSH(tty)) {
996 n_tty_flush_buffer(tty);
997 tty_driver_flush_buffer(tty);
998 }
999}
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011static inline void n_tty_receive_break(struct tty_struct *tty)
1012{
1013 if (I_IGNBRK(tty))
1014 return;
1015 if (I_BRKINT(tty)) {
1016 isig(SIGINT, tty, 1);
1017 return;
1018 }
1019 if (I_PARMRK(tty)) {
1020 put_tty_queue('\377', tty);
1021 put_tty_queue('\0', tty);
1022 }
1023 put_tty_queue('\0', tty);
1024 wake_up_interruptible(&tty->read_wait);
1025}
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040static inline void n_tty_receive_overrun(struct tty_struct *tty)
1041{
1042 char buf[64];
1043
1044 tty->num_overrun++;
1045 if (time_before(tty->overrun_time, jiffies - HZ) ||
1046 time_after(tty->overrun_time, jiffies)) {
1047 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1048 tty_name(tty, buf),
1049 tty->num_overrun);
1050 tty->overrun_time = jiffies;
1051 tty->num_overrun = 0;
1052 }
1053}
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063static inline void n_tty_receive_parity_error(struct tty_struct *tty,
1064 unsigned char c)
1065{
1066 if (I_IGNPAR(tty))
1067 return;
1068 if (I_PARMRK(tty)) {
1069 put_tty_queue('\377', tty);
1070 put_tty_queue('\0', tty);
1071 put_tty_queue(c, tty);
1072 } else if (I_INPCK(tty))
1073 put_tty_queue('\0', tty);
1074 else
1075 put_tty_queue(c, tty);
1076 wake_up_interruptible(&tty->read_wait);
1077}
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1090{
1091 unsigned long flags;
1092 int parmrk;
1093
1094 if (tty->raw) {
1095 put_tty_queue(c, tty);
1096 return;
1097 }
1098
1099 if (I_ISTRIP(tty))
1100 c &= 0x7f;
1101 if (I_IUCLC(tty) && L_IEXTEN(tty))
1102 c = tolower(c);
1103
1104 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
1105 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
1106 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
1107 start_tty(tty);
1108 process_echoes(tty);
1109 }
1110
1111 if (tty->closing) {
1112 if (I_IXON(tty)) {
1113 if (c == START_CHAR(tty)) {
1114 start_tty(tty);
1115 process_echoes(tty);
1116 } else if (c == STOP_CHAR(tty))
1117 stop_tty(tty);
1118 }
1119 return;
1120 }
1121
1122
1123
1124
1125
1126
1127
1128 if (!test_bit(c, tty->process_char_map) || tty->lnext) {
1129 tty->lnext = 0;
1130 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1131 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1132
1133 if (L_ECHO(tty))
1134 process_output('\a', tty);
1135 return;
1136 }
1137 if (L_ECHO(tty)) {
1138 finish_erasing(tty);
1139
1140 if (tty->canon_head == tty->read_head)
1141 echo_set_canon_col(tty);
1142 echo_char(c, tty);
1143 process_echoes(tty);
1144 }
1145 if (parmrk)
1146 put_tty_queue(c, tty);
1147 put_tty_queue(c, tty);
1148 return;
1149 }
1150
1151 if (I_IXON(tty)) {
1152 if (c == START_CHAR(tty)) {
1153 start_tty(tty);
1154 process_echoes(tty);
1155 return;
1156 }
1157 if (c == STOP_CHAR(tty)) {
1158 stop_tty(tty);
1159 return;
1160 }
1161 }
1162
1163 if (L_ISIG(tty)) {
1164 int signal;
1165 signal = SIGINT;
1166 if (c == INTR_CHAR(tty))
1167 goto send_signal;
1168 signal = SIGQUIT;
1169 if (c == QUIT_CHAR(tty))
1170 goto send_signal;
1171 signal = SIGTSTP;
1172 if (c == SUSP_CHAR(tty)) {
1173send_signal:
1174
1175
1176
1177
1178
1179 if (!L_NOFLSH(tty)) {
1180 n_tty_flush_buffer(tty);
1181 tty_driver_flush_buffer(tty);
1182 }
1183 if (I_IXON(tty))
1184 start_tty(tty);
1185 if (L_ECHO(tty)) {
1186 echo_char(c, tty);
1187 process_echoes(tty);
1188 }
1189 if (tty->pgrp)
1190 kill_pgrp(tty->pgrp, signal, 1);
1191 return;
1192 }
1193 }
1194
1195 if (c == '\r') {
1196 if (I_IGNCR(tty))
1197 return;
1198 if (I_ICRNL(tty))
1199 c = '\n';
1200 } else if (c == '\n' && I_INLCR(tty))
1201 c = '\r';
1202
1203 if (tty->icanon) {
1204 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1205 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1206 eraser(c, tty);
1207 process_echoes(tty);
1208 return;
1209 }
1210 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1211 tty->lnext = 1;
1212 if (L_ECHO(tty)) {
1213 finish_erasing(tty);
1214 if (L_ECHOCTL(tty)) {
1215 echo_char_raw('^', tty);
1216 echo_char_raw('\b', tty);
1217 process_echoes(tty);
1218 }
1219 }
1220 return;
1221 }
1222 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
1223 L_IEXTEN(tty)) {
1224 unsigned long tail = tty->canon_head;
1225
1226 finish_erasing(tty);
1227 echo_char(c, tty);
1228 echo_char_raw('\n', tty);
1229 while (tail != tty->read_head) {
1230 echo_char(tty->read_buf[tail], tty);
1231 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
1232 }
1233 process_echoes(tty);
1234 return;
1235 }
1236 if (c == '\n') {
1237 if (tty->read_cnt >= N_TTY_BUF_SIZE) {
1238 if (L_ECHO(tty))
1239 process_output('\a', tty);
1240 return;
1241 }
1242 if (L_ECHO(tty) || L_ECHONL(tty)) {
1243 echo_char_raw('\n', tty);
1244 process_echoes(tty);
1245 }
1246 goto handle_newline;
1247 }
1248 if (c == EOF_CHAR(tty)) {
1249 if (tty->read_cnt >= N_TTY_BUF_SIZE)
1250 return;
1251 if (tty->canon_head != tty->read_head)
1252 set_bit(TTY_PUSH, &tty->flags);
1253 c = __DISABLED_CHAR;
1254 goto handle_newline;
1255 }
1256 if ((c == EOL_CHAR(tty)) ||
1257 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1258 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
1259 ? 1 : 0;
1260 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) {
1261 if (L_ECHO(tty))
1262 process_output('\a', tty);
1263 return;
1264 }
1265
1266
1267
1268 if (L_ECHO(tty)) {
1269
1270 if (tty->canon_head == tty->read_head)
1271 echo_set_canon_col(tty);
1272 echo_char(c, tty);
1273 process_echoes(tty);
1274 }
1275
1276
1277
1278
1279 if (parmrk)
1280 put_tty_queue(c, tty);
1281
1282handle_newline:
1283 spin_lock_irqsave(&tty->read_lock, flags);
1284 set_bit(tty->read_head, tty->read_flags);
1285 put_tty_queue_nolock(c, tty);
1286 tty->canon_head = tty->read_head;
1287 tty->canon_data++;
1288 spin_unlock_irqrestore(&tty->read_lock, flags);
1289 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1290 if (waitqueue_active(&tty->read_wait))
1291 wake_up_interruptible(&tty->read_wait);
1292 return;
1293 }
1294 }
1295
1296 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1297 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1298
1299 if (L_ECHO(tty))
1300 process_output('\a', tty);
1301 return;
1302 }
1303 if (L_ECHO(tty)) {
1304 finish_erasing(tty);
1305 if (c == '\n')
1306 echo_char_raw('\n', tty);
1307 else {
1308
1309 if (tty->canon_head == tty->read_head)
1310 echo_set_canon_col(tty);
1311 echo_char(c, tty);
1312 }
1313 process_echoes(tty);
1314 }
1315
1316 if (parmrk)
1317 put_tty_queue(c, tty);
1318
1319 put_tty_queue(c, tty);
1320}
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332static void n_tty_write_wakeup(struct tty_struct *tty)
1333{
1334 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
1335 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
1336}
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1352 char *fp, int count)
1353{
1354 const unsigned char *p;
1355 char *f, flags = TTY_NORMAL;
1356 int i;
1357 char buf[64];
1358 unsigned long cpuflags;
1359
1360 if (!tty->read_buf)
1361 return;
1362
1363 if (tty->real_raw) {
1364 spin_lock_irqsave(&tty->read_lock, cpuflags);
1365 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1366 N_TTY_BUF_SIZE - tty->read_head);
1367 i = min(count, i);
1368 memcpy(tty->read_buf + tty->read_head, cp, i);
1369 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1370 tty->read_cnt += i;
1371 cp += i;
1372 count -= i;
1373
1374 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1375 N_TTY_BUF_SIZE - tty->read_head);
1376 i = min(count, i);
1377 memcpy(tty->read_buf + tty->read_head, cp, i);
1378 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1379 tty->read_cnt += i;
1380 spin_unlock_irqrestore(&tty->read_lock, cpuflags);
1381 } else {
1382 for (i = count, p = cp, f = fp; i; i--, p++) {
1383 if (f)
1384 flags = *f++;
1385 switch (flags) {
1386 case TTY_NORMAL:
1387 n_tty_receive_char(tty, *p);
1388 break;
1389 case TTY_BREAK:
1390 n_tty_receive_break(tty);
1391 break;
1392 case TTY_PARITY:
1393 case TTY_FRAME:
1394 n_tty_receive_parity_error(tty, *p);
1395 break;
1396 case TTY_OVERRUN:
1397 n_tty_receive_overrun(tty);
1398 break;
1399 default:
1400 printk(KERN_ERR "%s: unknown flag %d\n",
1401 tty_name(tty, buf), flags);
1402 break;
1403 }
1404 }
1405 if (tty->ops->flush_chars)
1406 tty->ops->flush_chars(tty);
1407 }
1408
1409 n_tty_set_room(tty);
1410
1411 if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
1412 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1413 if (waitqueue_active(&tty->read_wait))
1414 wake_up_interruptible(&tty->read_wait);
1415 }
1416
1417
1418
1419
1420
1421
1422 if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
1423 tty_throttle(tty);
1424}
1425
1426int is_ignored(int sig)
1427{
1428 return (sigismember(¤t->blocked, sig) ||
1429 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
1430}
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1447{
1448 int canon_change = 1;
1449 BUG_ON(!tty);
1450
1451 if (old)
1452 canon_change = (old->c_lflag ^ tty->termios->c_lflag) & ICANON;
1453 if (canon_change) {
1454 memset(&tty->read_flags, 0, sizeof tty->read_flags);
1455 tty->canon_head = tty->read_tail;
1456 tty->canon_data = 0;
1457 tty->erasing = 0;
1458 }
1459
1460 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
1461 wake_up_interruptible(&tty->read_wait);
1462
1463 tty->icanon = (L_ICANON(tty) != 0);
1464 if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
1465 tty->raw = 1;
1466 tty->real_raw = 1;
1467 n_tty_set_room(tty);
1468 return;
1469 }
1470 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1471 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1472 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1473 I_PARMRK(tty)) {
1474 memset(tty->process_char_map, 0, 256/8);
1475
1476 if (I_IGNCR(tty) || I_ICRNL(tty))
1477 set_bit('\r', tty->process_char_map);
1478 if (I_INLCR(tty))
1479 set_bit('\n', tty->process_char_map);
1480
1481 if (L_ICANON(tty)) {
1482 set_bit(ERASE_CHAR(tty), tty->process_char_map);
1483 set_bit(KILL_CHAR(tty), tty->process_char_map);
1484 set_bit(EOF_CHAR(tty), tty->process_char_map);
1485 set_bit('\n', tty->process_char_map);
1486 set_bit(EOL_CHAR(tty), tty->process_char_map);
1487 if (L_IEXTEN(tty)) {
1488 set_bit(WERASE_CHAR(tty),
1489 tty->process_char_map);
1490 set_bit(LNEXT_CHAR(tty),
1491 tty->process_char_map);
1492 set_bit(EOL2_CHAR(tty),
1493 tty->process_char_map);
1494 if (L_ECHO(tty))
1495 set_bit(REPRINT_CHAR(tty),
1496 tty->process_char_map);
1497 }
1498 }
1499 if (I_IXON(tty)) {
1500 set_bit(START_CHAR(tty), tty->process_char_map);
1501 set_bit(STOP_CHAR(tty), tty->process_char_map);
1502 }
1503 if (L_ISIG(tty)) {
1504 set_bit(INTR_CHAR(tty), tty->process_char_map);
1505 set_bit(QUIT_CHAR(tty), tty->process_char_map);
1506 set_bit(SUSP_CHAR(tty), tty->process_char_map);
1507 }
1508 clear_bit(__DISABLED_CHAR, tty->process_char_map);
1509 tty->raw = 0;
1510 tty->real_raw = 0;
1511 } else {
1512 tty->raw = 1;
1513 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1514 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1515 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1516 tty->real_raw = 1;
1517 else
1518 tty->real_raw = 0;
1519 }
1520 n_tty_set_room(tty);
1521
1522 wake_up_interruptible(&tty->write_wait);
1523 wake_up_interruptible(&tty->read_wait);
1524}
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536static void n_tty_close(struct tty_struct *tty)
1537{
1538 n_tty_flush_buffer(tty);
1539 if (tty->read_buf) {
1540 kfree(tty->read_buf);
1541 tty->read_buf = NULL;
1542 }
1543 if (tty->echo_buf) {
1544 kfree(tty->echo_buf);
1545 tty->echo_buf = NULL;
1546 }
1547}
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559static int n_tty_open(struct tty_struct *tty)
1560{
1561 if (!tty)
1562 return -EINVAL;
1563
1564
1565 if (!tty->read_buf) {
1566 tty->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1567 if (!tty->read_buf)
1568 return -ENOMEM;
1569 }
1570 if (!tty->echo_buf) {
1571 tty->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1572
1573 if (!tty->echo_buf)
1574 return -ENOMEM;
1575 }
1576 reset_buffer_flags(tty);
1577 tty->column = 0;
1578 n_tty_set_termios(tty, NULL);
1579 tty->minimum_to_wake = 1;
1580 tty->closing = 0;
1581 return 0;
1582}
1583
1584static inline int input_available_p(struct tty_struct *tty, int amt)
1585{
1586 tty_flush_to_ldisc(tty);
1587 if (tty->icanon) {
1588 if (tty->canon_data)
1589 return 1;
1590 } else if (tty->read_cnt >= (amt ? amt : 1))
1591 return 1;
1592
1593 return 0;
1594}
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613static int copy_from_read_buf(struct tty_struct *tty,
1614 unsigned char __user **b,
1615 size_t *nr)
1616
1617{
1618 int retval;
1619 size_t n;
1620 unsigned long flags;
1621
1622 retval = 0;
1623 spin_lock_irqsave(&tty->read_lock, flags);
1624 n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail);
1625 n = min(*nr, n);
1626 spin_unlock_irqrestore(&tty->read_lock, flags);
1627 if (n) {
1628 retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);
1629 n -= retval;
1630 tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n);
1631 spin_lock_irqsave(&tty->read_lock, flags);
1632 tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
1633 tty->read_cnt -= n;
1634 spin_unlock_irqrestore(&tty->read_lock, flags);
1635 *b += n;
1636 *nr -= n;
1637 }
1638 return retval;
1639}
1640
1641extern ssize_t redirected_tty_write(struct file *, const char __user *,
1642 size_t, loff_t *);
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659static int job_control(struct tty_struct *tty, struct file *file)
1660{
1661
1662
1663
1664
1665
1666 if (file->f_op->write != redirected_tty_write &&
1667 current->signal->tty == tty) {
1668 if (!tty->pgrp)
1669 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
1670 else if (task_pgrp(current) != tty->pgrp) {
1671 if (is_ignored(SIGTTIN) ||
1672 is_current_pgrp_orphaned())
1673 return -EIO;
1674 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
1675 set_thread_flag(TIF_SIGPENDING);
1676 return -ERESTARTSYS;
1677 }
1678 }
1679 return 0;
1680}
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
1699 unsigned char __user *buf, size_t nr)
1700{
1701 unsigned char __user *b = buf;
1702 DECLARE_WAITQUEUE(wait, current);
1703 int c;
1704 int minimum, time;
1705 ssize_t retval = 0;
1706 ssize_t size;
1707 long timeout;
1708 unsigned long flags;
1709 int packet;
1710
1711do_it_again:
1712
1713 BUG_ON(!tty->read_buf);
1714
1715 c = job_control(tty, file);
1716 if (c < 0)
1717 return c;
1718
1719 minimum = time = 0;
1720 timeout = MAX_SCHEDULE_TIMEOUT;
1721 if (!tty->icanon) {
1722 time = (HZ / 10) * TIME_CHAR(tty);
1723 minimum = MIN_CHAR(tty);
1724 if (minimum) {
1725 if (time)
1726 tty->minimum_to_wake = 1;
1727 else if (!waitqueue_active(&tty->read_wait) ||
1728 (tty->minimum_to_wake > minimum))
1729 tty->minimum_to_wake = minimum;
1730 } else {
1731 timeout = 0;
1732 if (time) {
1733 timeout = time;
1734 time = 0;
1735 }
1736 tty->minimum_to_wake = minimum = 1;
1737 }
1738 }
1739
1740
1741
1742
1743 if (file->f_flags & O_NONBLOCK) {
1744 if (!mutex_trylock(&tty->atomic_read_lock))
1745 return -EAGAIN;
1746 } else {
1747 if (mutex_lock_interruptible(&tty->atomic_read_lock))
1748 return -ERESTARTSYS;
1749 }
1750 packet = tty->packet;
1751
1752 add_wait_queue(&tty->read_wait, &wait);
1753 while (nr) {
1754
1755 if (packet && tty->link->ctrl_status) {
1756 unsigned char cs;
1757 if (b != buf)
1758 break;
1759 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
1760 cs = tty->link->ctrl_status;
1761 tty->link->ctrl_status = 0;
1762 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
1763 if (tty_put_user(tty, cs, b++)) {
1764 retval = -EFAULT;
1765 b--;
1766 break;
1767 }
1768 nr--;
1769 break;
1770 }
1771
1772
1773
1774 set_current_state(TASK_INTERRUPTIBLE);
1775
1776 if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
1777 ((minimum - (b - buf)) >= 1))
1778 tty->minimum_to_wake = (minimum - (b - buf));
1779
1780 if (!input_available_p(tty, 0)) {
1781 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
1782 retval = -EIO;
1783 break;
1784 }
1785 if (tty_hung_up_p(file))
1786 break;
1787 if (!timeout)
1788 break;
1789 if (file->f_flags & O_NONBLOCK) {
1790 retval = -EAGAIN;
1791 break;
1792 }
1793 if (signal_pending(current)) {
1794 retval = -ERESTARTSYS;
1795 break;
1796 }
1797
1798 n_tty_set_room(tty);
1799 timeout = schedule_timeout(timeout);
1800 continue;
1801 }
1802 __set_current_state(TASK_RUNNING);
1803
1804
1805 if (packet && b == buf) {
1806 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
1807 retval = -EFAULT;
1808 b--;
1809 break;
1810 }
1811 nr--;
1812 }
1813
1814 if (tty->icanon) {
1815
1816 while (nr && tty->read_cnt) {
1817 int eol;
1818
1819 eol = test_and_clear_bit(tty->read_tail,
1820 tty->read_flags);
1821 c = tty->read_buf[tty->read_tail];
1822 spin_lock_irqsave(&tty->read_lock, flags);
1823 tty->read_tail = ((tty->read_tail+1) &
1824 (N_TTY_BUF_SIZE-1));
1825 tty->read_cnt--;
1826 if (eol) {
1827
1828
1829
1830
1831 if (--tty->canon_data < 0)
1832 tty->canon_data = 0;
1833 }
1834 spin_unlock_irqrestore(&tty->read_lock, flags);
1835
1836 if (!eol || (c != __DISABLED_CHAR)) {
1837 if (tty_put_user(tty, c, b++)) {
1838 retval = -EFAULT;
1839 b--;
1840 break;
1841 }
1842 nr--;
1843 }
1844 if (eol) {
1845 tty_audit_push(tty);
1846 break;
1847 }
1848 }
1849 if (retval)
1850 break;
1851 } else {
1852 int uncopied;
1853
1854
1855 uncopied = copy_from_read_buf(tty, &b, &nr);
1856 uncopied += copy_from_read_buf(tty, &b, &nr);
1857 if (uncopied) {
1858 retval = -EFAULT;
1859 break;
1860 }
1861 }
1862
1863
1864
1865
1866
1867
1868
1869
1870 if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
1871 n_tty_set_room(tty);
1872 check_unthrottle(tty);
1873 }
1874
1875 if (b - buf >= minimum)
1876 break;
1877 if (time)
1878 timeout = time;
1879 }
1880 mutex_unlock(&tty->atomic_read_lock);
1881 remove_wait_queue(&tty->read_wait, &wait);
1882
1883 if (!waitqueue_active(&tty->read_wait))
1884 tty->minimum_to_wake = minimum;
1885
1886 __set_current_state(TASK_RUNNING);
1887 size = b - buf;
1888 if (size) {
1889 retval = size;
1890 if (nr)
1891 clear_bit(TTY_PUSH, &tty->flags);
1892 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
1893 goto do_it_again;
1894
1895 n_tty_set_room(tty);
1896 return retval;
1897}
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
1922 const unsigned char *buf, size_t nr)
1923{
1924 const unsigned char *b = buf;
1925 DECLARE_WAITQUEUE(wait, current);
1926 int c;
1927 ssize_t retval = 0;
1928
1929
1930 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
1931 retval = tty_check_change(tty);
1932 if (retval)
1933 return retval;
1934 }
1935
1936
1937 process_echoes(tty);
1938
1939 add_wait_queue(&tty->write_wait, &wait);
1940 while (1) {
1941 set_current_state(TASK_INTERRUPTIBLE);
1942 if (signal_pending(current)) {
1943 retval = -ERESTARTSYS;
1944 break;
1945 }
1946 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
1947 retval = -EIO;
1948 break;
1949 }
1950 if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
1951 while (nr > 0) {
1952 ssize_t num = process_output_block(tty, b, nr);
1953 if (num < 0) {
1954 if (num == -EAGAIN)
1955 break;
1956 retval = num;
1957 goto break_out;
1958 }
1959 b += num;
1960 nr -= num;
1961 if (nr == 0)
1962 break;
1963 c = *b;
1964 if (process_output(c, tty) < 0)
1965 break;
1966 b++; nr--;
1967 }
1968 if (tty->ops->flush_chars)
1969 tty->ops->flush_chars(tty);
1970 } else {
1971 while (nr > 0) {
1972 c = tty->ops->write(tty, b, nr);
1973 if (c < 0) {
1974 retval = c;
1975 goto break_out;
1976 }
1977 if (!c)
1978 break;
1979 b += c;
1980 nr -= c;
1981 }
1982 }
1983 if (!nr)
1984 break;
1985 if (file->f_flags & O_NONBLOCK) {
1986 retval = -EAGAIN;
1987 break;
1988 }
1989 schedule();
1990 }
1991break_out:
1992 __set_current_state(TASK_RUNNING);
1993 remove_wait_queue(&tty->write_wait, &wait);
1994 if (b - buf != nr && tty->fasync)
1995 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
1996 return (b - buf) ? b - buf : retval;
1997}
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
2014 poll_table *wait)
2015{
2016 unsigned int mask = 0;
2017
2018 poll_wait(file, &tty->read_wait, wait);
2019 poll_wait(file, &tty->write_wait, wait);
2020 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
2021 mask |= POLLIN | POLLRDNORM;
2022 if (tty->packet && tty->link->ctrl_status)
2023 mask |= POLLPRI | POLLIN | POLLRDNORM;
2024 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2025 mask |= POLLHUP;
2026 if (tty_hung_up_p(file))
2027 mask |= POLLHUP;
2028 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2029 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
2030 tty->minimum_to_wake = MIN_CHAR(tty);
2031 else
2032 tty->minimum_to_wake = 1;
2033 }
2034 if (tty->ops->write && !tty_is_writelocked(tty) &&
2035 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2036 tty_write_room(tty) > 0)
2037 mask |= POLLOUT | POLLWRNORM;
2038 return mask;
2039}
2040
2041static unsigned long inq_canon(struct tty_struct *tty)
2042{
2043 int nr, head, tail;
2044
2045 if (!tty->canon_data)
2046 return 0;
2047 head = tty->canon_head;
2048 tail = tty->read_tail;
2049 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
2050
2051 while (head != tail) {
2052 if (test_bit(tail, tty->read_flags) &&
2053 tty->read_buf[tail] == __DISABLED_CHAR)
2054 nr--;
2055 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
2056 }
2057 return nr;
2058}
2059
2060static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2061 unsigned int cmd, unsigned long arg)
2062{
2063 int retval;
2064
2065 switch (cmd) {
2066 case TIOCOUTQ:
2067 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2068 case TIOCINQ:
2069
2070 retval = tty->read_cnt;
2071 if (L_ICANON(tty))
2072 retval = inq_canon(tty);
2073 return put_user(retval, (unsigned int __user *) arg);
2074 default:
2075 return n_tty_ioctl_helper(tty, file, cmd, arg);
2076 }
2077}
2078
2079struct tty_ldisc_ops tty_ldisc_N_TTY = {
2080 .magic = TTY_LDISC_MAGIC,
2081 .name = "n_tty",
2082 .open = n_tty_open,
2083 .close = n_tty_close,
2084 .flush_buffer = n_tty_flush_buffer,
2085 .chars_in_buffer = n_tty_chars_in_buffer,
2086 .read = n_tty_read,
2087 .write = n_tty_write,
2088 .ioctl = n_tty_ioctl,
2089 .set_termios = n_tty_set_termios,
2090 .poll = n_tty_poll,
2091 .receive_buf = n_tty_receive_buf,
2092 .write_wakeup = n_tty_write_wakeup
2093};
2094