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