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