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