1#include <linux/types.h>
2#include <linux/major.h>
3#include <linux/errno.h>
4#include <linux/signal.h>
5#include <linux/fcntl.h>
6#include <linux/sched.h>
7#include <linux/interrupt.h>
8#include <linux/tty.h>
9#include <linux/tty_driver.h>
10#include <linux/tty_flip.h>
11#include <linux/devpts_fs.h>
12#include <linux/file.h>
13#include <linux/console.h>
14#include <linux/timer.h>
15#include <linux/ctype.h>
16#include <linux/kd.h>
17#include <linux/mm.h>
18#include <linux/string.h>
19#include <linux/slab.h>
20#include <linux/poll.h>
21#include <linux/proc_fs.h>
22#include <linux/init.h>
23#include <linux/module.h>
24#include <linux/device.h>
25#include <linux/wait.h>
26#include <linux/bitops.h>
27#include <linux/delay.h>
28#include <linux/seq_file.h>
29
30#include <linux/uaccess.h>
31#include <asm/system.h>
32
33#include <linux/kbd_kern.h>
34#include <linux/vt_kern.h>
35#include <linux/selection.h>
36
37#include <linux/smp_lock.h>
38
39#include <linux/kmod.h>
40#include <linux/nsproxy.h>
41
42
43
44
45
46
47
48static DEFINE_SPINLOCK(tty_ldisc_lock);
49static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
50static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_idle);
51
52static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
53
54static inline struct tty_ldisc *get_ldisc(struct tty_ldisc *ld)
55{
56 if (ld)
57 atomic_inc(&ld->users);
58 return ld;
59}
60
61static void put_ldisc(struct tty_ldisc *ld)
62{
63 unsigned long flags;
64
65 if (WARN_ON_ONCE(!ld))
66 return;
67
68
69
70
71
72
73
74
75 local_irq_save(flags);
76 if (atomic_dec_and_lock(&ld->users, &tty_ldisc_lock)) {
77 struct tty_ldisc_ops *ldo = ld->ops;
78
79 ldo->refcount--;
80 module_put(ldo->owner);
81 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
82
83 kfree(ld);
84 return;
85 }
86 local_irq_restore(flags);
87 wake_up(&tty_ldisc_idle);
88}
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
104{
105 unsigned long flags;
106 int ret = 0;
107
108 if (disc < N_TTY || disc >= NR_LDISCS)
109 return -EINVAL;
110
111 spin_lock_irqsave(&tty_ldisc_lock, flags);
112 tty_ldiscs[disc] = new_ldisc;
113 new_ldisc->num = disc;
114 new_ldisc->refcount = 0;
115 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
116
117 return ret;
118}
119EXPORT_SYMBOL(tty_register_ldisc);
120
121
122
123
124
125
126
127
128
129
130
131
132
133int tty_unregister_ldisc(int disc)
134{
135 unsigned long flags;
136 int ret = 0;
137
138 if (disc < N_TTY || disc >= NR_LDISCS)
139 return -EINVAL;
140
141 spin_lock_irqsave(&tty_ldisc_lock, flags);
142 if (tty_ldiscs[disc]->refcount)
143 ret = -EBUSY;
144 else
145 tty_ldiscs[disc] = NULL;
146 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
147
148 return ret;
149}
150EXPORT_SYMBOL(tty_unregister_ldisc);
151
152static struct tty_ldisc_ops *get_ldops(int disc)
153{
154 unsigned long flags;
155 struct tty_ldisc_ops *ldops, *ret;
156
157 spin_lock_irqsave(&tty_ldisc_lock, flags);
158 ret = ERR_PTR(-EINVAL);
159 ldops = tty_ldiscs[disc];
160 if (ldops) {
161 ret = ERR_PTR(-EAGAIN);
162 if (try_module_get(ldops->owner)) {
163 ldops->refcount++;
164 ret = ldops;
165 }
166 }
167 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
168 return ret;
169}
170
171static void put_ldops(struct tty_ldisc_ops *ldops)
172{
173 unsigned long flags;
174
175 spin_lock_irqsave(&tty_ldisc_lock, flags);
176 ldops->refcount--;
177 module_put(ldops->owner);
178 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
179}
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194static struct tty_ldisc *tty_ldisc_get(int disc)
195{
196 struct tty_ldisc *ld;
197 struct tty_ldisc_ops *ldops;
198
199 if (disc < N_TTY || disc >= NR_LDISCS)
200 return ERR_PTR(-EINVAL);
201
202
203
204
205
206 ldops = get_ldops(disc);
207 if (IS_ERR(ldops)) {
208 request_module("tty-ldisc-%d", disc);
209 ldops = get_ldops(disc);
210 if (IS_ERR(ldops))
211 return ERR_CAST(ldops);
212 }
213
214 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
215 if (ld == NULL) {
216 put_ldops(ldops);
217 return ERR_PTR(-ENOMEM);
218 }
219
220 ld->ops = ldops;
221 atomic_set(&ld->users, 1);
222 return ld;
223}
224
225static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
226{
227 return (*pos < NR_LDISCS) ? pos : NULL;
228}
229
230static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
231{
232 (*pos)++;
233 return (*pos < NR_LDISCS) ? pos : NULL;
234}
235
236static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
237{
238}
239
240static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
241{
242 int i = *(loff_t *)v;
243 struct tty_ldisc_ops *ldops;
244
245 ldops = get_ldops(i);
246 if (IS_ERR(ldops))
247 return 0;
248 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
249 put_ldops(ldops);
250 return 0;
251}
252
253static const struct seq_operations tty_ldiscs_seq_ops = {
254 .start = tty_ldiscs_seq_start,
255 .next = tty_ldiscs_seq_next,
256 .stop = tty_ldiscs_seq_stop,
257 .show = tty_ldiscs_seq_show,
258};
259
260static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
261{
262 return seq_open(file, &tty_ldiscs_seq_ops);
263}
264
265const struct file_operations tty_ldiscs_proc_fops = {
266 .owner = THIS_MODULE,
267 .open = proc_tty_ldiscs_open,
268 .read = seq_read,
269 .llseek = seq_lseek,
270 .release = seq_release,
271};
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
287{
288 tty->ldisc = ld;
289}
290
291
292
293
294
295
296
297
298
299
300
301
302
303static struct tty_ldisc *tty_ldisc_try(struct tty_struct *tty)
304{
305 unsigned long flags;
306 struct tty_ldisc *ld;
307
308 spin_lock_irqsave(&tty_ldisc_lock, flags);
309 ld = NULL;
310 if (test_bit(TTY_LDISC, &tty->flags))
311 ld = get_ldisc(tty->ldisc);
312 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
313 return ld;
314}
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
333{
334 struct tty_ldisc *ld;
335
336
337 wait_event(tty_ldisc_wait, (ld = tty_ldisc_try(tty)) != NULL);
338 return ld;
339}
340EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
341
342
343
344
345
346
347
348
349
350
351
352
353struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
354{
355 return tty_ldisc_try(tty);
356}
357EXPORT_SYMBOL_GPL(tty_ldisc_ref);
358
359
360
361
362
363
364
365
366
367
368
369void tty_ldisc_deref(struct tty_ldisc *ld)
370{
371 put_ldisc(ld);
372}
373EXPORT_SYMBOL_GPL(tty_ldisc_deref);
374
375static inline void tty_ldisc_put(struct tty_ldisc *ld)
376{
377 put_ldisc(ld);
378}
379
380
381
382
383
384
385
386
387
388
389
390
391
392void tty_ldisc_enable(struct tty_struct *tty)
393{
394 set_bit(TTY_LDISC, &tty->flags);
395 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
396 wake_up(&tty_ldisc_wait);
397}
398
399
400
401
402
403
404
405
406
407void tty_ldisc_flush(struct tty_struct *tty)
408{
409 struct tty_ldisc *ld = tty_ldisc_ref(tty);
410 if (ld) {
411 if (ld->ops->flush_buffer)
412 ld->ops->flush_buffer(tty);
413 tty_ldisc_deref(ld);
414 }
415 tty_buffer_flush(tty);
416}
417EXPORT_SYMBOL_GPL(tty_ldisc_flush);
418
419
420
421
422
423
424
425
426
427
428
429
430
431static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
432{
433 mutex_lock(&tty->termios_mutex);
434 tty->termios->c_line = num;
435 mutex_unlock(&tty->termios_mutex);
436}
437
438
439
440
441
442
443
444
445
446
447
448
449static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
450{
451 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
452 if (ld->ops->open) {
453 int ret;
454
455 WARN_ON(!tty_locked());
456 ret = ld->ops->open(tty);
457 if (ret)
458 clear_bit(TTY_LDISC_OPEN, &tty->flags);
459 return ret;
460 }
461 return 0;
462}
463
464
465
466
467
468
469
470
471
472
473static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
474{
475 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
476 clear_bit(TTY_LDISC_OPEN, &tty->flags);
477 if (ld->ops->close)
478 ld->ops->close(tty);
479}
480
481
482
483
484
485
486
487
488
489
490static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
491{
492 char buf[64];
493 struct tty_ldisc *new_ldisc;
494 int r;
495
496
497 old = tty_ldisc_get(old->ops->num);
498 WARN_ON(IS_ERR(old));
499 tty_ldisc_assign(tty, old);
500 tty_set_termios_ldisc(tty, old->ops->num);
501 if (tty_ldisc_open(tty, old) < 0) {
502 tty_ldisc_put(old);
503
504 new_ldisc = tty_ldisc_get(N_TTY);
505 if (IS_ERR(new_ldisc))
506 panic("n_tty: get");
507 tty_ldisc_assign(tty, new_ldisc);
508 tty_set_termios_ldisc(tty, N_TTY);
509 r = tty_ldisc_open(tty, new_ldisc);
510 if (r < 0)
511 panic("Couldn't open N_TTY ldisc for "
512 "%s --- error %d.",
513 tty_name(tty, buf), r);
514 }
515}
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531static int tty_ldisc_halt(struct tty_struct *tty)
532{
533 clear_bit(TTY_LDISC, &tty->flags);
534 return cancel_delayed_work_sync(&tty->buf.work);
535}
536
537
538
539
540
541
542
543
544static int tty_ldisc_wait_idle(struct tty_struct *tty)
545{
546 int ret;
547 ret = wait_event_interruptible_timeout(tty_ldisc_idle,
548 atomic_read(&tty->ldisc->users) == 1, 5 * HZ);
549 if (ret < 0)
550 return ret;
551 return ret > 0 ? 0 : -EBUSY;
552}
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567int tty_set_ldisc(struct tty_struct *tty, int ldisc)
568{
569 int retval;
570 struct tty_ldisc *o_ldisc, *new_ldisc;
571 int work, o_work = 0;
572 struct tty_struct *o_tty;
573
574 new_ldisc = tty_ldisc_get(ldisc);
575 if (IS_ERR(new_ldisc))
576 return PTR_ERR(new_ldisc);
577
578 tty_lock();
579
580
581
582
583
584 o_tty = tty->link;
585
586
587
588
589
590
591 if (tty->ldisc->ops->num == ldisc) {
592 tty_unlock();
593 tty_ldisc_put(new_ldisc);
594 return 0;
595 }
596
597 tty_unlock();
598
599
600
601
602
603 tty_wait_until_sent(tty, 0);
604
605 tty_lock();
606 mutex_lock(&tty->ldisc_mutex);
607
608
609
610
611
612
613 while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
614 mutex_unlock(&tty->ldisc_mutex);
615 tty_unlock();
616 wait_event(tty_ldisc_wait,
617 test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0);
618 tty_lock();
619 mutex_lock(&tty->ldisc_mutex);
620 }
621
622 set_bit(TTY_LDISC_CHANGING, &tty->flags);
623
624
625
626
627
628
629 tty->receive_room = 0;
630
631 o_ldisc = tty->ldisc;
632
633 tty_unlock();
634
635
636
637
638
639
640
641
642
643
644
645 work = tty_ldisc_halt(tty);
646 if (o_tty)
647 o_work = tty_ldisc_halt(o_tty);
648
649
650
651
652
653
654 mutex_unlock(&tty->ldisc_mutex);
655
656 flush_scheduled_work();
657
658 retval = tty_ldisc_wait_idle(tty);
659
660 tty_lock();
661 mutex_lock(&tty->ldisc_mutex);
662
663
664 if (retval) {
665 tty_ldisc_put(new_ldisc);
666 goto enable;
667 }
668
669 if (test_bit(TTY_HUPPED, &tty->flags)) {
670
671
672 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
673 mutex_unlock(&tty->ldisc_mutex);
674 tty_ldisc_put(new_ldisc);
675 tty_unlock();
676 return -EIO;
677 }
678
679
680 tty_ldisc_close(tty, o_ldisc);
681
682
683 tty_ldisc_assign(tty, new_ldisc);
684 tty_set_termios_ldisc(tty, ldisc);
685
686 retval = tty_ldisc_open(tty, new_ldisc);
687 if (retval < 0) {
688
689 tty_ldisc_put(new_ldisc);
690 tty_ldisc_restore(tty, o_ldisc);
691 }
692
693
694
695
696
697 if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc)
698 tty->ops->set_ldisc(tty);
699
700 tty_ldisc_put(o_ldisc);
701
702enable:
703
704
705
706
707 tty_ldisc_enable(tty);
708 if (o_tty)
709 tty_ldisc_enable(o_tty);
710
711
712
713 if (work)
714 schedule_delayed_work(&tty->buf.work, 1);
715 if (o_work)
716 schedule_delayed_work(&o_tty->buf.work, 1);
717 mutex_unlock(&tty->ldisc_mutex);
718 tty_unlock();
719 return retval;
720}
721
722
723
724
725
726
727
728
729static void tty_reset_termios(struct tty_struct *tty)
730{
731 mutex_lock(&tty->termios_mutex);
732 *tty->termios = tty->driver->init_termios;
733 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
734 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
735 mutex_unlock(&tty->termios_mutex);
736}
737
738
739
740
741
742
743
744
745
746
747
748static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
749{
750 struct tty_ldisc *ld = tty_ldisc_get(ldisc);
751
752 if (IS_ERR(ld))
753 return -1;
754
755 tty_ldisc_close(tty, tty->ldisc);
756 tty_ldisc_put(tty->ldisc);
757 tty->ldisc = NULL;
758
759
760
761 tty_ldisc_assign(tty, ld);
762 tty_set_termios_ldisc(tty, ldisc);
763
764 return 0;
765}
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782void tty_ldisc_hangup(struct tty_struct *tty)
783{
784 struct tty_ldisc *ld;
785 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
786 int err = 0;
787
788
789
790
791
792
793 ld = tty_ldisc_ref(tty);
794 if (ld != NULL) {
795
796 if (ld->ops->flush_buffer)
797 ld->ops->flush_buffer(tty);
798 tty_driver_flush_buffer(tty);
799 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
800 ld->ops->write_wakeup)
801 ld->ops->write_wakeup(tty);
802 if (ld->ops->hangup)
803 ld->ops->hangup(tty);
804 tty_ldisc_deref(ld);
805 }
806
807
808
809
810 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
811 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
812
813
814
815
816
817
818 mutex_lock(&tty->ldisc_mutex);
819
820
821
822
823
824
825 clear_bit(TTY_LDISC, &tty->flags);
826 tty_unlock();
827 cancel_delayed_work_sync(&tty->buf.work);
828 mutex_unlock(&tty->ldisc_mutex);
829
830 tty_lock();
831 mutex_lock(&tty->ldisc_mutex);
832
833
834
835
836
837 if (tty->ldisc) {
838 if (reset == 0) {
839
840 if (!tty_ldisc_reinit(tty, tty->termios->c_line))
841 err = tty_ldisc_open(tty, tty->ldisc);
842 else
843 err = 1;
844 }
845
846
847 if (reset || err) {
848 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
849 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
850 }
851 tty_ldisc_enable(tty);
852 }
853 mutex_unlock(&tty->ldisc_mutex);
854 if (reset)
855 tty_reset_termios(tty);
856}
857
858
859
860
861
862
863
864
865
866
867
868int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
869{
870 struct tty_ldisc *ld = tty->ldisc;
871 int retval;
872
873 retval = tty_ldisc_open(tty, ld);
874 if (retval)
875 return retval;
876
877 if (o_tty) {
878 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
879 if (retval) {
880 tty_ldisc_close(tty, ld);
881 return retval;
882 }
883 tty_ldisc_enable(o_tty);
884 }
885 tty_ldisc_enable(tty);
886 return 0;
887}
888
889
890
891
892
893
894
895
896
897
898void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
899{
900
901
902
903
904
905
906 tty_unlock();
907 tty_ldisc_halt(tty);
908 flush_scheduled_work();
909 tty_lock();
910
911 mutex_lock(&tty->ldisc_mutex);
912
913
914
915 tty_ldisc_close(tty, tty->ldisc);
916 tty_ldisc_put(tty->ldisc);
917
918 tty->ldisc = NULL;
919
920
921 tty_set_termios_ldisc(tty, N_TTY);
922 mutex_unlock(&tty->ldisc_mutex);
923
924
925 if (o_tty)
926 tty_ldisc_release(o_tty, NULL);
927
928
929
930}
931
932
933
934
935
936
937
938
939
940void tty_ldisc_init(struct tty_struct *tty)
941{
942 struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
943 if (IS_ERR(ld))
944 panic("n_tty: init_tty");
945 tty_ldisc_assign(tty, ld);
946}
947
948void tty_ldisc_begin(void)
949{
950
951 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
952}
953