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