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