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