2 * linux/drivers/char/tty_io.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
8 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9 * or rs-channels. It also implements echoing, cooked mode etc.
11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
13 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14 * tty_struct and tty_queue structures. Previously there was an array
15 * of 256 tty_struct's which was statically allocated, and the
16 * tty_queue structures were allocated at boot time. Both are now
17 * dynamically allocated only when the tty is open.
19 * Also restructured routines so that there is more of a separation
20 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21 * the low-level tty routines (serial.c, pty.c, console.c). This
22 * makes for cleaner and more compact code. -TYT, 9/17/92
24 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25 * which can be dynamically activated and de-activated by the line
26 * discipline handling modules (like SLIP).
28 * NOTE: pay no attention to the line discipline code (yet); its
29 * interface is still subject to change in this version...
32 * Added functionality to the OPOST tty handling. No delays, but all
33 * other bits should be there.
34 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
36 * Rewrote canonical mode and added more termios flags.
37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
39 * Reorganized FASYNC support so mouse code can share it.
40 * -- ctm@ardi.com, 9Sep95
42 * New TIOCLINUX variants added.
43 * -- mj@k332.feld.cvut.cz, 19-Nov-95
45 * Restrict vt switching via ioctl()
46 * -- grif@cs.ucr.edu, 5-Dec-95
48 * Move console and virtual terminal code to more appropriate files,
49 * implement CONFIG_VT and generalize console device interface.
50 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
52 * Rewrote init_dev and release_dev to eliminate races.
53 * -- Bill Hawes <whawes@star.net>, June 97
55 * Added devfs support.
56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
58 * Added support for a Unix98-style ptmx device.
59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
61 * Reduced memory usage for older ARM systems
62 * -- Russell King <rmk@arm.linux.org.uk>
64 * Move do_SAK() into process context. Less stack use in devfs functions.
65 * alloc_tty_struct() always uses kmalloc() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
68 #include <linux/config.h>
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/console.h>
82 #include <linux/timer.h>
83 #include <linux/ctype.h>
86 #include <linux/string.h>
87 #include <linux/slab.h>
88 #include <linux/poll.h>
89 #include <linux/proc_fs.h>
90 #include <linux/init.h>
91 #include <linux/module.h>
92 #include <linux/smp_lock.h>
93 #include <linux/device.h>
94 #include <linux/idr.h>
95 #include <linux/wait.h>
96 #include <linux/bitops.h>
97 #include <linux/delay.h>
99 #include <asm/uaccess.h>
100 #include <asm/system.h>
102 #include <linux/kbd_kern.h>
103 #include <linux/vt_kern.h>
104 #include <linux/selection.h>
105 #include <linux/devfs_fs_kernel.h>
107 #include <linux/kmod.h>
109 #undef TTY_DEBUG_HANGUP
111 #define TTY_PARANOIA_CHECK 1
112 #define CHECK_TTY_COUNT 1
114 struct termios tty_std_termios = { /* for the benefit of tty drivers */
115 .c_iflag = ICRNL | IXON,
116 .c_oflag = OPOST | ONLCR,
117 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
118 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
119 ECHOCTL | ECHOKE | IEXTEN,
123 EXPORT_SYMBOL(tty_std_termios);
125 /* This list gets poked at by procfs and various bits of boot up code. This
126 could do with some rationalisation such as pulling the tty proc function
129 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131 /* Semaphore to protect creating and releasing a tty. This is shared with
132 vt.c for deeply disgusting hack reasons */
133 DECLARE_MUTEX(tty_sem);
135 #ifdef CONFIG_UNIX98_PTYS
136 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
137 extern int pty_limit; /* Config limit on Unix98 ptys */
138 static DEFINE_IDR(allocated_ptys);
139 static DECLARE_MUTEX(allocated_ptys_lock);
140 static int ptmx_open(struct inode *, struct file *);
143 extern void disable_early_printk(void);
145 static void initialize_tty_struct(struct tty_struct *tty);
147 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
148 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
149 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
150 static unsigned int tty_poll(struct file *, poll_table *);
151 static int tty_open(struct inode *, struct file *);
152 static int tty_release(struct inode *, struct file *);
153 int tty_ioctl(struct inode * inode, struct file * file,
154 unsigned int cmd, unsigned long arg);
155 static int tty_fasync(int fd, struct file * filp, int on);
156 static void release_mem(struct tty_struct *tty, int idx);
159 static struct tty_struct *alloc_tty_struct(void)
161 struct tty_struct *tty;
163 tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
165 memset(tty, 0, sizeof(struct tty_struct));
169 static inline void free_tty_struct(struct tty_struct *tty)
171 kfree(tty->write_buf);
175 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
177 char *tty_name(struct tty_struct *tty, char *buf)
179 if (!tty) /* Hmm. NULL pointer. That's fun. */
180 strcpy(buf, "NULL tty");
182 strcpy(buf, tty->name);
186 EXPORT_SYMBOL(tty_name);
188 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
191 #ifdef TTY_PARANOIA_CHECK
194 "null TTY for (%d:%d) in %s\n",
195 imajor(inode), iminor(inode), routine);
198 if (tty->magic != TTY_MAGIC) {
200 "bad magic number for tty struct (%d:%d) in %s\n",
201 imajor(inode), iminor(inode), routine);
208 static int check_tty_count(struct tty_struct *tty, const char *routine)
210 #ifdef CHECK_TTY_COUNT
215 list_for_each(p, &tty->tty_files) {
219 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
220 tty->driver->subtype == PTY_TYPE_SLAVE &&
221 tty->link && tty->link->count)
223 if (tty->count != count) {
224 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
225 "!= #fd's(%d) in %s\n",
226 tty->name, tty->count, count, routine);
234 * This is probably overkill for real world processors but
235 * they are not on hot paths so a little discipline won't do
239 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
241 down(&tty->termios_sem);
242 tty->termios->c_line = num;
243 up(&tty->termios_sem);
247 * This guards the refcounted line discipline lists. The lock
248 * must be taken with irqs off because there are hangup path
249 * callers who will do ldisc lookups and cannot sleep.
252 static DEFINE_SPINLOCK(tty_ldisc_lock);
253 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
254 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
256 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
261 if (disc < N_TTY || disc >= NR_LDISCS)
264 spin_lock_irqsave(&tty_ldisc_lock, flags);
265 tty_ldiscs[disc] = *new_ldisc;
266 tty_ldiscs[disc].num = disc;
267 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
268 tty_ldiscs[disc].refcount = 0;
269 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
273 EXPORT_SYMBOL(tty_register_ldisc);
275 int tty_unregister_ldisc(int disc)
280 if (disc < N_TTY || disc >= NR_LDISCS)
283 spin_lock_irqsave(&tty_ldisc_lock, flags);
284 if (tty_ldiscs[disc].refcount)
287 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
288 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
292 EXPORT_SYMBOL(tty_unregister_ldisc);
294 struct tty_ldisc *tty_ldisc_get(int disc)
297 struct tty_ldisc *ld;
299 if (disc < N_TTY || disc >= NR_LDISCS)
302 spin_lock_irqsave(&tty_ldisc_lock, flags);
304 ld = &tty_ldiscs[disc];
305 /* Check the entry is defined */
306 if(ld->flags & LDISC_FLAG_DEFINED)
308 /* If the module is being unloaded we can't use it */
309 if (!try_module_get(ld->owner))
316 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
320 EXPORT_SYMBOL_GPL(tty_ldisc_get);
322 void tty_ldisc_put(int disc)
324 struct tty_ldisc *ld;
327 if (disc < N_TTY || disc >= NR_LDISCS)
330 spin_lock_irqsave(&tty_ldisc_lock, flags);
331 ld = &tty_ldiscs[disc];
332 if(ld->refcount == 0)
335 module_put(ld->owner);
336 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
339 EXPORT_SYMBOL_GPL(tty_ldisc_put);
341 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
344 tty->ldisc.refcount = 0;
348 * tty_ldisc_try - internal helper
351 * Make a single attempt to grab and bump the refcount on
352 * the tty ldisc. Return 0 on failure or 1 on success. This is
353 * used to implement both the waiting and non waiting versions
357 static int tty_ldisc_try(struct tty_struct *tty)
360 struct tty_ldisc *ld;
363 spin_lock_irqsave(&tty_ldisc_lock, flags);
365 if(test_bit(TTY_LDISC, &tty->flags))
370 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
375 * tty_ldisc_ref_wait - wait for the tty ldisc
378 * Dereference the line discipline for the terminal and take a
379 * reference to it. If the line discipline is in flux then
380 * wait patiently until it changes.
382 * Note: Must not be called from an IRQ/timer context. The caller
383 * must also be careful not to hold other locks that will deadlock
384 * against a discipline change, such as an existing ldisc reference
385 * (which we check for)
388 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
390 /* wait_event is a macro */
391 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
392 if(tty->ldisc.refcount == 0)
393 printk(KERN_ERR "tty_ldisc_ref_wait\n");
397 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
400 * tty_ldisc_ref - get the tty ldisc
403 * Dereference the line discipline for the terminal and take a
404 * reference to it. If the line discipline is in flux then
405 * return NULL. Can be called from IRQ and timer functions.
408 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
410 if(tty_ldisc_try(tty))
415 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
418 * tty_ldisc_deref - free a tty ldisc reference
419 * @ld: reference to free up
421 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
422 * be called in IRQ context.
425 void tty_ldisc_deref(struct tty_ldisc *ld)
432 spin_lock_irqsave(&tty_ldisc_lock, flags);
433 if(ld->refcount == 0)
434 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
437 if(ld->refcount == 0)
438 wake_up(&tty_ldisc_wait);
439 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
442 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
445 * tty_ldisc_enable - allow ldisc use
446 * @tty: terminal to activate ldisc on
448 * Set the TTY_LDISC flag when the line discipline can be called
449 * again. Do neccessary wakeups for existing sleepers.
451 * Note: nobody should set this bit except via this function. Clearing
452 * directly is allowed.
455 static void tty_ldisc_enable(struct tty_struct *tty)
457 set_bit(TTY_LDISC, &tty->flags);
458 wake_up(&tty_ldisc_wait);
462 * tty_set_ldisc - set line discipline
463 * @tty: the terminal to set
464 * @ldisc: the line discipline
466 * Set the discipline of a tty line. Must be called from a process
470 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
473 struct tty_ldisc o_ldisc;
477 struct tty_ldisc *ld;
478 struct tty_struct *o_tty;
480 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
485 ld = tty_ldisc_get(ldisc);
486 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
487 /* Cyrus Durgin <cider@speakeasy.org> */
489 request_module("tty-ldisc-%d", ldisc);
490 ld = tty_ldisc_get(ldisc);
495 tty_wait_until_sent(tty, 0);
497 if (tty->ldisc.num == ldisc) {
498 tty_ldisc_put(ldisc);
502 o_ldisc = tty->ldisc;
506 * Make sure we don't change while someone holds a
507 * reference to the line discipline. The TTY_LDISC bit
508 * prevents anyone taking a reference once it is clear.
509 * We need the lock to avoid racing reference takers.
512 spin_lock_irqsave(&tty_ldisc_lock, flags);
513 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
514 if(tty->ldisc.refcount) {
515 /* Free the new ldisc we grabbed. Must drop the lock
517 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
518 tty_ldisc_put(ldisc);
520 * There are several reasons we may be busy, including
521 * random momentary I/O traffic. We must therefore
522 * retry. We could distinguish between blocking ops
523 * and retries if we made tty_ldisc_wait() smarter. That
524 * is up for discussion.
526 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
530 if(o_tty && o_tty->ldisc.refcount) {
531 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
532 tty_ldisc_put(ldisc);
533 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
539 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
541 if (!test_bit(TTY_LDISC, &tty->flags)) {
542 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
543 tty_ldisc_put(ldisc);
544 ld = tty_ldisc_ref_wait(tty);
549 clear_bit(TTY_LDISC, &tty->flags);
550 clear_bit(TTY_DONT_FLIP, &tty->flags);
552 clear_bit(TTY_LDISC, &o_tty->flags);
553 clear_bit(TTY_DONT_FLIP, &o_tty->flags);
555 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
558 * From this point on we know nobody has an ldisc
559 * usage reference, nor can they obtain one until
560 * we say so later on.
563 work = cancel_delayed_work(&tty->flip.work);
565 * Wait for ->hangup_work and ->flip.work handlers to terminate
568 flush_scheduled_work();
569 /* Shutdown the current discipline. */
570 if (tty->ldisc.close)
571 (tty->ldisc.close)(tty);
573 /* Now set up the new line discipline. */
574 tty_ldisc_assign(tty, ld);
575 tty_set_termios_ldisc(tty, ldisc);
577 retval = (tty->ldisc.open)(tty);
579 tty_ldisc_put(ldisc);
580 /* There is an outstanding reference here so this is safe */
581 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
582 tty_set_termios_ldisc(tty, tty->ldisc.num);
583 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
584 tty_ldisc_put(o_ldisc.num);
585 /* This driver is always present */
586 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
587 tty_set_termios_ldisc(tty, N_TTY);
588 if (tty->ldisc.open) {
589 int r = tty->ldisc.open(tty);
592 panic("Couldn't open N_TTY ldisc for "
594 tty_name(tty, buf), r);
598 /* At this point we hold a reference to the new ldisc and a
599 a reference to the old ldisc. If we ended up flipping back
600 to the existing ldisc we have two references to it */
602 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
603 tty->driver->set_ldisc(tty);
605 tty_ldisc_put(o_ldisc.num);
608 * Allow ldisc referencing to occur as soon as the driver
609 * ldisc callback completes.
612 tty_ldisc_enable(tty);
614 tty_ldisc_enable(o_tty);
616 /* Restart it in case no characters kick it off. Safe if
619 schedule_delayed_work(&tty->flip.work, 1);
624 * This routine returns a tty driver structure, given a device number
626 static struct tty_driver *get_tty_driver(dev_t device, int *index)
628 struct tty_driver *p;
630 list_for_each_entry(p, &tty_drivers, tty_drivers) {
631 dev_t base = MKDEV(p->major, p->minor_start);
632 if (device < base || device >= base + p->num)
634 *index = device - base;
641 * If we try to write to, or set the state of, a terminal and we're
642 * not in the foreground, send a SIGTTOU. If the signal is blocked or
643 * ignored, go ahead and perform the operation. (POSIX 7.2)
645 int tty_check_change(struct tty_struct * tty)
647 if (current->signal->tty != tty)
649 if (tty->pgrp <= 0) {
650 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
653 if (process_group(current) == tty->pgrp)
655 if (is_ignored(SIGTTOU))
657 if (is_orphaned_pgrp(process_group(current)))
659 (void) kill_pg(process_group(current), SIGTTOU, 1);
663 EXPORT_SYMBOL(tty_check_change);
665 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
666 size_t count, loff_t *ppos)
671 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
672 size_t count, loff_t *ppos)
677 /* No kernel lock held - none needed ;) */
678 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
680 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
683 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
684 unsigned int cmd, unsigned long arg)
686 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
689 static struct file_operations tty_fops = {
696 .release = tty_release,
697 .fasync = tty_fasync,
700 #ifdef CONFIG_UNIX98_PTYS
701 static struct file_operations ptmx_fops = {
708 .release = tty_release,
709 .fasync = tty_fasync,
713 static struct file_operations console_fops = {
716 .write = redirected_tty_write,
720 .release = tty_release,
721 .fasync = tty_fasync,
724 static struct file_operations hung_up_tty_fops = {
726 .read = hung_up_tty_read,
727 .write = hung_up_tty_write,
728 .poll = hung_up_tty_poll,
729 .ioctl = hung_up_tty_ioctl,
730 .release = tty_release,
733 static DEFINE_SPINLOCK(redirect_lock);
734 static struct file *redirect;
737 * tty_wakeup - request more data
740 * Internal and external helper for wakeups of tty. This function
741 * informs the line discipline if present that the driver is ready
742 * to receive more output data.
745 void tty_wakeup(struct tty_struct *tty)
747 struct tty_ldisc *ld;
749 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
750 ld = tty_ldisc_ref(tty);
753 ld->write_wakeup(tty);
757 wake_up_interruptible(&tty->write_wait);
760 EXPORT_SYMBOL_GPL(tty_wakeup);
763 * tty_ldisc_flush - flush line discipline queue
766 * Flush the line discipline queue (if any) for this tty. If there
767 * is no line discipline active this is a no-op.
770 void tty_ldisc_flush(struct tty_struct *tty)
772 struct tty_ldisc *ld = tty_ldisc_ref(tty);
775 ld->flush_buffer(tty);
780 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
783 * This can be called by the "eventd" kernel thread. That is process synchronous,
784 * but doesn't hold any locks, so we need to make sure we have the appropriate
785 * locks for what we're doing..
787 static void do_tty_hangup(void *data)
789 struct tty_struct *tty = (struct tty_struct *) data;
790 struct file * cons_filp = NULL;
791 struct file *filp, *f = NULL;
792 struct task_struct *p;
793 struct tty_ldisc *ld;
794 int closecount = 0, n;
799 /* inuse_filps is protected by the single kernel lock */
802 spin_lock(&redirect_lock);
803 if (redirect && redirect->private_data == tty) {
807 spin_unlock(&redirect_lock);
809 check_tty_count(tty, "do_tty_hangup");
811 /* This breaks for file handles being sent over AF_UNIX sockets ? */
812 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
813 if (filp->f_op->write == redirected_tty_write)
815 if (filp->f_op->write != tty_write)
818 tty_fasync(-1, filp, 0); /* can't block */
819 filp->f_op = &hung_up_tty_fops;
823 /* FIXME! What are the locking issues here? This may me overdoing things..
824 * this question is especially important now that we've removed the irqlock. */
826 ld = tty_ldisc_ref(tty);
827 if(ld != NULL) /* We may have no line discipline at this point */
829 if (ld->flush_buffer)
830 ld->flush_buffer(tty);
831 if (tty->driver->flush_buffer)
832 tty->driver->flush_buffer(tty);
833 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
835 ld->write_wakeup(tty);
840 /* FIXME: Once we trust the LDISC code better we can wait here for
841 ldisc completion and fix the driver call race */
843 wake_up_interruptible(&tty->write_wait);
844 wake_up_interruptible(&tty->read_wait);
847 * Shutdown the current line discipline, and reset it to
850 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
852 down(&tty->termios_sem);
853 *tty->termios = tty->driver->init_termios;
854 up(&tty->termios_sem);
857 /* Defer ldisc switch */
858 /* tty_deferred_ldisc_switch(N_TTY);
860 This should get done automatically when the port closes and
861 tty_release is called */
863 read_lock(&tasklist_lock);
864 if (tty->session > 0) {
865 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
866 if (p->signal->tty == tty)
867 p->signal->tty = NULL;
868 if (!p->signal->leader)
870 send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
871 send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
873 p->signal->tty_old_pgrp = tty->pgrp;
874 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
876 read_unlock(&tasklist_lock);
881 tty->ctrl_status = 0;
883 * If one of the devices matches a console pointer, we
884 * cannot just call hangup() because that will cause
885 * tty->count and state->count to go out of sync.
886 * So we just call close() the right number of times.
889 if (tty->driver->close)
890 for (n = 0; n < closecount; n++)
891 tty->driver->close(tty, cons_filp);
892 } else if (tty->driver->hangup)
893 (tty->driver->hangup)(tty);
895 /* We don't want to have driver/ldisc interactions beyond
896 the ones we did here. The driver layer expects no
897 calls after ->hangup() from the ldisc side. However we
898 can't yet guarantee all that */
900 set_bit(TTY_HUPPED, &tty->flags);
902 tty_ldisc_enable(tty);
910 void tty_hangup(struct tty_struct * tty)
912 #ifdef TTY_DEBUG_HANGUP
915 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
917 schedule_work(&tty->hangup_work);
920 EXPORT_SYMBOL(tty_hangup);
922 void tty_vhangup(struct tty_struct * tty)
924 #ifdef TTY_DEBUG_HANGUP
927 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
929 do_tty_hangup((void *) tty);
931 EXPORT_SYMBOL(tty_vhangup);
933 int tty_hung_up_p(struct file * filp)
935 return (filp->f_op == &hung_up_tty_fops);
938 EXPORT_SYMBOL(tty_hung_up_p);
941 * This function is typically called only by the session leader, when
942 * it wants to disassociate itself from its controlling tty.
944 * It performs the following functions:
945 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
946 * (2) Clears the tty from being controlling the session
947 * (3) Clears the controlling tty for all processes in the
950 * The argument on_exit is set to 1 if called when a process is
951 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
953 void disassociate_ctty(int on_exit)
955 struct tty_struct *tty;
956 struct task_struct *p;
962 tty = current->signal->tty;
964 tty_pgrp = tty->pgrp;
966 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
969 if (current->signal->tty_old_pgrp) {
970 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
971 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
978 kill_pg(tty_pgrp, SIGHUP, on_exit);
980 kill_pg(tty_pgrp, SIGCONT, on_exit);
983 /* Must lock changes to tty_old_pgrp */
985 current->signal->tty_old_pgrp = 0;
989 /* Now clear signal->tty under the lock */
990 read_lock(&tasklist_lock);
991 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
992 p->signal->tty = NULL;
993 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
994 read_unlock(&tasklist_lock);
999 void stop_tty(struct tty_struct *tty)
1004 if (tty->link && tty->link->packet) {
1005 tty->ctrl_status &= ~TIOCPKT_START;
1006 tty->ctrl_status |= TIOCPKT_STOP;
1007 wake_up_interruptible(&tty->link->read_wait);
1009 if (tty->driver->stop)
1010 (tty->driver->stop)(tty);
1013 EXPORT_SYMBOL(stop_tty);
1015 void start_tty(struct tty_struct *tty)
1017 if (!tty->stopped || tty->flow_stopped)
1020 if (tty->link && tty->link->packet) {
1021 tty->ctrl_status &= ~TIOCPKT_STOP;
1022 tty->ctrl_status |= TIOCPKT_START;
1023 wake_up_interruptible(&tty->link->read_wait);
1025 if (tty->driver->start)
1026 (tty->driver->start)(tty);
1028 /* If we have a running line discipline it may need kicking */
1030 wake_up_interruptible(&tty->write_wait);
1033 EXPORT_SYMBOL(start_tty);
1035 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1039 struct tty_struct * tty;
1040 struct inode *inode;
1041 struct tty_ldisc *ld;
1043 tty = (struct tty_struct *)file->private_data;
1044 inode = file->f_dentry->d_inode;
1045 if (tty_paranoia_check(tty, inode, "tty_read"))
1047 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1050 /* We want to wait for the line discipline to sort out in this
1052 ld = tty_ldisc_ref_wait(tty);
1055 i = (ld->read)(tty,file,buf,count);
1058 tty_ldisc_deref(ld);
1061 inode->i_atime = current_fs_time(inode->i_sb);
1066 * Split writes up in sane blocksizes to avoid
1067 * denial-of-service type attacks
1069 static inline ssize_t do_tty_write(
1070 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1071 struct tty_struct *tty,
1073 const char __user *buf,
1076 ssize_t ret = 0, written = 0;
1079 if (down_interruptible(&tty->atomic_write)) {
1080 return -ERESTARTSYS;
1084 * We chunk up writes into a temporary buffer. This
1085 * simplifies low-level drivers immensely, since they
1086 * don't have locking issues and user mode accesses.
1088 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1091 * The default chunk-size is 2kB, because the NTTY
1092 * layer has problems with bigger chunks. It will
1093 * claim to be able to handle more characters than
1097 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1102 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1103 if (tty->write_cnt < chunk) {
1109 buf = kmalloc(chunk, GFP_KERNEL);
1111 up(&tty->atomic_write);
1114 kfree(tty->write_buf);
1115 tty->write_cnt = chunk;
1116 tty->write_buf = buf;
1119 /* Do the write .. */
1121 size_t size = count;
1125 if (copy_from_user(tty->write_buf, buf, size))
1128 ret = write(tty, file, tty->write_buf, size);
1138 if (signal_pending(current))
1143 struct inode *inode = file->f_dentry->d_inode;
1144 inode->i_mtime = current_fs_time(inode->i_sb);
1147 up(&tty->atomic_write);
1152 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1155 struct tty_struct * tty;
1156 struct inode *inode = file->f_dentry->d_inode;
1158 struct tty_ldisc *ld;
1160 tty = (struct tty_struct *)file->private_data;
1161 if (tty_paranoia_check(tty, inode, "tty_write"))
1163 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1166 ld = tty_ldisc_ref_wait(tty);
1170 ret = do_tty_write(ld->write, tty, file, buf, count);
1171 tty_ldisc_deref(ld);
1175 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1178 struct file *p = NULL;
1180 spin_lock(&redirect_lock);
1185 spin_unlock(&redirect_lock);
1189 res = vfs_write(p, buf, count, &p->f_pos);
1194 return tty_write(file, buf, count, ppos);
1197 static char ptychar[] = "pqrstuvwxyzabcde";
1199 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1201 int i = index + driver->name_base;
1202 /* ->name is initialized to "ttyp", but "tty" is expected */
1203 sprintf(p, "%s%c%x",
1204 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1205 ptychar[i >> 4 & 0xf], i & 0xf);
1208 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1210 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1214 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1215 * failed open. The new code protects the open with a semaphore, so it's
1216 * really quite straightforward. The semaphore locking can probably be
1217 * relaxed for the (most common) case of reopening a tty.
1219 static int init_dev(struct tty_driver *driver, int idx,
1220 struct tty_struct **ret_tty)
1222 struct tty_struct *tty, *o_tty;
1223 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1224 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1227 /* check whether we're reopening an existing tty */
1228 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1229 tty = devpts_get_tty(idx);
1230 if (tty && driver->subtype == PTY_TYPE_MASTER)
1233 tty = driver->ttys[idx];
1235 if (tty) goto fast_track;
1238 * First time open is complex, especially for PTY devices.
1239 * This code guarantees that either everything succeeds and the
1240 * TTY is ready for operation, or else the table slots are vacated
1241 * and the allocated memory released. (Except that the termios
1242 * and locked termios may be retained.)
1245 if (!try_module_get(driver->owner)) {
1254 tty = alloc_tty_struct();
1257 initialize_tty_struct(tty);
1258 tty->driver = driver;
1260 tty_line_name(driver, idx, tty->name);
1262 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1263 tp_loc = &tty->termios;
1264 ltp_loc = &tty->termios_locked;
1266 tp_loc = &driver->termios[idx];
1267 ltp_loc = &driver->termios_locked[idx];
1271 tp = (struct termios *) kmalloc(sizeof(struct termios),
1275 *tp = driver->init_termios;
1279 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1283 memset(ltp, 0, sizeof(struct termios));
1286 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1287 o_tty = alloc_tty_struct();
1290 initialize_tty_struct(o_tty);
1291 o_tty->driver = driver->other;
1293 tty_line_name(driver->other, idx, o_tty->name);
1295 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1296 o_tp_loc = &o_tty->termios;
1297 o_ltp_loc = &o_tty->termios_locked;
1299 o_tp_loc = &driver->other->termios[idx];
1300 o_ltp_loc = &driver->other->termios_locked[idx];
1304 o_tp = (struct termios *)
1305 kmalloc(sizeof(struct termios), GFP_KERNEL);
1308 *o_tp = driver->other->init_termios;
1312 o_ltp = (struct termios *)
1313 kmalloc(sizeof(struct termios), GFP_KERNEL);
1316 memset(o_ltp, 0, sizeof(struct termios));
1320 * Everything allocated ... set up the o_tty structure.
1322 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1323 driver->other->ttys[idx] = o_tty;
1329 o_tty->termios = *o_tp_loc;
1330 o_tty->termios_locked = *o_ltp_loc;
1331 driver->other->refcount++;
1332 if (driver->subtype == PTY_TYPE_MASTER)
1335 /* Establish the links in both directions */
1341 * All structures have been allocated, so now we install them.
1342 * Failures after this point use release_mem to clean up, so
1343 * there's no need to null out the local pointers.
1345 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1346 driver->ttys[idx] = tty;
1353 tty->termios = *tp_loc;
1354 tty->termios_locked = *ltp_loc;
1359 * Structures all installed ... call the ldisc open routines.
1360 * If we fail here just call release_mem to clean up. No need
1361 * to decrement the use counts, as release_mem doesn't care.
1364 if (tty->ldisc.open) {
1365 retval = (tty->ldisc.open)(tty);
1367 goto release_mem_out;
1369 if (o_tty && o_tty->ldisc.open) {
1370 retval = (o_tty->ldisc.open)(o_tty);
1372 if (tty->ldisc.close)
1373 (tty->ldisc.close)(tty);
1374 goto release_mem_out;
1376 tty_ldisc_enable(o_tty);
1378 tty_ldisc_enable(tty);
1382 * This fast open can be used if the tty is already open.
1383 * No memory is allocated, and the only failures are from
1384 * attempting to open a closing tty or attempting multiple
1385 * opens on a pty master.
1388 if (test_bit(TTY_CLOSING, &tty->flags)) {
1392 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1393 driver->subtype == PTY_TYPE_MASTER) {
1395 * special case for PTY masters: only one open permitted,
1396 * and the slave side open count is incremented as well.
1405 tty->driver = driver; /* N.B. why do this every time?? */
1408 if(!test_bit(TTY_LDISC, &tty->flags))
1409 printk(KERN_ERR "init_dev but no ldisc\n");
1413 /* All paths come through here to release the semaphore */
1417 /* Release locally allocated memory ... nothing placed in slots */
1421 free_tty_struct(o_tty);
1424 free_tty_struct(tty);
1427 module_put(driver->owner);
1431 /* call the tty release_mem routine to clean out this slot */
1433 printk(KERN_INFO "init_dev: ldisc open failed, "
1434 "clearing slot %d\n", idx);
1435 release_mem(tty, idx);
1440 * Releases memory associated with a tty structure, and clears out the
1441 * driver table slots.
1443 static void release_mem(struct tty_struct *tty, int idx)
1445 struct tty_struct *o_tty;
1447 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1449 if ((o_tty = tty->link) != NULL) {
1451 o_tty->driver->ttys[idx] = NULL;
1452 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1453 tp = o_tty->termios;
1455 o_tty->driver->termios[idx] = NULL;
1458 tp = o_tty->termios_locked;
1460 o_tty->driver->termios_locked[idx] = NULL;
1464 o_tty->driver->refcount--;
1466 list_del_init(&o_tty->tty_files);
1468 free_tty_struct(o_tty);
1472 tty->driver->ttys[idx] = NULL;
1473 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1476 tty->driver->termios[idx] = NULL;
1479 tp = tty->termios_locked;
1481 tty->driver->termios_locked[idx] = NULL;
1486 tty->driver->refcount--;
1488 list_del_init(&tty->tty_files);
1490 module_put(tty->driver->owner);
1491 free_tty_struct(tty);
1495 * Even releasing the tty structures is a tricky business.. We have
1496 * to be very careful that the structures are all released at the
1497 * same time, as interrupts might otherwise get the wrong pointers.
1499 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1500 * lead to double frees or releasing memory still in use.
1502 static void release_dev(struct file * filp)
1504 struct tty_struct *tty, *o_tty;
1505 int pty_master, tty_closing, o_tty_closing, do_sleep;
1506 int devpts_master, devpts;
1509 unsigned long flags;
1511 tty = (struct tty_struct *)filp->private_data;
1512 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1515 check_tty_count(tty, "release_dev");
1517 tty_fasync(-1, filp, 0);
1520 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1521 tty->driver->subtype == PTY_TYPE_MASTER);
1522 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1523 devpts_master = pty_master && devpts;
1526 #ifdef TTY_PARANOIA_CHECK
1527 if (idx < 0 || idx >= tty->driver->num) {
1528 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1529 "free (%s)\n", tty->name);
1532 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1533 if (tty != tty->driver->ttys[idx]) {
1534 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1535 "for (%s)\n", idx, tty->name);
1538 if (tty->termios != tty->driver->termios[idx]) {
1539 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1544 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1545 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1546 "termios_locked for (%s)\n",
1553 #ifdef TTY_DEBUG_HANGUP
1554 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1555 tty_name(tty, buf), tty->count);
1558 #ifdef TTY_PARANOIA_CHECK
1559 if (tty->driver->other &&
1560 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1561 if (o_tty != tty->driver->other->ttys[idx]) {
1562 printk(KERN_DEBUG "release_dev: other->table[%d] "
1563 "not o_tty for (%s)\n",
1567 if (o_tty->termios != tty->driver->other->termios[idx]) {
1568 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1569 "not o_termios for (%s)\n",
1573 if (o_tty->termios_locked !=
1574 tty->driver->other->termios_locked[idx]) {
1575 printk(KERN_DEBUG "release_dev: other->termios_locked["
1576 "%d] not o_termios_locked for (%s)\n",
1580 if (o_tty->link != tty) {
1581 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1586 if (tty->driver->close)
1587 tty->driver->close(tty, filp);
1590 * Sanity check: if tty->count is going to zero, there shouldn't be
1591 * any waiters on tty->read_wait or tty->write_wait. We test the
1592 * wait queues and kick everyone out _before_ actually starting to
1593 * close. This ensures that we won't block while releasing the tty
1596 * The test for the o_tty closing is necessary, since the master and
1597 * slave sides may close in any order. If the slave side closes out
1598 * first, its count will be one, since the master side holds an open.
1599 * Thus this test wouldn't be triggered at the time the slave closes,
1602 * Note that it's possible for the tty to be opened again while we're
1603 * flushing out waiters. By recalculating the closing flags before
1604 * each iteration we avoid any problems.
1607 /* Guard against races with tty->count changes elsewhere and
1608 opens on /dev/tty */
1611 tty_closing = tty->count <= 1;
1612 o_tty_closing = o_tty &&
1613 (o_tty->count <= (pty_master ? 1 : 0));
1618 if (waitqueue_active(&tty->read_wait)) {
1619 wake_up(&tty->read_wait);
1622 if (waitqueue_active(&tty->write_wait)) {
1623 wake_up(&tty->write_wait);
1627 if (o_tty_closing) {
1628 if (waitqueue_active(&o_tty->read_wait)) {
1629 wake_up(&o_tty->read_wait);
1632 if (waitqueue_active(&o_tty->write_wait)) {
1633 wake_up(&o_tty->write_wait);
1640 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1641 "active!\n", tty_name(tty, buf));
1646 * The closing flags are now consistent with the open counts on
1647 * both sides, and we've completed the last operation that could
1648 * block, so it's safe to proceed with closing.
1653 if (--o_tty->count < 0) {
1654 printk(KERN_WARNING "release_dev: bad pty slave count "
1656 o_tty->count, tty_name(o_tty, buf));
1660 if (--tty->count < 0) {
1661 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1662 tty->count, tty_name(tty, buf));
1668 * We've decremented tty->count, so we need to remove this file
1669 * descriptor off the tty->tty_files list; this serves two
1671 * - check_tty_count sees the correct number of file descriptors
1672 * associated with this tty.
1673 * - do_tty_hangup no longer sees this file descriptor as
1674 * something that needs to be handled for hangups.
1677 filp->private_data = NULL;
1680 * Perform some housekeeping before deciding whether to return.
1682 * Set the TTY_CLOSING flag if this was the last open. In the
1683 * case of a pty we may have to wait around for the other side
1684 * to close, and TTY_CLOSING makes sure we can't be reopened.
1687 set_bit(TTY_CLOSING, &tty->flags);
1689 set_bit(TTY_CLOSING, &o_tty->flags);
1692 * If _either_ side is closing, make sure there aren't any
1693 * processes that still think tty or o_tty is their controlling
1696 if (tty_closing || o_tty_closing) {
1697 struct task_struct *p;
1699 read_lock(&tasklist_lock);
1700 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1701 p->signal->tty = NULL;
1702 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1704 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1705 p->signal->tty = NULL;
1706 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1707 read_unlock(&tasklist_lock);
1710 /* check whether both sides are closing ... */
1711 if (!tty_closing || (o_tty && !o_tty_closing))
1714 #ifdef TTY_DEBUG_HANGUP
1715 printk(KERN_DEBUG "freeing tty structure...");
1718 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1719 * kill any delayed work. As this is the final close it does not
1720 * race with the set_ldisc code path.
1722 clear_bit(TTY_LDISC, &tty->flags);
1723 clear_bit(TTY_DONT_FLIP, &tty->flags);
1724 cancel_delayed_work(&tty->flip.work);
1727 * Wait for ->hangup_work and ->flip.work handlers to terminate
1730 flush_scheduled_work();
1733 * Wait for any short term users (we know they are just driver
1734 * side waiters as the file is closing so user count on the file
1737 spin_lock_irqsave(&tty_ldisc_lock, flags);
1738 while(tty->ldisc.refcount)
1740 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1741 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1742 spin_lock_irqsave(&tty_ldisc_lock, flags);
1744 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1746 * Shutdown the current line discipline, and reset it to N_TTY.
1747 * N.B. why reset ldisc when we're releasing the memory??
1749 * FIXME: this MUST get fixed for the new reflocking
1751 if (tty->ldisc.close)
1752 (tty->ldisc.close)(tty);
1753 tty_ldisc_put(tty->ldisc.num);
1756 * Switch the line discipline back
1758 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1759 tty_set_termios_ldisc(tty,N_TTY);
1761 /* FIXME: could o_tty be in setldisc here ? */
1762 clear_bit(TTY_LDISC, &o_tty->flags);
1763 if (o_tty->ldisc.close)
1764 (o_tty->ldisc.close)(o_tty);
1765 tty_ldisc_put(o_tty->ldisc.num);
1766 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1767 tty_set_termios_ldisc(o_tty,N_TTY);
1770 * The release_mem function takes care of the details of clearing
1771 * the slots and preserving the termios structure.
1773 release_mem(tty, idx);
1775 #ifdef CONFIG_UNIX98_PTYS
1776 /* Make this pty number available for reallocation */
1778 down(&allocated_ptys_lock);
1779 idr_remove(&allocated_ptys, idx);
1780 up(&allocated_ptys_lock);
1787 * tty_open and tty_release keep up the tty count that contains the
1788 * number of opens done on a tty. We cannot use the inode-count, as
1789 * different inodes might point to the same tty.
1791 * Open-counting is needed for pty masters, as well as for keeping
1792 * track of serial lines: DTR is dropped when the last close happens.
1793 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1795 * The termios state of a pty is reset on first open so that
1796 * settings don't persist across reuse.
1798 static int tty_open(struct inode * inode, struct file * filp)
1800 struct tty_struct *tty;
1802 struct tty_driver *driver;
1804 dev_t device = inode->i_rdev;
1805 unsigned short saved_flags = filp->f_flags;
1807 nonseekable_open(inode, filp);
1810 noctty = filp->f_flags & O_NOCTTY;
1816 if (device == MKDEV(TTYAUX_MAJOR,0)) {
1817 if (!current->signal->tty) {
1821 driver = current->signal->tty->driver;
1822 index = current->signal->tty->index;
1823 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1828 if (device == MKDEV(TTY_MAJOR,0)) {
1829 extern struct tty_driver *console_driver;
1830 driver = console_driver;
1836 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1837 driver = console_device(&index);
1839 /* Don't let /dev/console block */
1840 filp->f_flags |= O_NONBLOCK;
1848 driver = get_tty_driver(device, &index);
1854 retval = init_dev(driver, index, &tty);
1859 filp->private_data = tty;
1860 file_move(filp, &tty->tty_files);
1861 check_tty_count(tty, "tty_open");
1862 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1863 tty->driver->subtype == PTY_TYPE_MASTER)
1865 #ifdef TTY_DEBUG_HANGUP
1866 printk(KERN_DEBUG "opening %s...", tty->name);
1869 if (tty->driver->open)
1870 retval = tty->driver->open(tty, filp);
1874 filp->f_flags = saved_flags;
1876 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1880 #ifdef TTY_DEBUG_HANGUP
1881 printk(KERN_DEBUG "error %d in opening %s...", retval,
1885 if (retval != -ERESTARTSYS)
1887 if (signal_pending(current))
1891 * Need to reset f_op in case a hangup happened.
1893 if (filp->f_op == &hung_up_tty_fops)
1894 filp->f_op = &tty_fops;
1898 current->signal->leader &&
1899 !current->signal->tty &&
1900 tty->session == 0) {
1902 current->signal->tty = tty;
1903 task_unlock(current);
1904 current->signal->tty_old_pgrp = 0;
1905 tty->session = current->signal->session;
1906 tty->pgrp = process_group(current);
1911 #ifdef CONFIG_UNIX98_PTYS
1912 static int ptmx_open(struct inode * inode, struct file * filp)
1914 struct tty_struct *tty;
1919 nonseekable_open(inode, filp);
1921 /* find a device that is not in use. */
1922 down(&allocated_ptys_lock);
1923 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1924 up(&allocated_ptys_lock);
1927 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1929 up(&allocated_ptys_lock);
1930 if (idr_ret == -EAGAIN)
1934 if (index >= pty_limit) {
1935 idr_remove(&allocated_ptys, index);
1936 up(&allocated_ptys_lock);
1939 up(&allocated_ptys_lock);
1942 retval = init_dev(ptm_driver, index, &tty);
1948 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1949 filp->private_data = tty;
1950 file_move(filp, &tty->tty_files);
1953 if (devpts_pty_new(tty->link))
1956 check_tty_count(tty, "tty_open");
1957 retval = ptm_driver->open(tty, filp);
1963 down(&allocated_ptys_lock);
1964 idr_remove(&allocated_ptys, index);
1965 up(&allocated_ptys_lock);
1970 static int tty_release(struct inode * inode, struct file * filp)
1978 /* No kernel lock held - fine */
1979 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1981 struct tty_struct * tty;
1982 struct tty_ldisc *ld;
1985 tty = (struct tty_struct *)filp->private_data;
1986 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1989 ld = tty_ldisc_ref_wait(tty);
1991 ret = (ld->poll)(tty, filp, wait);
1992 tty_ldisc_deref(ld);
1996 static int tty_fasync(int fd, struct file * filp, int on)
1998 struct tty_struct * tty;
2001 tty = (struct tty_struct *)filp->private_data;
2002 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2005 retval = fasync_helper(fd, filp, on, &tty->fasync);
2010 if (!waitqueue_active(&tty->read_wait))
2011 tty->minimum_to_wake = 1;
2012 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2016 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2017 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2022 static int tiocsti(struct tty_struct *tty, char __user *p)
2025 struct tty_ldisc *ld;
2027 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2029 if (get_user(ch, p))
2031 ld = tty_ldisc_ref_wait(tty);
2032 ld->receive_buf(tty, &ch, &mbz, 1);
2033 tty_ldisc_deref(ld);
2037 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2039 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2044 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2045 struct winsize __user * arg)
2047 struct winsize tmp_ws;
2049 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2051 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2054 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2057 acquire_console_sem();
2058 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2059 release_console_sem();
2065 kill_pg(tty->pgrp, SIGWINCH, 1);
2066 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2067 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2068 tty->winsize = tmp_ws;
2069 real_tty->winsize = tmp_ws;
2073 static int tioccons(struct file *file)
2075 if (!capable(CAP_SYS_ADMIN))
2077 if (file->f_op->write == redirected_tty_write) {
2079 spin_lock(&redirect_lock);
2082 spin_unlock(&redirect_lock);
2087 spin_lock(&redirect_lock);
2089 spin_unlock(&redirect_lock);
2094 spin_unlock(&redirect_lock);
2099 static int fionbio(struct file *file, int __user *p)
2103 if (get_user(nonblock, p))
2107 file->f_flags |= O_NONBLOCK;
2109 file->f_flags &= ~O_NONBLOCK;
2113 static int tiocsctty(struct tty_struct *tty, int arg)
2117 if (current->signal->leader &&
2118 (current->signal->session == tty->session))
2121 * The process must be a session leader and
2122 * not have a controlling tty already.
2124 if (!current->signal->leader || current->signal->tty)
2126 if (tty->session > 0) {
2128 * This tty is already the controlling
2129 * tty for another session group!
2131 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2136 read_lock(&tasklist_lock);
2137 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2138 p->signal->tty = NULL;
2139 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2140 read_unlock(&tasklist_lock);
2145 current->signal->tty = tty;
2146 task_unlock(current);
2147 current->signal->tty_old_pgrp = 0;
2148 tty->session = current->signal->session;
2149 tty->pgrp = process_group(current);
2153 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2156 * (tty == real_tty) is a cheap way of
2157 * testing if the tty is NOT a master pty.
2159 if (tty == real_tty && current->signal->tty != real_tty)
2161 return put_user(real_tty->pgrp, p);
2164 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2167 int retval = tty_check_change(real_tty);
2173 if (!current->signal->tty ||
2174 (current->signal->tty != real_tty) ||
2175 (real_tty->session != current->signal->session))
2177 if (get_user(pgrp, p))
2181 if (session_of_pgrp(pgrp) != current->signal->session)
2183 real_tty->pgrp = pgrp;
2187 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2190 * (tty == real_tty) is a cheap way of
2191 * testing if the tty is NOT a master pty.
2193 if (tty == real_tty && current->signal->tty != real_tty)
2195 if (real_tty->session <= 0)
2197 return put_user(real_tty->session, p);
2200 static int tiocsetd(struct tty_struct *tty, int __user *p)
2204 if (get_user(ldisc, p))
2206 return tty_set_ldisc(tty, ldisc);
2209 static int send_break(struct tty_struct *tty, unsigned int duration)
2211 tty->driver->break_ctl(tty, -1);
2212 if (!signal_pending(current)) {
2213 msleep_interruptible(duration);
2215 tty->driver->break_ctl(tty, 0);
2216 if (signal_pending(current))
2222 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2224 int retval = -EINVAL;
2226 if (tty->driver->tiocmget) {
2227 retval = tty->driver->tiocmget(tty, file);
2230 retval = put_user(retval, p);
2236 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2239 int retval = -EINVAL;
2241 if (tty->driver->tiocmset) {
2242 unsigned int set, clear, val;
2244 retval = get_user(val, p);
2262 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2263 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2265 retval = tty->driver->tiocmset(tty, file, set, clear);
2271 * Split this up, as gcc can choke on it otherwise..
2273 int tty_ioctl(struct inode * inode, struct file * file,
2274 unsigned int cmd, unsigned long arg)
2276 struct tty_struct *tty, *real_tty;
2277 void __user *p = (void __user *)arg;
2279 struct tty_ldisc *ld;
2281 tty = (struct tty_struct *)file->private_data;
2282 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2286 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2287 tty->driver->subtype == PTY_TYPE_MASTER)
2288 real_tty = tty->link;
2291 * Break handling by driver
2293 if (!tty->driver->break_ctl) {
2297 if (tty->driver->ioctl)
2298 return tty->driver->ioctl(tty, file, cmd, arg);
2301 /* These two ioctl's always return success; even if */
2302 /* the driver doesn't support them. */
2305 if (!tty->driver->ioctl)
2307 retval = tty->driver->ioctl(tty, file, cmd, arg);
2308 if (retval == -ENOIOCTLCMD)
2315 * Factor out some common prep work
2323 retval = tty_check_change(tty);
2326 if (cmd != TIOCCBRK) {
2327 tty_wait_until_sent(tty, 0);
2328 if (signal_pending(current))
2336 return tiocsti(tty, p);
2338 return tiocgwinsz(tty, p);
2340 return tiocswinsz(tty, real_tty, p);
2342 return real_tty!=tty ? -EINVAL : tioccons(file);
2344 return fionbio(file, p);
2346 set_bit(TTY_EXCLUSIVE, &tty->flags);
2349 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2352 if (current->signal->tty != tty)
2354 if (current->signal->leader)
2355 disassociate_ctty(0);
2357 current->signal->tty = NULL;
2358 task_unlock(current);
2361 return tiocsctty(tty, arg);
2363 return tiocgpgrp(tty, real_tty, p);
2365 return tiocspgrp(tty, real_tty, p);
2367 return tiocgsid(tty, real_tty, p);
2369 /* FIXME: check this is ok */
2370 return put_user(tty->ldisc.num, (int __user *)p);
2372 return tiocsetd(tty, p);
2375 return tioclinux(tty, arg);
2380 case TIOCSBRK: /* Turn break on, unconditionally */
2381 tty->driver->break_ctl(tty, -1);
2384 case TIOCCBRK: /* Turn break off, unconditionally */
2385 tty->driver->break_ctl(tty, 0);
2387 case TCSBRK: /* SVID version: non-zero arg --> no break */
2389 * XXX is the above comment correct, or the
2390 * code below correct? Is this ioctl used at
2394 return send_break(tty, 250);
2396 case TCSBRKP: /* support for POSIX tcsendbreak() */
2397 return send_break(tty, arg ? arg*100 : 250);
2400 return tty_tiocmget(tty, file, p);
2405 return tty_tiocmset(tty, file, cmd, p);
2407 if (tty->driver->ioctl) {
2408 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2409 if (retval != -ENOIOCTLCMD)
2412 ld = tty_ldisc_ref_wait(tty);
2415 retval = ld->ioctl(tty, file, cmd, arg);
2416 if (retval == -ENOIOCTLCMD)
2419 tty_ldisc_deref(ld);
2425 * This implements the "Secure Attention Key" --- the idea is to
2426 * prevent trojan horses by killing all processes associated with this
2427 * tty when the user hits the "Secure Attention Key". Required for
2428 * super-paranoid applications --- see the Orange Book for more details.
2430 * This code could be nicer; ideally it should send a HUP, wait a few
2431 * seconds, then send a INT, and then a KILL signal. But you then
2432 * have to coordinate with the init process, since all processes associated
2433 * with the current tty must be dead before the new getty is allowed
2436 * Now, if it would be correct ;-/ The current code has a nasty hole -
2437 * it doesn't catch files in flight. We may send the descriptor to ourselves
2438 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2440 * Nasty bug: do_SAK is being called in interrupt context. This can
2441 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2443 static void __do_SAK(void *arg)
2448 struct tty_struct *tty = arg;
2449 struct task_struct *p;
2453 struct tty_ldisc *disc;
2454 struct fdtable *fdt;
2458 session = tty->session;
2460 /* We don't want an ldisc switch during this */
2461 disc = tty_ldisc_ref(tty);
2462 if (disc && disc->flush_buffer)
2463 disc->flush_buffer(tty);
2464 tty_ldisc_deref(disc);
2466 if (tty->driver->flush_buffer)
2467 tty->driver->flush_buffer(tty);
2469 read_lock(&tasklist_lock);
2470 do_each_task_pid(session, PIDTYPE_SID, p) {
2471 if (p->signal->tty == tty || session > 0) {
2472 printk(KERN_NOTICE "SAK: killed process %d"
2473 " (%s): p->signal->session==tty->session\n",
2475 send_sig(SIGKILL, p, 1);
2481 fdt = files_fdtable(p->files);
2482 for (i=0; i < fdt->max_fds; i++) {
2483 filp = fcheck_files(p->files, i);
2486 if (filp->f_op->read == tty_read &&
2487 filp->private_data == tty) {
2488 printk(KERN_NOTICE "SAK: killed process %d"
2489 " (%s): fd#%d opened to the tty\n",
2490 p->pid, p->comm, i);
2491 send_sig(SIGKILL, p, 1);
2498 } while_each_task_pid(session, PIDTYPE_SID, p);
2499 read_unlock(&tasklist_lock);
2504 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2505 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2506 * the values which we write to it will be identical to the values which it
2507 * already has. --akpm
2509 void do_SAK(struct tty_struct *tty)
2513 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2514 schedule_work(&tty->SAK_work);
2517 EXPORT_SYMBOL(do_SAK);
2520 * This routine is called out of the software interrupt to flush data
2521 * from the flip buffer to the line discipline.
2524 static void flush_to_ldisc(void *private_)
2526 struct tty_struct *tty = (struct tty_struct *) private_;
2530 unsigned long flags;
2531 struct tty_ldisc *disc;
2533 disc = tty_ldisc_ref(tty);
2534 if (disc == NULL) /* !TTY_LDISC */
2537 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2539 * Do it after the next timer tick:
2541 schedule_delayed_work(&tty->flip.work, 1);
2544 spin_lock_irqsave(&tty->read_lock, flags);
2545 if (tty->flip.buf_num) {
2546 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2547 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2548 tty->flip.buf_num = 0;
2549 tty->flip.char_buf_ptr = tty->flip.char_buf;
2550 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2552 cp = tty->flip.char_buf;
2553 fp = tty->flip.flag_buf;
2554 tty->flip.buf_num = 1;
2555 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2556 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2558 count = tty->flip.count;
2559 tty->flip.count = 0;
2560 spin_unlock_irqrestore(&tty->read_lock, flags);
2562 disc->receive_buf(tty, cp, fp, count);
2564 tty_ldisc_deref(disc);
2568 * Routine which returns the baud rate of the tty
2570 * Note that the baud_table needs to be kept in sync with the
2571 * include/asm/termbits.h file.
2573 static int baud_table[] = {
2574 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2575 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2577 76800, 153600, 307200, 614400, 921600
2579 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2580 2500000, 3000000, 3500000, 4000000
2584 static int n_baud_table = ARRAY_SIZE(baud_table);
2587 * tty_termios_baud_rate
2588 * @termios: termios structure
2590 * Convert termios baud rate data into a speed. This should be called
2591 * with the termios lock held if this termios is a terminal termios
2592 * structure. May change the termios data.
2595 int tty_termios_baud_rate(struct termios *termios)
2599 cbaud = termios->c_cflag & CBAUD;
2601 if (cbaud & CBAUDEX) {
2604 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2605 termios->c_cflag &= ~CBAUDEX;
2609 return baud_table[cbaud];
2612 EXPORT_SYMBOL(tty_termios_baud_rate);
2615 * tty_get_baud_rate - get tty bit rates
2616 * @tty: tty to query
2618 * Returns the baud rate as an integer for this terminal. The
2619 * termios lock must be held by the caller and the terminal bit
2620 * flags may be updated.
2623 int tty_get_baud_rate(struct tty_struct *tty)
2625 int baud = tty_termios_baud_rate(tty->termios);
2627 if (baud == 38400 && tty->alt_speed) {
2629 printk(KERN_WARNING "Use of setserial/setrocket to "
2630 "set SPD_* flags is deprecated\n");
2633 baud = tty->alt_speed;
2639 EXPORT_SYMBOL(tty_get_baud_rate);
2642 * tty_flip_buffer_push - terminal
2645 * Queue a push of the terminal flip buffers to the line discipline. This
2646 * function must not be called from IRQ context if tty->low_latency is set.
2648 * In the event of the queue being busy for flipping the work will be
2649 * held off and retried later.
2652 void tty_flip_buffer_push(struct tty_struct *tty)
2654 if (tty->low_latency)
2655 flush_to_ldisc((void *) tty);
2657 schedule_delayed_work(&tty->flip.work, 1);
2660 EXPORT_SYMBOL(tty_flip_buffer_push);
2663 * This subroutine initializes a tty structure.
2665 static void initialize_tty_struct(struct tty_struct *tty)
2667 memset(tty, 0, sizeof(struct tty_struct));
2668 tty->magic = TTY_MAGIC;
2669 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2671 tty->overrun_time = jiffies;
2672 tty->flip.char_buf_ptr = tty->flip.char_buf;
2673 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2674 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2675 init_MUTEX(&tty->flip.pty_sem);
2676 init_MUTEX(&tty->termios_sem);
2677 init_waitqueue_head(&tty->write_wait);
2678 init_waitqueue_head(&tty->read_wait);
2679 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2680 sema_init(&tty->atomic_read, 1);
2681 sema_init(&tty->atomic_write, 1);
2682 spin_lock_init(&tty->read_lock);
2683 INIT_LIST_HEAD(&tty->tty_files);
2684 INIT_WORK(&tty->SAK_work, NULL, NULL);
2688 * The default put_char routine if the driver did not define one.
2690 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2692 tty->driver->write(tty, &ch, 1);
2695 static struct class *tty_class;
2698 * tty_register_device - register a tty device
2699 * @driver: the tty driver that describes the tty device
2700 * @index: the index in the tty driver for this tty device
2701 * @device: a struct device that is associated with this tty device.
2702 * This field is optional, if there is no known struct device for this
2703 * tty device it can be set to NULL safely.
2705 * This call is required to be made to register an individual tty device if
2706 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2707 * bit is not set, this function should not be called.
2709 void tty_register_device(struct tty_driver *driver, unsigned index,
2710 struct device *device)
2713 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2715 if (index >= driver->num) {
2716 printk(KERN_ERR "Attempt to register invalid tty line number "
2721 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2722 "%s%d", driver->devfs_name, index + driver->name_base);
2724 if (driver->type == TTY_DRIVER_TYPE_PTY)
2725 pty_line_name(driver, index, name);
2727 tty_line_name(driver, index, name);
2728 class_device_create(tty_class, NULL, dev, device, "%s", name);
2732 * tty_unregister_device - unregister a tty device
2733 * @driver: the tty driver that describes the tty device
2734 * @index: the index in the tty driver for this tty device
2736 * If a tty device is registered with a call to tty_register_device() then
2737 * this function must be made when the tty device is gone.
2739 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2741 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2742 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
2745 EXPORT_SYMBOL(tty_register_device);
2746 EXPORT_SYMBOL(tty_unregister_device);
2748 struct tty_driver *alloc_tty_driver(int lines)
2750 struct tty_driver *driver;
2752 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2754 memset(driver, 0, sizeof(struct tty_driver));
2755 driver->magic = TTY_DRIVER_MAGIC;
2756 driver->num = lines;
2757 /* later we'll move allocation of tables here */
2762 void put_tty_driver(struct tty_driver *driver)
2767 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2769 driver->open = op->open;
2770 driver->close = op->close;
2771 driver->write = op->write;
2772 driver->put_char = op->put_char;
2773 driver->flush_chars = op->flush_chars;
2774 driver->write_room = op->write_room;
2775 driver->chars_in_buffer = op->chars_in_buffer;
2776 driver->ioctl = op->ioctl;
2777 driver->set_termios = op->set_termios;
2778 driver->throttle = op->throttle;
2779 driver->unthrottle = op->unthrottle;
2780 driver->stop = op->stop;
2781 driver->start = op->start;
2782 driver->hangup = op->hangup;
2783 driver->break_ctl = op->break_ctl;
2784 driver->flush_buffer = op->flush_buffer;
2785 driver->set_ldisc = op->set_ldisc;
2786 driver->wait_until_sent = op->wait_until_sent;
2787 driver->send_xchar = op->send_xchar;
2788 driver->read_proc = op->read_proc;
2789 driver->write_proc = op->write_proc;
2790 driver->tiocmget = op->tiocmget;
2791 driver->tiocmset = op->tiocmset;
2795 EXPORT_SYMBOL(alloc_tty_driver);
2796 EXPORT_SYMBOL(put_tty_driver);
2797 EXPORT_SYMBOL(tty_set_operations);
2800 * Called by a tty driver to register itself.
2802 int tty_register_driver(struct tty_driver *driver)
2809 if (driver->flags & TTY_DRIVER_INSTALLED)
2812 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2813 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2816 memset(p, 0, driver->num * 3 * sizeof(void *));
2819 if (!driver->major) {
2820 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2821 (char*)driver->name);
2823 driver->major = MAJOR(dev);
2824 driver->minor_start = MINOR(dev);
2827 dev = MKDEV(driver->major, driver->minor_start);
2828 error = register_chrdev_region(dev, driver->num,
2829 (char*)driver->name);
2837 driver->ttys = (struct tty_struct **)p;
2838 driver->termios = (struct termios **)(p + driver->num);
2839 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2841 driver->ttys = NULL;
2842 driver->termios = NULL;
2843 driver->termios_locked = NULL;
2846 cdev_init(&driver->cdev, &tty_fops);
2847 driver->cdev.owner = driver->owner;
2848 error = cdev_add(&driver->cdev, dev, driver->num);
2850 cdev_del(&driver->cdev);
2851 unregister_chrdev_region(dev, driver->num);
2852 driver->ttys = NULL;
2853 driver->termios = driver->termios_locked = NULL;
2858 if (!driver->put_char)
2859 driver->put_char = tty_default_put_char;
2861 list_add(&driver->tty_drivers, &tty_drivers);
2863 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2864 for(i = 0; i < driver->num; i++)
2865 tty_register_device(driver, i, NULL);
2867 proc_tty_register_driver(driver);
2871 EXPORT_SYMBOL(tty_register_driver);
2874 * Called by a tty driver to unregister itself.
2876 int tty_unregister_driver(struct tty_driver *driver)
2882 if (driver->refcount)
2885 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2888 list_del(&driver->tty_drivers);
2891 * Free the termios and termios_locked structures because
2892 * we don't want to get memory leaks when modular tty
2893 * drivers are removed from the kernel.
2895 for (i = 0; i < driver->num; i++) {
2896 tp = driver->termios[i];
2898 driver->termios[i] = NULL;
2901 tp = driver->termios_locked[i];
2903 driver->termios_locked[i] = NULL;
2906 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2907 tty_unregister_device(driver, i);
2910 proc_tty_unregister_driver(driver);
2911 driver->ttys = NULL;
2912 driver->termios = driver->termios_locked = NULL;
2914 cdev_del(&driver->cdev);
2918 EXPORT_SYMBOL(tty_unregister_driver);
2922 * Initialize the console device. This is called *early*, so
2923 * we can't necessarily depend on lots of kernel help here.
2924 * Just do some early initializations, and do the complex setup
2927 void __init console_init(void)
2931 /* Setup the default TTY line discipline. */
2932 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2935 * set up the console device so that later boot sequences can
2936 * inform about problems etc..
2938 #ifdef CONFIG_EARLY_PRINTK
2939 disable_early_printk();
2941 call = __con_initcall_start;
2942 while (call < __con_initcall_end) {
2949 extern int vty_init(void);
2952 static int __init tty_class_init(void)
2954 tty_class = class_create(THIS_MODULE, "tty");
2955 if (IS_ERR(tty_class))
2956 return PTR_ERR(tty_class);
2960 postcore_initcall(tty_class_init);
2962 /* 3/2004 jmc: why do these devices exist? */
2964 static struct cdev tty_cdev, console_cdev;
2965 #ifdef CONFIG_UNIX98_PTYS
2966 static struct cdev ptmx_cdev;
2969 static struct cdev vc0_cdev;
2973 * Ok, now we can initialize the rest of the tty devices and can count
2974 * on memory allocations, interrupts etc..
2976 static int __init tty_init(void)
2978 cdev_init(&tty_cdev, &tty_fops);
2979 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2980 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2981 panic("Couldn't register /dev/tty driver\n");
2982 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2983 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2985 cdev_init(&console_cdev, &console_fops);
2986 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2987 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2988 panic("Couldn't register /dev/console driver\n");
2989 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2990 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2992 #ifdef CONFIG_UNIX98_PTYS
2993 cdev_init(&ptmx_cdev, &ptmx_fops);
2994 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2995 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2996 panic("Couldn't register /dev/ptmx driver\n");
2997 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2998 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3002 cdev_init(&vc0_cdev, &console_fops);
3003 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3004 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3005 panic("Couldn't register /dev/tty0 driver\n");
3006 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3007 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3013 module_init(tty_init);