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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68#include <linux/types.h>
69#include <linux/major.h>
70#include <linux/errno.h>
71#include <linux/signal.h>
72#include <linux/fcntl.h>
73#include <linux/sched/signal.h>
74#include <linux/sched/task.h>
75#include <linux/interrupt.h>
76#include <linux/tty.h>
77#include <linux/tty_driver.h>
78#include <linux/tty_flip.h>
79#include <linux/devpts_fs.h>
80#include <linux/file.h>
81#include <linux/fdtable.h>
82#include <linux/console.h>
83#include <linux/timer.h>
84#include <linux/ctype.h>
85#include <linux/kd.h>
86#include <linux/mm.h>
87#include <linux/string.h>
88#include <linux/slab.h>
89#include <linux/poll.h>
90#include <linux/proc_fs.h>
91#include <linux/init.h>
92#include <linux/module.h>
93#include <linux/device.h>
94#include <linux/wait.h>
95#include <linux/bitops.h>
96#include <linux/delay.h>
97#include <linux/seq_file.h>
98#include <linux/serial.h>
99#include <linux/ratelimit.h>
100
101#include <linux/uaccess.h>
102
103#include <linux/kbd_kern.h>
104#include <linux/vt_kern.h>
105#include <linux/selection.h>
106
107#include <linux/kmod.h>
108#include <linux/nsproxy.h>
109
110#undef TTY_DEBUG_HANGUP
111#ifdef TTY_DEBUG_HANGUP
112# define tty_debug_hangup(tty, f, args...) tty_debug(tty, f, ##args)
113#else
114# define tty_debug_hangup(tty, f, args...) do { } while (0)
115#endif
116
117#define TTY_PARANOIA_CHECK 1
118#define CHECK_TTY_COUNT 1
119
120struct ktermios tty_std_termios = {
121 .c_iflag = ICRNL | IXON,
122 .c_oflag = OPOST | ONLCR,
123 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
124 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
125 ECHOCTL | ECHOKE | IEXTEN,
126 .c_cc = INIT_C_CC,
127 .c_ispeed = 38400,
128 .c_ospeed = 38400,
129
130};
131
132EXPORT_SYMBOL(tty_std_termios);
133
134
135
136
137
138LIST_HEAD(tty_drivers);
139
140
141DEFINE_MUTEX(tty_mutex);
142
143static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
144static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
145ssize_t redirected_tty_write(struct file *, const char __user *,
146 size_t, loff_t *);
147static __poll_t tty_poll(struct file *, poll_table *);
148static int tty_open(struct inode *, struct file *);
149long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
150#ifdef CONFIG_COMPAT
151static long tty_compat_ioctl(struct file *file, unsigned int cmd,
152 unsigned long arg);
153#else
154#define tty_compat_ioctl NULL
155#endif
156static int __tty_fasync(int fd, struct file *filp, int on);
157static int tty_fasync(int fd, struct file *filp, int on);
158static void release_tty(struct tty_struct *tty, int idx);
159
160
161
162
163
164
165
166
167
168
169static void free_tty_struct(struct tty_struct *tty)
170{
171 tty_ldisc_deinit(tty);
172 put_device(tty->dev);
173 kfree(tty->write_buf);
174 tty->magic = 0xDEADDEAD;
175 kfree(tty);
176}
177
178static inline struct tty_struct *file_tty(struct file *file)
179{
180 return ((struct tty_file_private *)file->private_data)->tty;
181}
182
183int tty_alloc_file(struct file *file)
184{
185 struct tty_file_private *priv;
186
187 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
188 if (!priv)
189 return -ENOMEM;
190
191 file->private_data = priv;
192
193 return 0;
194}
195
196
197void tty_add_file(struct tty_struct *tty, struct file *file)
198{
199 struct tty_file_private *priv = file->private_data;
200
201 priv->tty = tty;
202 priv->file = file;
203
204 spin_lock(&tty->files_lock);
205 list_add(&priv->list, &tty->tty_files);
206 spin_unlock(&tty->files_lock);
207}
208
209
210
211
212
213
214
215void tty_free_file(struct file *file)
216{
217 struct tty_file_private *priv = file->private_data;
218
219 file->private_data = NULL;
220 kfree(priv);
221}
222
223
224static void tty_del_file(struct file *file)
225{
226 struct tty_file_private *priv = file->private_data;
227 struct tty_struct *tty = priv->tty;
228
229 spin_lock(&tty->files_lock);
230 list_del(&priv->list);
231 spin_unlock(&tty->files_lock);
232 tty_free_file(file);
233}
234
235
236
237
238
239
240
241
242
243
244
245const char *tty_name(const struct tty_struct *tty)
246{
247 if (!tty)
248 return "NULL tty";
249 return tty->name;
250}
251
252EXPORT_SYMBOL(tty_name);
253
254const char *tty_driver_name(const struct tty_struct *tty)
255{
256 if (!tty || !tty->driver)
257 return "";
258 return tty->driver->name;
259}
260
261static int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
262 const char *routine)
263{
264#ifdef TTY_PARANOIA_CHECK
265 if (!tty) {
266 pr_warn("(%d:%d): %s: NULL tty\n",
267 imajor(inode), iminor(inode), routine);
268 return 1;
269 }
270 if (tty->magic != TTY_MAGIC) {
271 pr_warn("(%d:%d): %s: bad magic number\n",
272 imajor(inode), iminor(inode), routine);
273 return 1;
274 }
275#endif
276 return 0;
277}
278
279
280static int check_tty_count(struct tty_struct *tty, const char *routine)
281{
282#ifdef CHECK_TTY_COUNT
283 struct list_head *p;
284 int count = 0, kopen_count = 0;
285
286 spin_lock(&tty->files_lock);
287 list_for_each(p, &tty->tty_files) {
288 count++;
289 }
290 spin_unlock(&tty->files_lock);
291 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
292 tty->driver->subtype == PTY_TYPE_SLAVE &&
293 tty->link && tty->link->count)
294 count++;
295 if (tty_port_kopened(tty->port))
296 kopen_count++;
297 if (tty->count != (count + kopen_count)) {
298 tty_warn(tty, "%s: tty->count(%d) != (#fd's(%d) + #kopen's(%d))\n",
299 routine, tty->count, count, kopen_count);
300 return (count + kopen_count);
301 }
302#endif
303 return 0;
304}
305
306
307
308
309
310
311
312
313
314
315
316
317static struct tty_driver *get_tty_driver(dev_t device, int *index)
318{
319 struct tty_driver *p;
320
321 list_for_each_entry(p, &tty_drivers, tty_drivers) {
322 dev_t base = MKDEV(p->major, p->minor_start);
323 if (device < base || device >= base + p->num)
324 continue;
325 *index = device - base;
326 return tty_driver_kref_get(p);
327 }
328 return NULL;
329}
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344int tty_dev_name_to_number(const char *name, dev_t *number)
345{
346 struct tty_driver *p;
347 int ret;
348 int index, prefix_length = 0;
349 const char *str;
350
351 for (str = name; *str && !isdigit(*str); str++)
352 ;
353
354 if (!*str)
355 return -EINVAL;
356
357 ret = kstrtoint(str, 10, &index);
358 if (ret)
359 return ret;
360
361 prefix_length = str - name;
362 mutex_lock(&tty_mutex);
363
364 list_for_each_entry(p, &tty_drivers, tty_drivers)
365 if (prefix_length == strlen(p->name) && strncmp(name,
366 p->name, prefix_length) == 0) {
367 if (index < p->num) {
368 *number = MKDEV(p->major, p->minor_start + index);
369 goto out;
370 }
371 }
372
373
374 ret = -ENODEV;
375out:
376 mutex_unlock(&tty_mutex);
377 return ret;
378}
379EXPORT_SYMBOL_GPL(tty_dev_name_to_number);
380
381#ifdef CONFIG_CONSOLE_POLL
382
383
384
385
386
387
388
389
390
391
392struct tty_driver *tty_find_polling_driver(char *name, int *line)
393{
394 struct tty_driver *p, *res = NULL;
395 int tty_line = 0;
396 int len;
397 char *str, *stp;
398
399 for (str = name; *str; str++)
400 if ((*str >= '0' && *str <= '9') || *str == ',')
401 break;
402 if (!*str)
403 return NULL;
404
405 len = str - name;
406 tty_line = simple_strtoul(str, &str, 10);
407
408 mutex_lock(&tty_mutex);
409
410 list_for_each_entry(p, &tty_drivers, tty_drivers) {
411 if (strncmp(name, p->name, len) != 0)
412 continue;
413 stp = str;
414 if (*stp == ',')
415 stp++;
416 if (*stp == '\0')
417 stp = NULL;
418
419 if (tty_line >= 0 && tty_line < p->num && p->ops &&
420 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
421 res = tty_driver_kref_get(p);
422 *line = tty_line;
423 break;
424 }
425 }
426 mutex_unlock(&tty_mutex);
427
428 return res;
429}
430EXPORT_SYMBOL_GPL(tty_find_polling_driver);
431#endif
432
433static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
434 size_t count, loff_t *ppos)
435{
436 return 0;
437}
438
439static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
440 size_t count, loff_t *ppos)
441{
442 return -EIO;
443}
444
445
446static __poll_t hung_up_tty_poll(struct file *filp, poll_table *wait)
447{
448 return EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP | EPOLLRDNORM | EPOLLWRNORM;
449}
450
451static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
452 unsigned long arg)
453{
454 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
455}
456
457static long hung_up_tty_compat_ioctl(struct file *file,
458 unsigned int cmd, unsigned long arg)
459{
460 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
461}
462
463static int hung_up_tty_fasync(int fd, struct file *file, int on)
464{
465 return -ENOTTY;
466}
467
468static void tty_show_fdinfo(struct seq_file *m, struct file *file)
469{
470 struct tty_struct *tty = file_tty(file);
471
472 if (tty && tty->ops && tty->ops->show_fdinfo)
473 tty->ops->show_fdinfo(tty, m);
474}
475
476static const struct file_operations tty_fops = {
477 .llseek = no_llseek,
478 .read = tty_read,
479 .write = tty_write,
480 .poll = tty_poll,
481 .unlocked_ioctl = tty_ioctl,
482 .compat_ioctl = tty_compat_ioctl,
483 .open = tty_open,
484 .release = tty_release,
485 .fasync = tty_fasync,
486 .show_fdinfo = tty_show_fdinfo,
487};
488
489static const struct file_operations console_fops = {
490 .llseek = no_llseek,
491 .read = tty_read,
492 .write = redirected_tty_write,
493 .poll = tty_poll,
494 .unlocked_ioctl = tty_ioctl,
495 .compat_ioctl = tty_compat_ioctl,
496 .open = tty_open,
497 .release = tty_release,
498 .fasync = tty_fasync,
499};
500
501static const struct file_operations hung_up_tty_fops = {
502 .llseek = no_llseek,
503 .read = hung_up_tty_read,
504 .write = hung_up_tty_write,
505 .poll = hung_up_tty_poll,
506 .unlocked_ioctl = hung_up_tty_ioctl,
507 .compat_ioctl = hung_up_tty_compat_ioctl,
508 .release = tty_release,
509 .fasync = hung_up_tty_fasync,
510};
511
512static DEFINE_SPINLOCK(redirect_lock);
513static struct file *redirect;
514
515
516
517
518
519
520
521
522
523
524void tty_wakeup(struct tty_struct *tty)
525{
526 struct tty_ldisc *ld;
527
528 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
529 ld = tty_ldisc_ref(tty);
530 if (ld) {
531 if (ld->ops->write_wakeup)
532 ld->ops->write_wakeup(tty);
533 tty_ldisc_deref(ld);
534 }
535 }
536 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
537}
538
539EXPORT_SYMBOL_GPL(tty_wakeup);
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563static void __tty_hangup(struct tty_struct *tty, int exit_session)
564{
565 struct file *cons_filp = NULL;
566 struct file *filp, *f = NULL;
567 struct tty_file_private *priv;
568 int closecount = 0, n;
569 int refs;
570
571 if (!tty)
572 return;
573
574
575 spin_lock(&redirect_lock);
576 if (redirect && file_tty(redirect) == tty) {
577 f = redirect;
578 redirect = NULL;
579 }
580 spin_unlock(&redirect_lock);
581
582 tty_lock(tty);
583
584 if (test_bit(TTY_HUPPED, &tty->flags)) {
585 tty_unlock(tty);
586 return;
587 }
588
589
590
591
592
593
594
595 set_bit(TTY_HUPPING, &tty->flags);
596
597
598
599
600 check_tty_count(tty, "tty_hangup");
601
602 spin_lock(&tty->files_lock);
603
604 list_for_each_entry(priv, &tty->tty_files, list) {
605 filp = priv->file;
606 if (filp->f_op->write == redirected_tty_write)
607 cons_filp = filp;
608 if (filp->f_op->write != tty_write)
609 continue;
610 closecount++;
611 __tty_fasync(-1, filp, 0);
612 filp->f_op = &hung_up_tty_fops;
613 }
614 spin_unlock(&tty->files_lock);
615
616 refs = tty_signal_session_leader(tty, exit_session);
617
618 while (refs--)
619 tty_kref_put(tty);
620
621 tty_ldisc_hangup(tty, cons_filp != NULL);
622
623 spin_lock_irq(&tty->ctrl_lock);
624 clear_bit(TTY_THROTTLED, &tty->flags);
625 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
626 put_pid(tty->session);
627 put_pid(tty->pgrp);
628 tty->session = NULL;
629 tty->pgrp = NULL;
630 tty->ctrl_status = 0;
631 spin_unlock_irq(&tty->ctrl_lock);
632
633
634
635
636
637
638
639 if (cons_filp) {
640 if (tty->ops->close)
641 for (n = 0; n < closecount; n++)
642 tty->ops->close(tty, cons_filp);
643 } else if (tty->ops->hangup)
644 tty->ops->hangup(tty);
645
646
647
648
649
650 set_bit(TTY_HUPPED, &tty->flags);
651 clear_bit(TTY_HUPPING, &tty->flags);
652 tty_unlock(tty);
653
654 if (f)
655 fput(f);
656}
657
658static void do_tty_hangup(struct work_struct *work)
659{
660 struct tty_struct *tty =
661 container_of(work, struct tty_struct, hangup_work);
662
663 __tty_hangup(tty, 0);
664}
665
666
667
668
669
670
671
672
673
674void tty_hangup(struct tty_struct *tty)
675{
676 tty_debug_hangup(tty, "hangup\n");
677 schedule_work(&tty->hangup_work);
678}
679
680EXPORT_SYMBOL(tty_hangup);
681
682
683
684
685
686
687
688
689
690
691void tty_vhangup(struct tty_struct *tty)
692{
693 tty_debug_hangup(tty, "vhangup\n");
694 __tty_hangup(tty, 0);
695}
696
697EXPORT_SYMBOL(tty_vhangup);
698
699
700
701
702
703
704
705
706void tty_vhangup_self(void)
707{
708 struct tty_struct *tty;
709
710 tty = get_current_tty();
711 if (tty) {
712 tty_vhangup(tty);
713 tty_kref_put(tty);
714 }
715}
716
717
718
719
720
721
722
723
724
725
726
727
728void tty_vhangup_session(struct tty_struct *tty)
729{
730 tty_debug_hangup(tty, "session hangup\n");
731 __tty_hangup(tty, 1);
732}
733
734
735
736
737
738
739
740
741
742int tty_hung_up_p(struct file *filp)
743{
744 return (filp && filp->f_op == &hung_up_tty_fops);
745}
746
747EXPORT_SYMBOL(tty_hung_up_p);
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766void __stop_tty(struct tty_struct *tty)
767{
768 if (tty->stopped)
769 return;
770 tty->stopped = 1;
771 if (tty->ops->stop)
772 tty->ops->stop(tty);
773}
774
775void stop_tty(struct tty_struct *tty)
776{
777 unsigned long flags;
778
779 spin_lock_irqsave(&tty->flow_lock, flags);
780 __stop_tty(tty);
781 spin_unlock_irqrestore(&tty->flow_lock, flags);
782}
783EXPORT_SYMBOL(stop_tty);
784
785
786
787
788
789
790
791
792
793
794
795
796
797void __start_tty(struct tty_struct *tty)
798{
799 if (!tty->stopped || tty->flow_stopped)
800 return;
801 tty->stopped = 0;
802 if (tty->ops->start)
803 tty->ops->start(tty);
804 tty_wakeup(tty);
805}
806
807void start_tty(struct tty_struct *tty)
808{
809 unsigned long flags;
810
811 spin_lock_irqsave(&tty->flow_lock, flags);
812 __start_tty(tty);
813 spin_unlock_irqrestore(&tty->flow_lock, flags);
814}
815EXPORT_SYMBOL(start_tty);
816
817static void tty_update_time(struct timespec *time)
818{
819 unsigned long sec = get_seconds();
820
821
822
823
824
825
826
827 if ((sec ^ time->tv_sec) & ~7)
828 time->tv_sec = sec;
829}
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
847 loff_t *ppos)
848{
849 int i;
850 struct inode *inode = file_inode(file);
851 struct tty_struct *tty = file_tty(file);
852 struct tty_ldisc *ld;
853
854 if (tty_paranoia_check(tty, inode, "tty_read"))
855 return -EIO;
856 if (!tty || tty_io_error(tty))
857 return -EIO;
858
859
860
861 ld = tty_ldisc_ref_wait(tty);
862 if (!ld)
863 return hung_up_tty_read(file, buf, count, ppos);
864 if (ld->ops->read)
865 i = ld->ops->read(tty, file, buf, count);
866 else
867 i = -EIO;
868 tty_ldisc_deref(ld);
869
870 if (i > 0) {
871 struct timespec ts;
872
873 ts = timespec64_to_timespec(inode->i_atime);
874 tty_update_time(&ts);
875 inode->i_atime = timespec_to_timespec64(ts);
876 }
877
878 return i;
879}
880
881static void tty_write_unlock(struct tty_struct *tty)
882{
883 mutex_unlock(&tty->atomic_write_lock);
884 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
885}
886
887static int tty_write_lock(struct tty_struct *tty, int ndelay)
888{
889 if (!mutex_trylock(&tty->atomic_write_lock)) {
890 if (ndelay)
891 return -EAGAIN;
892 if (mutex_lock_interruptible(&tty->atomic_write_lock))
893 return -ERESTARTSYS;
894 }
895 return 0;
896}
897
898
899
900
901
902static inline ssize_t do_tty_write(
903 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
904 struct tty_struct *tty,
905 struct file *file,
906 const char __user *buf,
907 size_t count)
908{
909 ssize_t ret, written = 0;
910 unsigned int chunk;
911
912 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
913 if (ret < 0)
914 return ret;
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932 chunk = 2048;
933 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
934 chunk = 65536;
935 if (count < chunk)
936 chunk = count;
937
938
939 if (tty->write_cnt < chunk) {
940 unsigned char *buf_chunk;
941
942 if (chunk < 1024)
943 chunk = 1024;
944
945 buf_chunk = kmalloc(chunk, GFP_KERNEL);
946 if (!buf_chunk) {
947 ret = -ENOMEM;
948 goto out;
949 }
950 kfree(tty->write_buf);
951 tty->write_cnt = chunk;
952 tty->write_buf = buf_chunk;
953 }
954
955
956 for (;;) {
957 size_t size = count;
958 if (size > chunk)
959 size = chunk;
960 ret = -EFAULT;
961 if (copy_from_user(tty->write_buf, buf, size))
962 break;
963 ret = write(tty, file, tty->write_buf, size);
964 if (ret <= 0)
965 break;
966 written += ret;
967 buf += ret;
968 count -= ret;
969 if (!count)
970 break;
971 ret = -ERESTARTSYS;
972 if (signal_pending(current))
973 break;
974 cond_resched();
975 }
976 if (written) {
977 struct timespec ts;
978
979 ts = timespec64_to_timespec(file_inode(file)->i_mtime);
980 tty_update_time(&ts);
981 file_inode(file)->i_mtime = timespec_to_timespec64(ts);
982 ret = written;
983 }
984out:
985 tty_write_unlock(tty);
986 return ret;
987}
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001void tty_write_message(struct tty_struct *tty, char *msg)
1002{
1003 if (tty) {
1004 mutex_lock(&tty->atomic_write_lock);
1005 tty_lock(tty);
1006 if (tty->ops->write && tty->count > 0)
1007 tty->ops->write(tty, msg, strlen(msg));
1008 tty_unlock(tty);
1009 tty_write_unlock(tty);
1010 }
1011 return;
1012}
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031static ssize_t tty_write(struct file *file, const char __user *buf,
1032 size_t count, loff_t *ppos)
1033{
1034 struct tty_struct *tty = file_tty(file);
1035 struct tty_ldisc *ld;
1036 ssize_t ret;
1037
1038 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
1039 return -EIO;
1040 if (!tty || !tty->ops->write || tty_io_error(tty))
1041 return -EIO;
1042
1043 if (tty->ops->write_room == NULL)
1044 tty_err(tty, "missing write_room method\n");
1045 ld = tty_ldisc_ref_wait(tty);
1046 if (!ld)
1047 return hung_up_tty_write(file, buf, count, ppos);
1048 if (!ld->ops->write)
1049 ret = -EIO;
1050 else
1051 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
1052 tty_ldisc_deref(ld);
1053 return ret;
1054}
1055
1056ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1057 size_t count, loff_t *ppos)
1058{
1059 struct file *p = NULL;
1060
1061 spin_lock(&redirect_lock);
1062 if (redirect)
1063 p = get_file(redirect);
1064 spin_unlock(&redirect_lock);
1065
1066 if (p) {
1067 ssize_t res;
1068 res = vfs_write(p, buf, count, &p->f_pos);
1069 fput(p);
1070 return res;
1071 }
1072 return tty_write(file, buf, count, ppos);
1073}
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083int tty_send_xchar(struct tty_struct *tty, char ch)
1084{
1085 int was_stopped = tty->stopped;
1086
1087 if (tty->ops->send_xchar) {
1088 down_read(&tty->termios_rwsem);
1089 tty->ops->send_xchar(tty, ch);
1090 up_read(&tty->termios_rwsem);
1091 return 0;
1092 }
1093
1094 if (tty_write_lock(tty, 0) < 0)
1095 return -ERESTARTSYS;
1096
1097 down_read(&tty->termios_rwsem);
1098 if (was_stopped)
1099 start_tty(tty);
1100 tty->ops->write(tty, &ch, 1);
1101 if (was_stopped)
1102 stop_tty(tty);
1103 up_read(&tty->termios_rwsem);
1104 tty_write_unlock(tty);
1105 return 0;
1106}
1107
1108static char ptychar[] = "pqrstuvwxyzabcde";
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121static void pty_line_name(struct tty_driver *driver, int index, char *p)
1122{
1123 int i = index + driver->name_base;
1124
1125 sprintf(p, "%s%c%x",
1126 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1127 ptychar[i >> 4 & 0xf], i & 0xf);
1128}
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
1142{
1143 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
1144 return sprintf(p, "%s", driver->name);
1145 else
1146 return sprintf(p, "%s%d", driver->name,
1147 index + driver->name_base);
1148}
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
1161 struct file *file, int idx)
1162{
1163 struct tty_struct *tty;
1164
1165 if (driver->ops->lookup)
1166 if (!file)
1167 tty = ERR_PTR(-EIO);
1168 else
1169 tty = driver->ops->lookup(driver, file, idx);
1170 else
1171 tty = driver->ttys[idx];
1172
1173 if (!IS_ERR(tty))
1174 tty_kref_get(tty);
1175 return tty;
1176}
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186void tty_init_termios(struct tty_struct *tty)
1187{
1188 struct ktermios *tp;
1189 int idx = tty->index;
1190
1191 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1192 tty->termios = tty->driver->init_termios;
1193 else {
1194
1195 tp = tty->driver->termios[idx];
1196 if (tp != NULL) {
1197 tty->termios = *tp;
1198 tty->termios.c_line = tty->driver->init_termios.c_line;
1199 } else
1200 tty->termios = tty->driver->init_termios;
1201 }
1202
1203 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1204 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
1205}
1206EXPORT_SYMBOL_GPL(tty_init_termios);
1207
1208int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1209{
1210 tty_init_termios(tty);
1211 tty_driver_kref_get(driver);
1212 tty->count++;
1213 driver->ttys[tty->index] = tty;
1214 return 0;
1215}
1216EXPORT_SYMBOL_GPL(tty_standard_install);
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230static int tty_driver_install_tty(struct tty_driver *driver,
1231 struct tty_struct *tty)
1232{
1233 return driver->ops->install ? driver->ops->install(driver, tty) :
1234 tty_standard_install(driver, tty);
1235}
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
1248{
1249 if (driver->ops->remove)
1250 driver->ops->remove(driver, tty);
1251 else
1252 driver->ttys[tty->index] = NULL;
1253}
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264static int tty_reopen(struct tty_struct *tty)
1265{
1266 struct tty_driver *driver = tty->driver;
1267
1268 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1269 driver->subtype == PTY_TYPE_MASTER)
1270 return -EIO;
1271
1272 if (!tty->count)
1273 return -EAGAIN;
1274
1275 if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1276 return -EBUSY;
1277
1278 tty->count++;
1279
1280 if (!tty->ldisc)
1281 return tty_ldisc_reinit(tty, tty->termios.c_line);
1282
1283 return 0;
1284}
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
1311{
1312 struct tty_struct *tty;
1313 int retval;
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323 if (!try_module_get(driver->owner))
1324 return ERR_PTR(-ENODEV);
1325
1326 tty = alloc_tty_struct(driver, idx);
1327 if (!tty) {
1328 retval = -ENOMEM;
1329 goto err_module_put;
1330 }
1331
1332 tty_lock(tty);
1333 retval = tty_driver_install_tty(driver, tty);
1334 if (retval < 0)
1335 goto err_free_tty;
1336
1337 if (!tty->port)
1338 tty->port = driver->ports[idx];
1339
1340 WARN_RATELIMIT(!tty->port,
1341 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1342 __func__, tty->driver->name);
1343
1344 retval = tty_ldisc_lock(tty, 5 * HZ);
1345 if (retval)
1346 goto err_release_lock;
1347 tty->port->itty = tty;
1348
1349
1350
1351
1352
1353
1354 retval = tty_ldisc_setup(tty, tty->link);
1355 if (retval)
1356 goto err_release_tty;
1357 tty_ldisc_unlock(tty);
1358
1359 return tty;
1360
1361err_free_tty:
1362 tty_unlock(tty);
1363 free_tty_struct(tty);
1364err_module_put:
1365 module_put(driver->owner);
1366 return ERR_PTR(retval);
1367
1368
1369err_release_tty:
1370 tty_ldisc_unlock(tty);
1371 tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
1372 retval, idx);
1373err_release_lock:
1374 tty_unlock(tty);
1375 release_tty(tty, idx);
1376 return ERR_PTR(retval);
1377}
1378
1379static void tty_free_termios(struct tty_struct *tty)
1380{
1381 struct ktermios *tp;
1382 int idx = tty->index;
1383
1384
1385 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1386 return;
1387
1388
1389 tp = tty->driver->termios[idx];
1390 if (tp == NULL) {
1391 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1392 if (tp == NULL)
1393 return;
1394 tty->driver->termios[idx] = tp;
1395 }
1396 *tp = tty->termios;
1397}
1398
1399
1400
1401
1402
1403
1404
1405static void tty_flush_works(struct tty_struct *tty)
1406{
1407 flush_work(&tty->SAK_work);
1408 flush_work(&tty->hangup_work);
1409 if (tty->link) {
1410 flush_work(&tty->link->SAK_work);
1411 flush_work(&tty->link->hangup_work);
1412 }
1413}
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430static void release_one_tty(struct work_struct *work)
1431{
1432 struct tty_struct *tty =
1433 container_of(work, struct tty_struct, hangup_work);
1434 struct tty_driver *driver = tty->driver;
1435 struct module *owner = driver->owner;
1436
1437 if (tty->ops->cleanup)
1438 tty->ops->cleanup(tty);
1439
1440 tty->magic = 0;
1441 tty_driver_kref_put(driver);
1442 module_put(owner);
1443
1444 spin_lock(&tty->files_lock);
1445 list_del_init(&tty->tty_files);
1446 spin_unlock(&tty->files_lock);
1447
1448 put_pid(tty->pgrp);
1449 put_pid(tty->session);
1450 free_tty_struct(tty);
1451}
1452
1453static void queue_release_one_tty(struct kref *kref)
1454{
1455 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1456
1457
1458
1459 INIT_WORK(&tty->hangup_work, release_one_tty);
1460 schedule_work(&tty->hangup_work);
1461}
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471void tty_kref_put(struct tty_struct *tty)
1472{
1473 if (tty)
1474 kref_put(&tty->kref, queue_release_one_tty);
1475}
1476EXPORT_SYMBOL(tty_kref_put);
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490static void release_tty(struct tty_struct *tty, int idx)
1491{
1492
1493 WARN_ON(tty->index != idx);
1494 WARN_ON(!mutex_is_locked(&tty_mutex));
1495 if (tty->ops->shutdown)
1496 tty->ops->shutdown(tty);
1497 tty_free_termios(tty);
1498 tty_driver_remove_tty(tty->driver, tty);
1499 tty->port->itty = NULL;
1500 if (tty->link)
1501 tty->link->port->itty = NULL;
1502 tty_buffer_cancel_work(tty->port);
1503 if (tty->link)
1504 tty_buffer_cancel_work(tty->link->port);
1505
1506 tty_kref_put(tty->link);
1507 tty_kref_put(tty);
1508}
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519static int tty_release_checks(struct tty_struct *tty, int idx)
1520{
1521#ifdef TTY_PARANOIA_CHECK
1522 if (idx < 0 || idx >= tty->driver->num) {
1523 tty_debug(tty, "bad idx %d\n", idx);
1524 return -1;
1525 }
1526
1527
1528 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1529 return 0;
1530
1531 if (tty != tty->driver->ttys[idx]) {
1532 tty_debug(tty, "bad driver table[%d] = %p\n",
1533 idx, tty->driver->ttys[idx]);
1534 return -1;
1535 }
1536 if (tty->driver->other) {
1537 struct tty_struct *o_tty = tty->link;
1538
1539 if (o_tty != tty->driver->other->ttys[idx]) {
1540 tty_debug(tty, "bad other table[%d] = %p\n",
1541 idx, tty->driver->other->ttys[idx]);
1542 return -1;
1543 }
1544 if (o_tty->link != tty) {
1545 tty_debug(tty, "bad link = %p\n", o_tty->link);
1546 return -1;
1547 }
1548 }
1549#endif
1550 return 0;
1551}
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561void tty_kclose(struct tty_struct *tty)
1562{
1563
1564
1565
1566 tty_ldisc_release(tty);
1567
1568
1569 tty_flush_works(tty);
1570
1571 tty_debug_hangup(tty, "freeing structure\n");
1572
1573
1574
1575
1576
1577
1578 mutex_lock(&tty_mutex);
1579 tty_port_set_kopened(tty->port, 0);
1580 release_tty(tty, tty->index);
1581 mutex_unlock(&tty_mutex);
1582}
1583EXPORT_SYMBOL_GPL(tty_kclose);
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593void tty_release_struct(struct tty_struct *tty, int idx)
1594{
1595
1596
1597
1598 tty_ldisc_release(tty);
1599
1600
1601 tty_flush_works(tty);
1602
1603 tty_debug_hangup(tty, "freeing structure\n");
1604
1605
1606
1607
1608
1609
1610 mutex_lock(&tty_mutex);
1611 release_tty(tty, idx);
1612 mutex_unlock(&tty_mutex);
1613}
1614EXPORT_SYMBOL_GPL(tty_release_struct);
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635int tty_release(struct inode *inode, struct file *filp)
1636{
1637 struct tty_struct *tty = file_tty(filp);
1638 struct tty_struct *o_tty = NULL;
1639 int do_sleep, final;
1640 int idx;
1641 long timeout = 0;
1642 int once = 1;
1643
1644 if (tty_paranoia_check(tty, inode, __func__))
1645 return 0;
1646
1647 tty_lock(tty);
1648 check_tty_count(tty, __func__);
1649
1650 __tty_fasync(-1, filp, 0);
1651
1652 idx = tty->index;
1653 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1654 tty->driver->subtype == PTY_TYPE_MASTER)
1655 o_tty = tty->link;
1656
1657 if (tty_release_checks(tty, idx)) {
1658 tty_unlock(tty);
1659 return 0;
1660 }
1661
1662 tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);
1663
1664 if (tty->ops->close)
1665 tty->ops->close(tty, filp);
1666
1667
1668 tty_lock_slave(o_tty);
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683 while (1) {
1684 do_sleep = 0;
1685
1686 if (tty->count <= 1) {
1687 if (waitqueue_active(&tty->read_wait)) {
1688 wake_up_poll(&tty->read_wait, EPOLLIN);
1689 do_sleep++;
1690 }
1691 if (waitqueue_active(&tty->write_wait)) {
1692 wake_up_poll(&tty->write_wait, EPOLLOUT);
1693 do_sleep++;
1694 }
1695 }
1696 if (o_tty && o_tty->count <= 1) {
1697 if (waitqueue_active(&o_tty->read_wait)) {
1698 wake_up_poll(&o_tty->read_wait, EPOLLIN);
1699 do_sleep++;
1700 }
1701 if (waitqueue_active(&o_tty->write_wait)) {
1702 wake_up_poll(&o_tty->write_wait, EPOLLOUT);
1703 do_sleep++;
1704 }
1705 }
1706 if (!do_sleep)
1707 break;
1708
1709 if (once) {
1710 once = 0;
1711 tty_warn(tty, "read/write wait queue active!\n");
1712 }
1713 schedule_timeout_killable(timeout);
1714 if (timeout < 120 * HZ)
1715 timeout = 2 * timeout + 1;
1716 else
1717 timeout = MAX_SCHEDULE_TIMEOUT;
1718 }
1719
1720 if (o_tty) {
1721 if (--o_tty->count < 0) {
1722 tty_warn(tty, "bad slave count (%d)\n", o_tty->count);
1723 o_tty->count = 0;
1724 }
1725 }
1726 if (--tty->count < 0) {
1727 tty_warn(tty, "bad tty->count (%d)\n", tty->count);
1728 tty->count = 0;
1729 }
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740 tty_del_file(filp);
1741
1742
1743
1744
1745
1746
1747
1748
1749 if (!tty->count) {
1750 read_lock(&tasklist_lock);
1751 session_clear_tty(tty->session);
1752 if (o_tty)
1753 session_clear_tty(o_tty->session);
1754 read_unlock(&tasklist_lock);
1755 }
1756
1757
1758 final = !tty->count && !(o_tty && o_tty->count);
1759
1760 tty_unlock_slave(o_tty);
1761 tty_unlock(tty);
1762
1763
1764
1765
1766 if (!final)
1767 return 0;
1768
1769 tty_debug_hangup(tty, "final close\n");
1770
1771 tty_release_struct(tty, idx);
1772 return 0;
1773}
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1787{
1788 struct tty_struct *tty;
1789 int retval;
1790
1791 if (device != MKDEV(TTYAUX_MAJOR, 0))
1792 return NULL;
1793
1794 tty = get_current_tty();
1795 if (!tty)
1796 return ERR_PTR(-ENXIO);
1797
1798 filp->f_flags |= O_NONBLOCK;
1799
1800 tty_lock(tty);
1801 tty_kref_put(tty);
1802
1803 retval = tty_reopen(tty);
1804 if (retval < 0) {
1805 tty_unlock(tty);
1806 tty = ERR_PTR(retval);
1807 }
1808 return tty;
1809}
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1824 int *index)
1825{
1826 struct tty_driver *driver;
1827
1828 switch (device) {
1829#ifdef CONFIG_VT
1830 case MKDEV(TTY_MAJOR, 0): {
1831 extern struct tty_driver *console_driver;
1832 driver = tty_driver_kref_get(console_driver);
1833 *index = fg_console;
1834 break;
1835 }
1836#endif
1837 case MKDEV(TTYAUX_MAJOR, 1): {
1838 struct tty_driver *console_driver = console_device(index);
1839 if (console_driver) {
1840 driver = tty_driver_kref_get(console_driver);
1841 if (driver && filp) {
1842
1843 filp->f_flags |= O_NONBLOCK;
1844 break;
1845 }
1846 }
1847 return ERR_PTR(-ENODEV);
1848 }
1849 default:
1850 driver = get_tty_driver(device, index);
1851 if (!driver)
1852 return ERR_PTR(-ENODEV);
1853 break;
1854 }
1855 return driver;
1856}
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873struct tty_struct *tty_kopen(dev_t device)
1874{
1875 struct tty_struct *tty;
1876 struct tty_driver *driver = NULL;
1877 int index = -1;
1878
1879 mutex_lock(&tty_mutex);
1880 driver = tty_lookup_driver(device, NULL, &index);
1881 if (IS_ERR(driver)) {
1882 mutex_unlock(&tty_mutex);
1883 return ERR_CAST(driver);
1884 }
1885
1886
1887 tty = tty_driver_lookup_tty(driver, NULL, index);
1888 if (IS_ERR(tty))
1889 goto out;
1890
1891 if (tty) {
1892
1893 tty_kref_put(tty);
1894 tty = ERR_PTR(-EBUSY);
1895 } else {
1896 tty = tty_init_dev(driver, index);
1897 if (IS_ERR(tty))
1898 goto out;
1899 tty_port_set_kopened(tty->port, 1);
1900 }
1901out:
1902 mutex_unlock(&tty_mutex);
1903 tty_driver_kref_put(driver);
1904 return tty;
1905}
1906EXPORT_SYMBOL_GPL(tty_kopen);
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
1925 struct file *filp)
1926{
1927 struct tty_struct *tty;
1928 struct tty_driver *driver = NULL;
1929 int index = -1;
1930 int retval;
1931
1932 mutex_lock(&tty_mutex);
1933 driver = tty_lookup_driver(device, filp, &index);
1934 if (IS_ERR(driver)) {
1935 mutex_unlock(&tty_mutex);
1936 return ERR_CAST(driver);
1937 }
1938
1939
1940 tty = tty_driver_lookup_tty(driver, filp, index);
1941 if (IS_ERR(tty)) {
1942 mutex_unlock(&tty_mutex);
1943 goto out;
1944 }
1945
1946 if (tty) {
1947 if (tty_port_kopened(tty->port)) {
1948 tty_kref_put(tty);
1949 mutex_unlock(&tty_mutex);
1950 tty = ERR_PTR(-EBUSY);
1951 goto out;
1952 }
1953 mutex_unlock(&tty_mutex);
1954 retval = tty_lock_interruptible(tty);
1955 tty_kref_put(tty);
1956 if (retval) {
1957 if (retval == -EINTR)
1958 retval = -ERESTARTSYS;
1959 tty = ERR_PTR(retval);
1960 goto out;
1961 }
1962 retval = tty_reopen(tty);
1963 if (retval < 0) {
1964 tty_unlock(tty);
1965 tty = ERR_PTR(retval);
1966 }
1967 } else {
1968 tty = tty_init_dev(driver, index);
1969 mutex_unlock(&tty_mutex);
1970 }
1971out:
1972 tty_driver_kref_put(driver);
1973 return tty;
1974}
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000static int tty_open(struct inode *inode, struct file *filp)
2001{
2002 struct tty_struct *tty;
2003 int noctty, retval;
2004 dev_t device = inode->i_rdev;
2005 unsigned saved_flags = filp->f_flags;
2006
2007 nonseekable_open(inode, filp);
2008
2009retry_open:
2010 retval = tty_alloc_file(filp);
2011 if (retval)
2012 return -ENOMEM;
2013
2014 tty = tty_open_current_tty(device, filp);
2015 if (!tty)
2016 tty = tty_open_by_driver(device, inode, filp);
2017
2018 if (IS_ERR(tty)) {
2019 tty_free_file(filp);
2020 retval = PTR_ERR(tty);
2021 if (retval != -EAGAIN || signal_pending(current))
2022 return retval;
2023 schedule();
2024 goto retry_open;
2025 }
2026
2027 tty_add_file(tty, filp);
2028
2029 check_tty_count(tty, __func__);
2030 tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
2031
2032 if (tty->ops->open)
2033 retval = tty->ops->open(tty, filp);
2034 else
2035 retval = -ENODEV;
2036 filp->f_flags = saved_flags;
2037
2038 if (retval) {
2039 tty_debug_hangup(tty, "open error %d, releasing\n", retval);
2040
2041 tty_unlock(tty);
2042 tty_release(inode, filp);
2043 if (retval != -ERESTARTSYS)
2044 return retval;
2045
2046 if (signal_pending(current))
2047 return retval;
2048
2049 schedule();
2050
2051
2052
2053 if (tty_hung_up_p(filp))
2054 filp->f_op = &tty_fops;
2055 goto retry_open;
2056 }
2057 clear_bit(TTY_HUPPED, &tty->flags);
2058
2059 noctty = (filp->f_flags & O_NOCTTY) ||
2060 (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
2061 device == MKDEV(TTYAUX_MAJOR, 1) ||
2062 (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2063 tty->driver->subtype == PTY_TYPE_MASTER);
2064 if (!noctty)
2065 tty_open_proc_set_tty(filp, tty);
2066 tty_unlock(tty);
2067 return 0;
2068}
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084static __poll_t tty_poll(struct file *filp, poll_table *wait)
2085{
2086 struct tty_struct *tty = file_tty(filp);
2087 struct tty_ldisc *ld;
2088 __poll_t ret = 0;
2089
2090 if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
2091 return 0;
2092
2093 ld = tty_ldisc_ref_wait(tty);
2094 if (!ld)
2095 return hung_up_tty_poll(filp, wait);
2096 if (ld->ops->poll)
2097 ret = ld->ops->poll(tty, filp, wait);
2098 tty_ldisc_deref(ld);
2099 return ret;
2100}
2101
2102static int __tty_fasync(int fd, struct file *filp, int on)
2103{
2104 struct tty_struct *tty = file_tty(filp);
2105 unsigned long flags;
2106 int retval = 0;
2107
2108 if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
2109 goto out;
2110
2111 retval = fasync_helper(fd, filp, on, &tty->fasync);
2112 if (retval <= 0)
2113 goto out;
2114
2115 if (on) {
2116 enum pid_type type;
2117 struct pid *pid;
2118
2119 spin_lock_irqsave(&tty->ctrl_lock, flags);
2120 if (tty->pgrp) {
2121 pid = tty->pgrp;
2122 type = PIDTYPE_PGID;
2123 } else {
2124 pid = task_pid(current);
2125 type = PIDTYPE_PID;
2126 }
2127 get_pid(pid);
2128 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2129 __f_setown(filp, pid, type, 0);
2130 put_pid(pid);
2131 retval = 0;
2132 }
2133out:
2134 return retval;
2135}
2136
2137static int tty_fasync(int fd, struct file *filp, int on)
2138{
2139 struct tty_struct *tty = file_tty(filp);
2140 int retval = -ENOTTY;
2141
2142 tty_lock(tty);
2143 if (!tty_hung_up_p(filp))
2144 retval = __tty_fasync(fd, filp, on);
2145 tty_unlock(tty);
2146
2147 return retval;
2148}
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167static int tiocsti(struct tty_struct *tty, char __user *p)
2168{
2169 char ch, mbz = 0;
2170 struct tty_ldisc *ld;
2171
2172 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2173 return -EPERM;
2174 if (get_user(ch, p))
2175 return -EFAULT;
2176 tty_audit_tiocsti(tty, ch);
2177 ld = tty_ldisc_ref_wait(tty);
2178 if (!ld)
2179 return -EIO;
2180 ld->ops->receive_buf(tty, &ch, &mbz, 1);
2181 tty_ldisc_deref(ld);
2182 return 0;
2183}
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
2197{
2198 int err;
2199
2200 mutex_lock(&tty->winsize_mutex);
2201 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2202 mutex_unlock(&tty->winsize_mutex);
2203
2204 return err ? -EFAULT: 0;
2205}
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
2218{
2219 struct pid *pgrp;
2220
2221
2222 mutex_lock(&tty->winsize_mutex);
2223 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2224 goto done;
2225
2226
2227 pgrp = tty_get_pgrp(tty);
2228 if (pgrp)
2229 kill_pgrp(pgrp, SIGWINCH, 1);
2230 put_pid(pgrp);
2231
2232 tty->winsize = *ws;
2233done:
2234 mutex_unlock(&tty->winsize_mutex);
2235 return 0;
2236}
2237EXPORT_SYMBOL(tty_do_resize);
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
2255{
2256 struct winsize tmp_ws;
2257 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2258 return -EFAULT;
2259
2260 if (tty->ops->resize)
2261 return tty->ops->resize(tty, &tmp_ws);
2262 else
2263 return tty_do_resize(tty, &tmp_ws);
2264}
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275static int tioccons(struct file *file)
2276{
2277 if (!capable(CAP_SYS_ADMIN))
2278 return -EPERM;
2279 if (file->f_op->write == redirected_tty_write) {
2280 struct file *f;
2281 spin_lock(&redirect_lock);
2282 f = redirect;
2283 redirect = NULL;
2284 spin_unlock(&redirect_lock);
2285 if (f)
2286 fput(f);
2287 return 0;
2288 }
2289 spin_lock(&redirect_lock);
2290 if (redirect) {
2291 spin_unlock(&redirect_lock);
2292 return -EBUSY;
2293 }
2294 redirect = get_file(file);
2295 spin_unlock(&redirect_lock);
2296 return 0;
2297}
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311static int fionbio(struct file *file, int __user *p)
2312{
2313 int nonblock;
2314
2315 if (get_user(nonblock, p))
2316 return -EFAULT;
2317
2318 spin_lock(&file->f_lock);
2319 if (nonblock)
2320 file->f_flags |= O_NONBLOCK;
2321 else
2322 file->f_flags &= ~O_NONBLOCK;
2323 spin_unlock(&file->f_lock);
2324 return 0;
2325}
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337static int tiocsetd(struct tty_struct *tty, int __user *p)
2338{
2339 int disc;
2340 int ret;
2341
2342 if (get_user(disc, p))
2343 return -EFAULT;
2344
2345 ret = tty_set_ldisc(tty, disc);
2346
2347 return ret;
2348}
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361static int tiocgetd(struct tty_struct *tty, int __user *p)
2362{
2363 struct tty_ldisc *ld;
2364 int ret;
2365
2366 ld = tty_ldisc_ref_wait(tty);
2367 if (!ld)
2368 return -EIO;
2369 ret = put_user(ld->ops->num, p);
2370 tty_ldisc_deref(ld);
2371 return ret;
2372}
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387static int send_break(struct tty_struct *tty, unsigned int duration)
2388{
2389 int retval;
2390
2391 if (tty->ops->break_ctl == NULL)
2392 return 0;
2393
2394 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2395 retval = tty->ops->break_ctl(tty, duration);
2396 else {
2397
2398 if (tty_write_lock(tty, 0) < 0)
2399 return -EINTR;
2400 retval = tty->ops->break_ctl(tty, -1);
2401 if (retval)
2402 goto out;
2403 if (!signal_pending(current))
2404 msleep_interruptible(duration);
2405 retval = tty->ops->break_ctl(tty, 0);
2406out:
2407 tty_write_unlock(tty);
2408 if (signal_pending(current))
2409 retval = -EINTR;
2410 }
2411 return retval;
2412}
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426static int tty_tiocmget(struct tty_struct *tty, int __user *p)
2427{
2428 int retval = -EINVAL;
2429
2430 if (tty->ops->tiocmget) {
2431 retval = tty->ops->tiocmget(tty);
2432
2433 if (retval >= 0)
2434 retval = put_user(retval, p);
2435 }
2436 return retval;
2437}
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
2452 unsigned __user *p)
2453{
2454 int retval;
2455 unsigned int set, clear, val;
2456
2457 if (tty->ops->tiocmset == NULL)
2458 return -EINVAL;
2459
2460 retval = get_user(val, p);
2461 if (retval)
2462 return retval;
2463 set = clear = 0;
2464 switch (cmd) {
2465 case TIOCMBIS:
2466 set = val;
2467 break;
2468 case TIOCMBIC:
2469 clear = val;
2470 break;
2471 case TIOCMSET:
2472 set = val;
2473 clear = ~val;
2474 break;
2475 }
2476 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2477 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2478 return tty->ops->tiocmset(tty, set, clear);
2479}
2480
2481static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2482{
2483 int retval = -EINVAL;
2484 struct serial_icounter_struct icount;
2485 memset(&icount, 0, sizeof(icount));
2486 if (tty->ops->get_icount)
2487 retval = tty->ops->get_icount(tty, &icount);
2488 if (retval != 0)
2489 return retval;
2490 if (copy_to_user(arg, &icount, sizeof(icount)))
2491 return -EFAULT;
2492 return 0;
2493}
2494
2495static void tty_warn_deprecated_flags(struct serial_struct __user *ss)
2496{
2497 static DEFINE_RATELIMIT_STATE(depr_flags,
2498 DEFAULT_RATELIMIT_INTERVAL,
2499 DEFAULT_RATELIMIT_BURST);
2500 char comm[TASK_COMM_LEN];
2501 int flags;
2502
2503 if (get_user(flags, &ss->flags))
2504 return;
2505
2506 flags &= ASYNC_DEPRECATED;
2507
2508 if (flags && __ratelimit(&depr_flags))
2509 pr_warn("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2510 __func__, get_task_comm(comm, current), flags);
2511}
2512
2513
2514
2515
2516
2517static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2518{
2519 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2520 tty->driver->subtype == PTY_TYPE_MASTER)
2521 tty = tty->link;
2522 return tty;
2523}
2524
2525
2526
2527
2528long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2529{
2530 struct tty_struct *tty = file_tty(file);
2531 struct tty_struct *real_tty;
2532 void __user *p = (void __user *)arg;
2533 int retval;
2534 struct tty_ldisc *ld;
2535
2536 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2537 return -EINVAL;
2538
2539 real_tty = tty_pair_get_tty(tty);
2540
2541
2542
2543
2544 switch (cmd) {
2545 case TIOCSETD:
2546 case TIOCSBRK:
2547 case TIOCCBRK:
2548 case TCSBRK:
2549 case TCSBRKP:
2550 retval = tty_check_change(tty);
2551 if (retval)
2552 return retval;
2553 if (cmd != TIOCCBRK) {
2554 tty_wait_until_sent(tty, 0);
2555 if (signal_pending(current))
2556 return -EINTR;
2557 }
2558 break;
2559 }
2560
2561
2562
2563
2564 switch (cmd) {
2565 case TIOCSTI:
2566 return tiocsti(tty, p);
2567 case TIOCGWINSZ:
2568 return tiocgwinsz(real_tty, p);
2569 case TIOCSWINSZ:
2570 return tiocswinsz(real_tty, p);
2571 case TIOCCONS:
2572 return real_tty != tty ? -EINVAL : tioccons(file);
2573 case FIONBIO:
2574 return fionbio(file, p);
2575 case TIOCEXCL:
2576 set_bit(TTY_EXCLUSIVE, &tty->flags);
2577 return 0;
2578 case TIOCNXCL:
2579 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2580 return 0;
2581 case TIOCGEXCL:
2582 {
2583 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2584 return put_user(excl, (int __user *)p);
2585 }
2586 case TIOCGETD:
2587 return tiocgetd(tty, p);
2588 case TIOCSETD:
2589 return tiocsetd(tty, p);
2590 case TIOCVHANGUP:
2591 if (!capable(CAP_SYS_ADMIN))
2592 return -EPERM;
2593 tty_vhangup(tty);
2594 return 0;
2595 case TIOCGDEV:
2596 {
2597 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2598 return put_user(ret, (unsigned int __user *)p);
2599 }
2600
2601
2602
2603 case TIOCSBRK:
2604 if (tty->ops->break_ctl)
2605 return tty->ops->break_ctl(tty, -1);
2606 return 0;
2607 case TIOCCBRK:
2608 if (tty->ops->break_ctl)
2609 return tty->ops->break_ctl(tty, 0);
2610 return 0;
2611 case TCSBRK:
2612
2613
2614
2615
2616 if (!arg)
2617 return send_break(tty, 250);
2618 return 0;
2619 case TCSBRKP:
2620 return send_break(tty, arg ? arg*100 : 250);
2621
2622 case TIOCMGET:
2623 return tty_tiocmget(tty, p);
2624 case TIOCMSET:
2625 case TIOCMBIC:
2626 case TIOCMBIS:
2627 return tty_tiocmset(tty, cmd, p);
2628 case TIOCGICOUNT:
2629 retval = tty_tiocgicount(tty, p);
2630
2631 if (retval != -EINVAL)
2632 return retval;
2633 break;
2634 case TCFLSH:
2635 switch (arg) {
2636 case TCIFLUSH:
2637 case TCIOFLUSH:
2638
2639 tty_buffer_flush(tty, NULL);
2640 break;
2641 }
2642 break;
2643 case TIOCSSERIAL:
2644 tty_warn_deprecated_flags(p);
2645 break;
2646 case TIOCGPTPEER:
2647
2648 return ptm_open_peer(file, tty, (int)arg);
2649 default:
2650 retval = tty_jobctrl_ioctl(tty, real_tty, file, cmd, arg);
2651 if (retval != -ENOIOCTLCMD)
2652 return retval;
2653 }
2654 if (tty->ops->ioctl) {
2655 retval = tty->ops->ioctl(tty, cmd, arg);
2656 if (retval != -ENOIOCTLCMD)
2657 return retval;
2658 }
2659 ld = tty_ldisc_ref_wait(tty);
2660 if (!ld)
2661 return hung_up_tty_ioctl(file, cmd, arg);
2662 retval = -EINVAL;
2663 if (ld->ops->ioctl) {
2664 retval = ld->ops->ioctl(tty, file, cmd, arg);
2665 if (retval == -ENOIOCTLCMD)
2666 retval = -ENOTTY;
2667 }
2668 tty_ldisc_deref(ld);
2669 return retval;
2670}
2671
2672#ifdef CONFIG_COMPAT
2673static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2674 unsigned long arg)
2675{
2676 struct tty_struct *tty = file_tty(file);
2677 struct tty_ldisc *ld;
2678 int retval = -ENOIOCTLCMD;
2679
2680 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2681 return -EINVAL;
2682
2683 if (tty->ops->compat_ioctl) {
2684 retval = tty->ops->compat_ioctl(tty, cmd, arg);
2685 if (retval != -ENOIOCTLCMD)
2686 return retval;
2687 }
2688
2689 ld = tty_ldisc_ref_wait(tty);
2690 if (!ld)
2691 return hung_up_tty_compat_ioctl(file, cmd, arg);
2692 if (ld->ops->compat_ioctl)
2693 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2694 else
2695 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
2696 tty_ldisc_deref(ld);
2697
2698 return retval;
2699}
2700#endif
2701
2702static int this_tty(const void *t, struct file *file, unsigned fd)
2703{
2704 if (likely(file->f_op->read != tty_read))
2705 return 0;
2706 return file_tty(file) != t ? 0 : fd + 1;
2707}
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728void __do_SAK(struct tty_struct *tty)
2729{
2730#ifdef TTY_SOFT_SAK
2731 tty_hangup(tty);
2732#else
2733 struct task_struct *g, *p;
2734 struct pid *session;
2735 int i;
2736
2737 if (!tty)
2738 return;
2739 session = tty->session;
2740
2741 tty_ldisc_flush(tty);
2742
2743 tty_driver_flush_buffer(tty);
2744
2745 read_lock(&tasklist_lock);
2746
2747 do_each_pid_task(session, PIDTYPE_SID, p) {
2748 tty_notice(tty, "SAK: killed process %d (%s): by session\n",
2749 task_pid_nr(p), p->comm);
2750 send_sig(SIGKILL, p, 1);
2751 } while_each_pid_task(session, PIDTYPE_SID, p);
2752
2753
2754 do_each_thread(g, p) {
2755 if (p->signal->tty == tty) {
2756 tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n",
2757 task_pid_nr(p), p->comm);
2758 send_sig(SIGKILL, p, 1);
2759 continue;
2760 }
2761 task_lock(p);
2762 i = iterate_fd(p->files, 0, this_tty, tty);
2763 if (i != 0) {
2764 tty_notice(tty, "SAK: killed process %d (%s): by fd#%d\n",
2765 task_pid_nr(p), p->comm, i - 1);
2766 force_sig(SIGKILL, p);
2767 }
2768 task_unlock(p);
2769 } while_each_thread(g, p);
2770 read_unlock(&tasklist_lock);
2771#endif
2772}
2773
2774static void do_SAK_work(struct work_struct *work)
2775{
2776 struct tty_struct *tty =
2777 container_of(work, struct tty_struct, SAK_work);
2778 __do_SAK(tty);
2779}
2780
2781
2782
2783
2784
2785
2786
2787void do_SAK(struct tty_struct *tty)
2788{
2789 if (!tty)
2790 return;
2791 schedule_work(&tty->SAK_work);
2792}
2793
2794EXPORT_SYMBOL(do_SAK);
2795
2796static int dev_match_devt(struct device *dev, const void *data)
2797{
2798 const dev_t *devt = data;
2799 return dev->devt == *devt;
2800}
2801
2802
2803static struct device *tty_get_device(struct tty_struct *tty)
2804{
2805 dev_t devt = tty_devnum(tty);
2806 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2807}
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
2819{
2820 struct tty_struct *tty;
2821
2822 tty = kzalloc(sizeof(*tty), GFP_KERNEL);
2823 if (!tty)
2824 return NULL;
2825
2826 kref_init(&tty->kref);
2827 tty->magic = TTY_MAGIC;
2828 if (tty_ldisc_init(tty)) {
2829 kfree(tty);
2830 return NULL;
2831 }
2832 tty->session = NULL;
2833 tty->pgrp = NULL;
2834 mutex_init(&tty->legacy_mutex);
2835 mutex_init(&tty->throttle_mutex);
2836 init_rwsem(&tty->termios_rwsem);
2837 mutex_init(&tty->winsize_mutex);
2838 init_ldsem(&tty->ldisc_sem);
2839 init_waitqueue_head(&tty->write_wait);
2840 init_waitqueue_head(&tty->read_wait);
2841 INIT_WORK(&tty->hangup_work, do_tty_hangup);
2842 mutex_init(&tty->atomic_write_lock);
2843 spin_lock_init(&tty->ctrl_lock);
2844 spin_lock_init(&tty->flow_lock);
2845 spin_lock_init(&tty->files_lock);
2846 INIT_LIST_HEAD(&tty->tty_files);
2847 INIT_WORK(&tty->SAK_work, do_SAK_work);
2848
2849 tty->driver = driver;
2850 tty->ops = driver->ops;
2851 tty->index = idx;
2852 tty_line_name(driver, idx, tty->name);
2853 tty->dev = tty_get_device(tty);
2854
2855 return tty;
2856}
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870int tty_put_char(struct tty_struct *tty, unsigned char ch)
2871{
2872 if (tty->ops->put_char)
2873 return tty->ops->put_char(tty, ch);
2874 return tty->ops->write(tty, &ch, 1);
2875}
2876EXPORT_SYMBOL_GPL(tty_put_char);
2877
2878struct class *tty_class;
2879
2880static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
2881 unsigned int index, unsigned int count)
2882{
2883 int err;
2884
2885
2886 driver->cdevs[index] = cdev_alloc();
2887 if (!driver->cdevs[index])
2888 return -ENOMEM;
2889 driver->cdevs[index]->ops = &tty_fops;
2890 driver->cdevs[index]->owner = driver->owner;
2891 err = cdev_add(driver->cdevs[index], dev, count);
2892 if (err)
2893 kobject_put(&driver->cdevs[index]->kobj);
2894 return err;
2895}
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2917 struct device *device)
2918{
2919 return tty_register_device_attr(driver, index, device, NULL, NULL);
2920}
2921EXPORT_SYMBOL(tty_register_device);
2922
2923static void tty_device_create_release(struct device *dev)
2924{
2925 dev_dbg(dev, "releasing...\n");
2926 kfree(dev);
2927}
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949struct device *tty_register_device_attr(struct tty_driver *driver,
2950 unsigned index, struct device *device,
2951 void *drvdata,
2952 const struct attribute_group **attr_grp)
2953{
2954 char name[64];
2955 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
2956 struct ktermios *tp;
2957 struct device *dev;
2958 int retval;
2959
2960 if (index >= driver->num) {
2961 pr_err("%s: Attempt to register invalid tty line number (%d)\n",
2962 driver->name, index);
2963 return ERR_PTR(-EINVAL);
2964 }
2965
2966 if (driver->type == TTY_DRIVER_TYPE_PTY)
2967 pty_line_name(driver, index, name);
2968 else
2969 tty_line_name(driver, index, name);
2970
2971 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2972 if (!dev)
2973 return ERR_PTR(-ENOMEM);
2974
2975 dev->devt = devt;
2976 dev->class = tty_class;
2977 dev->parent = device;
2978 dev->release = tty_device_create_release;
2979 dev_set_name(dev, "%s", name);
2980 dev->groups = attr_grp;
2981 dev_set_drvdata(dev, drvdata);
2982
2983 dev_set_uevent_suppress(dev, 1);
2984
2985 retval = device_register(dev);
2986 if (retval)
2987 goto err_put;
2988
2989 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
2990
2991
2992
2993
2994 tp = driver->termios[index];
2995 if (tp) {
2996 driver->termios[index] = NULL;
2997 kfree(tp);
2998 }
2999
3000 retval = tty_cdev_add(driver, devt, index, 1);
3001 if (retval)
3002 goto err_del;
3003 }
3004
3005 dev_set_uevent_suppress(dev, 0);
3006 kobject_uevent(&dev->kobj, KOBJ_ADD);
3007
3008 return dev;
3009
3010err_del:
3011 device_del(dev);
3012err_put:
3013 put_device(dev);
3014
3015 return ERR_PTR(retval);
3016}
3017EXPORT_SYMBOL_GPL(tty_register_device_attr);
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030void tty_unregister_device(struct tty_driver *driver, unsigned index)
3031{
3032 device_destroy(tty_class,
3033 MKDEV(driver->major, driver->minor_start) + index);
3034 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3035 cdev_del(driver->cdevs[index]);
3036 driver->cdevs[index] = NULL;
3037 }
3038}
3039EXPORT_SYMBOL(tty_unregister_device);
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3051 unsigned long flags)
3052{
3053 struct tty_driver *driver;
3054 unsigned int cdevs = 1;
3055 int err;
3056
3057 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
3058 return ERR_PTR(-EINVAL);
3059
3060 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
3061 if (!driver)
3062 return ERR_PTR(-ENOMEM);
3063
3064 kref_init(&driver->kref);
3065 driver->magic = TTY_DRIVER_MAGIC;
3066 driver->num = lines;
3067 driver->owner = owner;
3068 driver->flags = flags;
3069
3070 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3071 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3072 GFP_KERNEL);
3073 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3074 GFP_KERNEL);
3075 if (!driver->ttys || !driver->termios) {
3076 err = -ENOMEM;
3077 goto err_free_all;
3078 }
3079 }
3080
3081 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3082 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3083 GFP_KERNEL);
3084 if (!driver->ports) {
3085 err = -ENOMEM;
3086 goto err_free_all;
3087 }
3088 cdevs = lines;
3089 }
3090
3091 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3092 if (!driver->cdevs) {
3093 err = -ENOMEM;
3094 goto err_free_all;
3095 }
3096
3097 return driver;
3098err_free_all:
3099 kfree(driver->ports);
3100 kfree(driver->ttys);
3101 kfree(driver->termios);
3102 kfree(driver->cdevs);
3103 kfree(driver);
3104 return ERR_PTR(err);
3105}
3106EXPORT_SYMBOL(__tty_alloc_driver);
3107
3108static void destruct_tty_driver(struct kref *kref)
3109{
3110 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3111 int i;
3112 struct ktermios *tp;
3113
3114 if (driver->flags & TTY_DRIVER_INSTALLED) {
3115 for (i = 0; i < driver->num; i++) {
3116 tp = driver->termios[i];
3117 if (tp) {
3118 driver->termios[i] = NULL;
3119 kfree(tp);
3120 }
3121 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3122 tty_unregister_device(driver, i);
3123 }
3124 proc_tty_unregister_driver(driver);
3125 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3126 cdev_del(driver->cdevs[0]);
3127 }
3128 kfree(driver->cdevs);
3129 kfree(driver->ports);
3130 kfree(driver->termios);
3131 kfree(driver->ttys);
3132 kfree(driver);
3133}
3134
3135void tty_driver_kref_put(struct tty_driver *driver)
3136{
3137 kref_put(&driver->kref, destruct_tty_driver);
3138}
3139EXPORT_SYMBOL(tty_driver_kref_put);
3140
3141void tty_set_operations(struct tty_driver *driver,
3142 const struct tty_operations *op)
3143{
3144 driver->ops = op;
3145};
3146EXPORT_SYMBOL(tty_set_operations);
3147
3148void put_tty_driver(struct tty_driver *d)
3149{
3150 tty_driver_kref_put(d);
3151}
3152EXPORT_SYMBOL(put_tty_driver);
3153
3154
3155
3156
3157int tty_register_driver(struct tty_driver *driver)
3158{
3159 int error;
3160 int i;
3161 dev_t dev;
3162 struct device *d;
3163
3164 if (!driver->major) {
3165 error = alloc_chrdev_region(&dev, driver->minor_start,
3166 driver->num, driver->name);
3167 if (!error) {
3168 driver->major = MAJOR(dev);
3169 driver->minor_start = MINOR(dev);
3170 }
3171 } else {
3172 dev = MKDEV(driver->major, driver->minor_start);
3173 error = register_chrdev_region(dev, driver->num, driver->name);
3174 }
3175 if (error < 0)
3176 goto err;
3177
3178 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3179 error = tty_cdev_add(driver, dev, 0, driver->num);
3180 if (error)
3181 goto err_unreg_char;
3182 }
3183
3184 mutex_lock(&tty_mutex);
3185 list_add(&driver->tty_drivers, &tty_drivers);
3186 mutex_unlock(&tty_mutex);
3187
3188 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
3189 for (i = 0; i < driver->num; i++) {
3190 d = tty_register_device(driver, i, NULL);
3191 if (IS_ERR(d)) {
3192 error = PTR_ERR(d);
3193 goto err_unreg_devs;
3194 }
3195 }
3196 }
3197 proc_tty_register_driver(driver);
3198 driver->flags |= TTY_DRIVER_INSTALLED;
3199 return 0;
3200
3201err_unreg_devs:
3202 for (i--; i >= 0; i--)
3203 tty_unregister_device(driver, i);
3204
3205 mutex_lock(&tty_mutex);
3206 list_del(&driver->tty_drivers);
3207 mutex_unlock(&tty_mutex);
3208
3209err_unreg_char:
3210 unregister_chrdev_region(dev, driver->num);
3211err:
3212 return error;
3213}
3214EXPORT_SYMBOL(tty_register_driver);
3215
3216
3217
3218
3219int tty_unregister_driver(struct tty_driver *driver)
3220{
3221#if 0
3222
3223 if (driver->refcount)
3224 return -EBUSY;
3225#endif
3226 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3227 driver->num);
3228 mutex_lock(&tty_mutex);
3229 list_del(&driver->tty_drivers);
3230 mutex_unlock(&tty_mutex);
3231 return 0;
3232}
3233
3234EXPORT_SYMBOL(tty_unregister_driver);
3235
3236dev_t tty_devnum(struct tty_struct *tty)
3237{
3238 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3239}
3240EXPORT_SYMBOL(tty_devnum);
3241
3242void tty_default_fops(struct file_operations *fops)
3243{
3244 *fops = tty_fops;
3245}
3246
3247static char *tty_devnode(struct device *dev, umode_t *mode)
3248{
3249 if (!mode)
3250 return NULL;
3251 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3252 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3253 *mode = 0666;
3254 return NULL;
3255}
3256
3257static int __init tty_class_init(void)
3258{
3259 tty_class = class_create(THIS_MODULE, "tty");
3260 if (IS_ERR(tty_class))
3261 return PTR_ERR(tty_class);
3262 tty_class->devnode = tty_devnode;
3263 return 0;
3264}
3265
3266postcore_initcall(tty_class_init);
3267
3268
3269static struct cdev tty_cdev, console_cdev;
3270
3271static ssize_t show_cons_active(struct device *dev,
3272 struct device_attribute *attr, char *buf)
3273{
3274 struct console *cs[16];
3275 int i = 0;
3276 struct console *c;
3277 ssize_t count = 0;
3278
3279 console_lock();
3280 for_each_console(c) {
3281 if (!c->device)
3282 continue;
3283 if (!c->write)
3284 continue;
3285 if ((c->flags & CON_ENABLED) == 0)
3286 continue;
3287 cs[i++] = c;
3288 if (i >= ARRAY_SIZE(cs))
3289 break;
3290 }
3291 while (i--) {
3292 int index = cs[i]->index;
3293 struct tty_driver *drv = cs[i]->device(cs[i], &index);
3294
3295
3296 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
3297 count += tty_line_name(drv, index, buf + count);
3298 else
3299 count += sprintf(buf + count, "%s%d",
3300 cs[i]->name, cs[i]->index);
3301
3302 count += sprintf(buf + count, "%c", i ? ' ':'\n');
3303 }
3304 console_unlock();
3305
3306 return count;
3307}
3308static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3309
3310static struct attribute *cons_dev_attrs[] = {
3311 &dev_attr_active.attr,
3312 NULL
3313};
3314
3315ATTRIBUTE_GROUPS(cons_dev);
3316
3317static struct device *consdev;
3318
3319void console_sysfs_notify(void)
3320{
3321 if (consdev)
3322 sysfs_notify(&consdev->kobj, NULL, "active");
3323}
3324
3325
3326
3327
3328
3329int __init tty_init(void)
3330{
3331 cdev_init(&tty_cdev, &tty_fops);
3332 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3333 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3334 panic("Couldn't register /dev/tty driver\n");
3335 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3336
3337 cdev_init(&console_cdev, &console_fops);
3338 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3339 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3340 panic("Couldn't register /dev/console driver\n");
3341 consdev = device_create_with_groups(tty_class, NULL,
3342 MKDEV(TTYAUX_MAJOR, 1), NULL,
3343 cons_dev_groups, "console");
3344 if (IS_ERR(consdev))
3345 consdev = NULL;
3346
3347#ifdef CONFIG_VT
3348 vty_init(&console_fops);
3349#endif
3350 return 0;
3351}
3352
3353