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