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>
98 #include <asm/uaccess.h>
99 #include <asm/system.h>
101 #include <linux/kbd_kern.h>
102 #include <linux/vt_kern.h>
103 #include <linux/selection.h>
104 #include <linux/devfs_fs_kernel.h>
106 #include <linux/kmod.h>
108 #undef TTY_DEBUG_HANGUP
110 #define TTY_PARANOIA_CHECK 1
111 #define CHECK_TTY_COUNT 1
113 struct termios tty_std_termios = { /* for the benefit of tty drivers */
114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
122 EXPORT_SYMBOL(tty_std_termios);
124 /* This list gets poked at by procfs and various bits of boot up code. This
125 could do with some rationalisation such as pulling the tty proc function
128 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
130 /* Semaphore to protect creating and releasing a tty. This is shared with
131 vt.c for deeply disgusting hack reasons */
132 DECLARE_MUTEX(tty_sem);
134 #ifdef CONFIG_UNIX98_PTYS
135 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
136 extern int pty_limit; /* Config limit on Unix98 ptys */
137 static DEFINE_IDR(allocated_ptys);
138 static DECLARE_MUTEX(allocated_ptys_lock);
139 static int ptmx_open(struct inode *, struct file *);
142 extern void disable_early_printk(void);
144 static void initialize_tty_struct(struct tty_struct *tty);
146 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149 static unsigned int tty_poll(struct file *, poll_table *);
150 static int tty_open(struct inode *, struct file *);
151 static int tty_release(struct inode *, struct file *);
152 int tty_ioctl(struct inode * inode, struct file * file,
153 unsigned int cmd, unsigned long arg);
154 static int tty_fasync(int fd, struct file * filp, int on);
155 extern void rs_360_init(void);
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;
479 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
484 if (tty->ldisc.num == ldisc)
485 return 0; /* We are already in the desired discipline */
487 ld = tty_ldisc_get(ldisc);
488 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
489 /* Cyrus Durgin <cider@speakeasy.org> */
491 request_module("tty-ldisc-%d", ldisc);
492 ld = tty_ldisc_get(ldisc);
497 o_ldisc = tty->ldisc;
499 tty_wait_until_sent(tty, 0);
502 * Make sure we don't change while someone holds a
503 * reference to the line discipline. The TTY_LDISC bit
504 * prevents anyone taking a reference once it is clear.
505 * We need the lock to avoid racing reference takers.
508 spin_lock_irqsave(&tty_ldisc_lock, flags);
509 if(tty->ldisc.refcount)
511 /* Free the new ldisc we grabbed. Must drop the lock
513 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
514 tty_ldisc_put(ldisc);
516 * There are several reasons we may be busy, including
517 * random momentary I/O traffic. We must therefore
518 * retry. We could distinguish between blocking ops
519 * and retries if we made tty_ldisc_wait() smarter. That
520 * is up for discussion.
522 if(wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
526 clear_bit(TTY_LDISC, &tty->flags);
527 clear_bit(TTY_DONT_FLIP, &tty->flags);
528 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
531 * From this point on we know nobody has an ldisc
532 * usage reference, nor can they obtain one until
533 * we say so later on.
536 work = cancel_delayed_work(&tty->flip.work);
538 * Wait for ->hangup_work and ->flip.work handlers to terminate
541 flush_scheduled_work();
542 /* Shutdown the current discipline. */
543 if (tty->ldisc.close)
544 (tty->ldisc.close)(tty);
546 /* Now set up the new line discipline. */
547 tty_ldisc_assign(tty, ld);
548 tty_set_termios_ldisc(tty, ldisc);
550 retval = (tty->ldisc.open)(tty);
552 tty_ldisc_put(ldisc);
553 /* There is an outstanding reference here so this is safe */
554 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
555 tty_set_termios_ldisc(tty, tty->ldisc.num);
556 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
557 tty_ldisc_put(o_ldisc.num);
558 /* This driver is always present */
559 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
560 tty_set_termios_ldisc(tty, N_TTY);
561 if (tty->ldisc.open) {
562 int r = tty->ldisc.open(tty);
565 panic("Couldn't open N_TTY ldisc for "
567 tty_name(tty, buf), r);
571 /* At this point we hold a reference to the new ldisc and a
572 a reference to the old ldisc. If we ended up flipping back
573 to the existing ldisc we have two references to it */
575 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
576 tty->driver->set_ldisc(tty);
578 tty_ldisc_put(o_ldisc.num);
581 * Allow ldisc referencing to occur as soon as the driver
582 * ldisc callback completes.
585 tty_ldisc_enable(tty);
587 /* Restart it in case no characters kick it off. Safe if
590 schedule_delayed_work(&tty->flip.work, 1);
595 * This routine returns a tty driver structure, given a device number
597 static struct tty_driver *get_tty_driver(dev_t device, int *index)
599 struct tty_driver *p;
601 list_for_each_entry(p, &tty_drivers, tty_drivers) {
602 dev_t base = MKDEV(p->major, p->minor_start);
603 if (device < base || device >= base + p->num)
605 *index = device - base;
612 * If we try to write to, or set the state of, a terminal and we're
613 * not in the foreground, send a SIGTTOU. If the signal is blocked or
614 * ignored, go ahead and perform the operation. (POSIX 7.2)
616 int tty_check_change(struct tty_struct * tty)
618 if (current->signal->tty != tty)
620 if (tty->pgrp <= 0) {
621 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
624 if (process_group(current) == tty->pgrp)
626 if (is_ignored(SIGTTOU))
628 if (is_orphaned_pgrp(process_group(current)))
630 (void) kill_pg(process_group(current), SIGTTOU, 1);
634 EXPORT_SYMBOL(tty_check_change);
636 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
637 size_t count, loff_t *ppos)
642 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
643 size_t count, loff_t *ppos)
648 /* No kernel lock held - none needed ;) */
649 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
651 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
654 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
655 unsigned int cmd, unsigned long arg)
657 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
660 static struct file_operations tty_fops = {
667 .release = tty_release,
668 .fasync = tty_fasync,
671 #ifdef CONFIG_UNIX98_PTYS
672 static struct file_operations ptmx_fops = {
679 .release = tty_release,
680 .fasync = tty_fasync,
684 static struct file_operations console_fops = {
687 .write = redirected_tty_write,
691 .release = tty_release,
692 .fasync = tty_fasync,
695 static struct file_operations hung_up_tty_fops = {
697 .read = hung_up_tty_read,
698 .write = hung_up_tty_write,
699 .poll = hung_up_tty_poll,
700 .ioctl = hung_up_tty_ioctl,
701 .release = tty_release,
704 static DEFINE_SPINLOCK(redirect_lock);
705 static struct file *redirect;
708 * tty_wakeup - request more data
711 * Internal and external helper for wakeups of tty. This function
712 * informs the line discipline if present that the driver is ready
713 * to receive more output data.
716 void tty_wakeup(struct tty_struct *tty)
718 struct tty_ldisc *ld;
720 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
721 ld = tty_ldisc_ref(tty);
724 ld->write_wakeup(tty);
728 wake_up_interruptible(&tty->write_wait);
731 EXPORT_SYMBOL_GPL(tty_wakeup);
734 * tty_ldisc_flush - flush line discipline queue
737 * Flush the line discipline queue (if any) for this tty. If there
738 * is no line discipline active this is a no-op.
741 void tty_ldisc_flush(struct tty_struct *tty)
743 struct tty_ldisc *ld = tty_ldisc_ref(tty);
746 ld->flush_buffer(tty);
751 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
754 * This can be called by the "eventd" kernel thread. That is process synchronous,
755 * but doesn't hold any locks, so we need to make sure we have the appropriate
756 * locks for what we're doing..
758 static void do_tty_hangup(void *data)
760 struct tty_struct *tty = (struct tty_struct *) data;
761 struct file * cons_filp = NULL;
762 struct file *filp, *f = NULL;
763 struct task_struct *p;
764 struct tty_ldisc *ld;
765 int closecount = 0, n;
770 /* inuse_filps is protected by the single kernel lock */
773 spin_lock(&redirect_lock);
774 if (redirect && redirect->private_data == tty) {
778 spin_unlock(&redirect_lock);
780 check_tty_count(tty, "do_tty_hangup");
782 /* This breaks for file handles being sent over AF_UNIX sockets ? */
783 list_for_each_entry(filp, &tty->tty_files, f_list) {
784 if (filp->f_op->write == redirected_tty_write)
786 if (filp->f_op->write != tty_write)
789 tty_fasync(-1, filp, 0); /* can't block */
790 filp->f_op = &hung_up_tty_fops;
794 /* FIXME! What are the locking issues here? This may me overdoing things..
795 * this question is especially important now that we've removed the irqlock. */
797 ld = tty_ldisc_ref(tty);
798 if(ld != NULL) /* We may have no line discipline at this point */
800 if (ld->flush_buffer)
801 ld->flush_buffer(tty);
802 if (tty->driver->flush_buffer)
803 tty->driver->flush_buffer(tty);
804 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
806 ld->write_wakeup(tty);
811 /* FIXME: Once we trust the LDISC code better we can wait here for
812 ldisc completion and fix the driver call race */
814 wake_up_interruptible(&tty->write_wait);
815 wake_up_interruptible(&tty->read_wait);
818 * Shutdown the current line discipline, and reset it to
821 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
823 down(&tty->termios_sem);
824 *tty->termios = tty->driver->init_termios;
825 up(&tty->termios_sem);
828 /* Defer ldisc switch */
829 /* tty_deferred_ldisc_switch(N_TTY);
831 This should get done automatically when the port closes and
832 tty_release is called */
834 read_lock(&tasklist_lock);
835 if (tty->session > 0) {
836 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
837 if (p->signal->tty == tty)
838 p->signal->tty = NULL;
839 if (!p->signal->leader)
841 send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
842 send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
844 p->signal->tty_old_pgrp = tty->pgrp;
845 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
847 read_unlock(&tasklist_lock);
852 tty->ctrl_status = 0;
854 * If one of the devices matches a console pointer, we
855 * cannot just call hangup() because that will cause
856 * tty->count and state->count to go out of sync.
857 * So we just call close() the right number of times.
860 if (tty->driver->close)
861 for (n = 0; n < closecount; n++)
862 tty->driver->close(tty, cons_filp);
863 } else if (tty->driver->hangup)
864 (tty->driver->hangup)(tty);
866 /* We don't want to have driver/ldisc interactions beyond
867 the ones we did here. The driver layer expects no
868 calls after ->hangup() from the ldisc side. However we
869 can't yet guarantee all that */
871 set_bit(TTY_HUPPED, &tty->flags);
873 tty_ldisc_enable(tty);
881 void tty_hangup(struct tty_struct * tty)
883 #ifdef TTY_DEBUG_HANGUP
886 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
888 schedule_work(&tty->hangup_work);
891 EXPORT_SYMBOL(tty_hangup);
893 void tty_vhangup(struct tty_struct * tty)
895 #ifdef TTY_DEBUG_HANGUP
898 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
900 do_tty_hangup((void *) tty);
902 EXPORT_SYMBOL(tty_vhangup);
904 int tty_hung_up_p(struct file * filp)
906 return (filp->f_op == &hung_up_tty_fops);
909 EXPORT_SYMBOL(tty_hung_up_p);
912 * This function is typically called only by the session leader, when
913 * it wants to disassociate itself from its controlling tty.
915 * It performs the following functions:
916 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
917 * (2) Clears the tty from being controlling the session
918 * (3) Clears the controlling tty for all processes in the
921 * The argument on_exit is set to 1 if called when a process is
922 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
924 void disassociate_ctty(int on_exit)
926 struct tty_struct *tty;
927 struct task_struct *p;
933 tty = current->signal->tty;
935 tty_pgrp = tty->pgrp;
937 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
940 if (current->signal->tty_old_pgrp) {
941 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
942 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
949 kill_pg(tty_pgrp, SIGHUP, on_exit);
951 kill_pg(tty_pgrp, SIGCONT, on_exit);
954 /* Must lock changes to tty_old_pgrp */
956 current->signal->tty_old_pgrp = 0;
960 /* Now clear signal->tty under the lock */
961 read_lock(&tasklist_lock);
962 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
963 p->signal->tty = NULL;
964 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
965 read_unlock(&tasklist_lock);
970 void stop_tty(struct tty_struct *tty)
975 if (tty->link && tty->link->packet) {
976 tty->ctrl_status &= ~TIOCPKT_START;
977 tty->ctrl_status |= TIOCPKT_STOP;
978 wake_up_interruptible(&tty->link->read_wait);
980 if (tty->driver->stop)
981 (tty->driver->stop)(tty);
984 EXPORT_SYMBOL(stop_tty);
986 void start_tty(struct tty_struct *tty)
988 if (!tty->stopped || tty->flow_stopped)
991 if (tty->link && tty->link->packet) {
992 tty->ctrl_status &= ~TIOCPKT_STOP;
993 tty->ctrl_status |= TIOCPKT_START;
994 wake_up_interruptible(&tty->link->read_wait);
996 if (tty->driver->start)
997 (tty->driver->start)(tty);
999 /* If we have a running line discipline it may need kicking */
1001 wake_up_interruptible(&tty->write_wait);
1004 EXPORT_SYMBOL(start_tty);
1006 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1010 struct tty_struct * tty;
1011 struct inode *inode;
1012 struct tty_ldisc *ld;
1014 tty = (struct tty_struct *)file->private_data;
1015 inode = file->f_dentry->d_inode;
1016 if (tty_paranoia_check(tty, inode, "tty_read"))
1018 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1021 /* We want to wait for the line discipline to sort out in this
1023 ld = tty_ldisc_ref_wait(tty);
1026 i = (ld->read)(tty,file,buf,count);
1029 tty_ldisc_deref(ld);
1032 inode->i_atime = current_fs_time(inode->i_sb);
1037 * Split writes up in sane blocksizes to avoid
1038 * denial-of-service type attacks
1040 static inline ssize_t do_tty_write(
1041 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1042 struct tty_struct *tty,
1044 const char __user *buf,
1047 ssize_t ret = 0, written = 0;
1050 if (down_interruptible(&tty->atomic_write)) {
1051 return -ERESTARTSYS;
1055 * We chunk up writes into a temporary buffer. This
1056 * simplifies low-level drivers immensely, since they
1057 * don't have locking issues and user mode accesses.
1059 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1062 * The default chunk-size is 2kB, because the NTTY
1063 * layer has problems with bigger chunks. It will
1064 * claim to be able to handle more characters than
1068 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1073 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1074 if (tty->write_cnt < chunk) {
1080 buf = kmalloc(chunk, GFP_KERNEL);
1082 up(&tty->atomic_write);
1085 kfree(tty->write_buf);
1086 tty->write_cnt = chunk;
1087 tty->write_buf = buf;
1090 /* Do the write .. */
1092 size_t size = count;
1096 if (copy_from_user(tty->write_buf, buf, size))
1099 ret = write(tty, file, tty->write_buf, size);
1109 if (signal_pending(current))
1114 struct inode *inode = file->f_dentry->d_inode;
1115 inode->i_mtime = current_fs_time(inode->i_sb);
1118 up(&tty->atomic_write);
1123 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1126 struct tty_struct * tty;
1127 struct inode *inode = file->f_dentry->d_inode;
1129 struct tty_ldisc *ld;
1131 tty = (struct tty_struct *)file->private_data;
1132 if (tty_paranoia_check(tty, inode, "tty_write"))
1134 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1137 ld = tty_ldisc_ref_wait(tty);
1141 ret = do_tty_write(ld->write, tty, file, buf, count);
1142 tty_ldisc_deref(ld);
1146 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1149 struct file *p = NULL;
1151 spin_lock(&redirect_lock);
1156 spin_unlock(&redirect_lock);
1160 res = vfs_write(p, buf, count, &p->f_pos);
1165 return tty_write(file, buf, count, ppos);
1168 static char ptychar[] = "pqrstuvwxyzabcde";
1170 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1172 int i = index + driver->name_base;
1173 /* ->name is initialized to "ttyp", but "tty" is expected */
1174 sprintf(p, "%s%c%x",
1175 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1176 ptychar[i >> 4 & 0xf], i & 0xf);
1179 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1181 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1185 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1186 * failed open. The new code protects the open with a semaphore, so it's
1187 * really quite straightforward. The semaphore locking can probably be
1188 * relaxed for the (most common) case of reopening a tty.
1190 static int init_dev(struct tty_driver *driver, int idx,
1191 struct tty_struct **ret_tty)
1193 struct tty_struct *tty, *o_tty;
1194 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1195 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1198 /* check whether we're reopening an existing tty */
1199 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1200 tty = devpts_get_tty(idx);
1201 if (tty && driver->subtype == PTY_TYPE_MASTER)
1204 tty = driver->ttys[idx];
1206 if (tty) goto fast_track;
1209 * First time open is complex, especially for PTY devices.
1210 * This code guarantees that either everything succeeds and the
1211 * TTY is ready for operation, or else the table slots are vacated
1212 * and the allocated memory released. (Except that the termios
1213 * and locked termios may be retained.)
1216 if (!try_module_get(driver->owner)) {
1225 tty = alloc_tty_struct();
1228 initialize_tty_struct(tty);
1229 tty->driver = driver;
1231 tty_line_name(driver, idx, tty->name);
1233 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1234 tp_loc = &tty->termios;
1235 ltp_loc = &tty->termios_locked;
1237 tp_loc = &driver->termios[idx];
1238 ltp_loc = &driver->termios_locked[idx];
1242 tp = (struct termios *) kmalloc(sizeof(struct termios),
1246 *tp = driver->init_termios;
1250 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1254 memset(ltp, 0, sizeof(struct termios));
1257 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1258 o_tty = alloc_tty_struct();
1261 initialize_tty_struct(o_tty);
1262 o_tty->driver = driver->other;
1264 tty_line_name(driver->other, idx, o_tty->name);
1266 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1267 o_tp_loc = &o_tty->termios;
1268 o_ltp_loc = &o_tty->termios_locked;
1270 o_tp_loc = &driver->other->termios[idx];
1271 o_ltp_loc = &driver->other->termios_locked[idx];
1275 o_tp = (struct termios *)
1276 kmalloc(sizeof(struct termios), GFP_KERNEL);
1279 *o_tp = driver->other->init_termios;
1283 o_ltp = (struct termios *)
1284 kmalloc(sizeof(struct termios), GFP_KERNEL);
1287 memset(o_ltp, 0, sizeof(struct termios));
1291 * Everything allocated ... set up the o_tty structure.
1293 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1294 driver->other->ttys[idx] = o_tty;
1300 o_tty->termios = *o_tp_loc;
1301 o_tty->termios_locked = *o_ltp_loc;
1302 driver->other->refcount++;
1303 if (driver->subtype == PTY_TYPE_MASTER)
1306 /* Establish the links in both directions */
1312 * All structures have been allocated, so now we install them.
1313 * Failures after this point use release_mem to clean up, so
1314 * there's no need to null out the local pointers.
1316 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1317 driver->ttys[idx] = tty;
1324 tty->termios = *tp_loc;
1325 tty->termios_locked = *ltp_loc;
1330 * Structures all installed ... call the ldisc open routines.
1331 * If we fail here just call release_mem to clean up. No need
1332 * to decrement the use counts, as release_mem doesn't care.
1335 if (tty->ldisc.open) {
1336 retval = (tty->ldisc.open)(tty);
1338 goto release_mem_out;
1340 if (o_tty && o_tty->ldisc.open) {
1341 retval = (o_tty->ldisc.open)(o_tty);
1343 if (tty->ldisc.close)
1344 (tty->ldisc.close)(tty);
1345 goto release_mem_out;
1347 tty_ldisc_enable(o_tty);
1349 tty_ldisc_enable(tty);
1353 * This fast open can be used if the tty is already open.
1354 * No memory is allocated, and the only failures are from
1355 * attempting to open a closing tty or attempting multiple
1356 * opens on a pty master.
1359 if (test_bit(TTY_CLOSING, &tty->flags)) {
1363 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1364 driver->subtype == PTY_TYPE_MASTER) {
1366 * special case for PTY masters: only one open permitted,
1367 * and the slave side open count is incremented as well.
1376 tty->driver = driver; /* N.B. why do this every time?? */
1379 if(!test_bit(TTY_LDISC, &tty->flags))
1380 printk(KERN_ERR "init_dev but no ldisc\n");
1384 /* All paths come through here to release the semaphore */
1388 /* Release locally allocated memory ... nothing placed in slots */
1393 free_tty_struct(o_tty);
1398 free_tty_struct(tty);
1401 module_put(driver->owner);
1405 /* call the tty release_mem routine to clean out this slot */
1407 printk(KERN_INFO "init_dev: ldisc open failed, "
1408 "clearing slot %d\n", idx);
1409 release_mem(tty, idx);
1414 * Releases memory associated with a tty structure, and clears out the
1415 * driver table slots.
1417 static void release_mem(struct tty_struct *tty, int idx)
1419 struct tty_struct *o_tty;
1421 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1423 if ((o_tty = tty->link) != NULL) {
1425 o_tty->driver->ttys[idx] = NULL;
1426 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1427 tp = o_tty->termios;
1429 o_tty->driver->termios[idx] = NULL;
1432 tp = o_tty->termios_locked;
1434 o_tty->driver->termios_locked[idx] = NULL;
1438 o_tty->driver->refcount--;
1440 list_del_init(&o_tty->tty_files);
1442 free_tty_struct(o_tty);
1446 tty->driver->ttys[idx] = NULL;
1447 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1450 tty->driver->termios[idx] = NULL;
1453 tp = tty->termios_locked;
1455 tty->driver->termios_locked[idx] = NULL;
1460 tty->driver->refcount--;
1462 list_del_init(&tty->tty_files);
1464 module_put(tty->driver->owner);
1465 free_tty_struct(tty);
1469 * Even releasing the tty structures is a tricky business.. We have
1470 * to be very careful that the structures are all released at the
1471 * same time, as interrupts might otherwise get the wrong pointers.
1473 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1474 * lead to double frees or releasing memory still in use.
1476 static void release_dev(struct file * filp)
1478 struct tty_struct *tty, *o_tty;
1479 int pty_master, tty_closing, o_tty_closing, do_sleep;
1480 int devpts_master, devpts;
1483 unsigned long flags;
1485 tty = (struct tty_struct *)filp->private_data;
1486 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1489 check_tty_count(tty, "release_dev");
1491 tty_fasync(-1, filp, 0);
1494 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1495 tty->driver->subtype == PTY_TYPE_MASTER);
1496 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1497 devpts_master = pty_master && devpts;
1500 #ifdef TTY_PARANOIA_CHECK
1501 if (idx < 0 || idx >= tty->driver->num) {
1502 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1503 "free (%s)\n", tty->name);
1506 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1507 if (tty != tty->driver->ttys[idx]) {
1508 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1509 "for (%s)\n", idx, tty->name);
1512 if (tty->termios != tty->driver->termios[idx]) {
1513 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1518 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1519 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1520 "termios_locked for (%s)\n",
1527 #ifdef TTY_DEBUG_HANGUP
1528 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1529 tty_name(tty, buf), tty->count);
1532 #ifdef TTY_PARANOIA_CHECK
1533 if (tty->driver->other &&
1534 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1535 if (o_tty != tty->driver->other->ttys[idx]) {
1536 printk(KERN_DEBUG "release_dev: other->table[%d] "
1537 "not o_tty for (%s)\n",
1541 if (o_tty->termios != tty->driver->other->termios[idx]) {
1542 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1543 "not o_termios for (%s)\n",
1547 if (o_tty->termios_locked !=
1548 tty->driver->other->termios_locked[idx]) {
1549 printk(KERN_DEBUG "release_dev: other->termios_locked["
1550 "%d] not o_termios_locked for (%s)\n",
1554 if (o_tty->link != tty) {
1555 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1560 if (tty->driver->close)
1561 tty->driver->close(tty, filp);
1564 * Sanity check: if tty->count is going to zero, there shouldn't be
1565 * any waiters on tty->read_wait or tty->write_wait. We test the
1566 * wait queues and kick everyone out _before_ actually starting to
1567 * close. This ensures that we won't block while releasing the tty
1570 * The test for the o_tty closing is necessary, since the master and
1571 * slave sides may close in any order. If the slave side closes out
1572 * first, its count will be one, since the master side holds an open.
1573 * Thus this test wouldn't be triggered at the time the slave closes,
1576 * Note that it's possible for the tty to be opened again while we're
1577 * flushing out waiters. By recalculating the closing flags before
1578 * each iteration we avoid any problems.
1581 /* Guard against races with tty->count changes elsewhere and
1582 opens on /dev/tty */
1585 tty_closing = tty->count <= 1;
1586 o_tty_closing = o_tty &&
1587 (o_tty->count <= (pty_master ? 1 : 0));
1592 if (waitqueue_active(&tty->read_wait)) {
1593 wake_up(&tty->read_wait);
1596 if (waitqueue_active(&tty->write_wait)) {
1597 wake_up(&tty->write_wait);
1601 if (o_tty_closing) {
1602 if (waitqueue_active(&o_tty->read_wait)) {
1603 wake_up(&o_tty->read_wait);
1606 if (waitqueue_active(&o_tty->write_wait)) {
1607 wake_up(&o_tty->write_wait);
1614 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1615 "active!\n", tty_name(tty, buf));
1620 * The closing flags are now consistent with the open counts on
1621 * both sides, and we've completed the last operation that could
1622 * block, so it's safe to proceed with closing.
1627 if (--o_tty->count < 0) {
1628 printk(KERN_WARNING "release_dev: bad pty slave count "
1630 o_tty->count, tty_name(o_tty, buf));
1634 if (--tty->count < 0) {
1635 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1636 tty->count, tty_name(tty, buf));
1642 * We've decremented tty->count, so we need to remove this file
1643 * descriptor off the tty->tty_files list; this serves two
1645 * - check_tty_count sees the correct number of file descriptors
1646 * associated with this tty.
1647 * - do_tty_hangup no longer sees this file descriptor as
1648 * something that needs to be handled for hangups.
1651 filp->private_data = NULL;
1654 * Perform some housekeeping before deciding whether to return.
1656 * Set the TTY_CLOSING flag if this was the last open. In the
1657 * case of a pty we may have to wait around for the other side
1658 * to close, and TTY_CLOSING makes sure we can't be reopened.
1661 set_bit(TTY_CLOSING, &tty->flags);
1663 set_bit(TTY_CLOSING, &o_tty->flags);
1666 * If _either_ side is closing, make sure there aren't any
1667 * processes that still think tty or o_tty is their controlling
1670 if (tty_closing || o_tty_closing) {
1671 struct task_struct *p;
1673 read_lock(&tasklist_lock);
1674 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1675 p->signal->tty = NULL;
1676 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1678 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1679 p->signal->tty = NULL;
1680 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1681 read_unlock(&tasklist_lock);
1684 /* check whether both sides are closing ... */
1685 if (!tty_closing || (o_tty && !o_tty_closing))
1688 #ifdef TTY_DEBUG_HANGUP
1689 printk(KERN_DEBUG "freeing tty structure...");
1692 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1693 * kill any delayed work. As this is the final close it does not
1694 * race with the set_ldisc code path.
1696 clear_bit(TTY_LDISC, &tty->flags);
1697 clear_bit(TTY_DONT_FLIP, &tty->flags);
1698 cancel_delayed_work(&tty->flip.work);
1701 * Wait for ->hangup_work and ->flip.work handlers to terminate
1704 flush_scheduled_work();
1707 * Wait for any short term users (we know they are just driver
1708 * side waiters as the file is closing so user count on the file
1711 spin_lock_irqsave(&tty_ldisc_lock, flags);
1712 while(tty->ldisc.refcount)
1714 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1715 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1716 spin_lock_irqsave(&tty_ldisc_lock, flags);
1718 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1720 * Shutdown the current line discipline, and reset it to N_TTY.
1721 * N.B. why reset ldisc when we're releasing the memory??
1723 * FIXME: this MUST get fixed for the new reflocking
1725 if (tty->ldisc.close)
1726 (tty->ldisc.close)(tty);
1727 tty_ldisc_put(tty->ldisc.num);
1730 * Switch the line discipline back
1732 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1733 tty_set_termios_ldisc(tty,N_TTY);
1735 /* FIXME: could o_tty be in setldisc here ? */
1736 clear_bit(TTY_LDISC, &o_tty->flags);
1737 if (o_tty->ldisc.close)
1738 (o_tty->ldisc.close)(o_tty);
1739 tty_ldisc_put(o_tty->ldisc.num);
1740 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1741 tty_set_termios_ldisc(o_tty,N_TTY);
1744 * The release_mem function takes care of the details of clearing
1745 * the slots and preserving the termios structure.
1747 release_mem(tty, idx);
1749 #ifdef CONFIG_UNIX98_PTYS
1750 /* Make this pty number available for reallocation */
1752 down(&allocated_ptys_lock);
1753 idr_remove(&allocated_ptys, idx);
1754 up(&allocated_ptys_lock);
1761 * tty_open and tty_release keep up the tty count that contains the
1762 * number of opens done on a tty. We cannot use the inode-count, as
1763 * different inodes might point to the same tty.
1765 * Open-counting is needed for pty masters, as well as for keeping
1766 * track of serial lines: DTR is dropped when the last close happens.
1767 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1769 * The termios state of a pty is reset on first open so that
1770 * settings don't persist across reuse.
1772 static int tty_open(struct inode * inode, struct file * filp)
1774 struct tty_struct *tty;
1776 struct tty_driver *driver;
1778 dev_t device = inode->i_rdev;
1779 unsigned short saved_flags = filp->f_flags;
1781 nonseekable_open(inode, filp);
1784 noctty = filp->f_flags & O_NOCTTY;
1790 if (device == MKDEV(TTYAUX_MAJOR,0)) {
1791 if (!current->signal->tty) {
1795 driver = current->signal->tty->driver;
1796 index = current->signal->tty->index;
1797 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1802 if (device == MKDEV(TTY_MAJOR,0)) {
1803 extern struct tty_driver *console_driver;
1804 driver = console_driver;
1810 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1811 driver = console_device(&index);
1813 /* Don't let /dev/console block */
1814 filp->f_flags |= O_NONBLOCK;
1822 driver = get_tty_driver(device, &index);
1828 retval = init_dev(driver, index, &tty);
1833 filp->private_data = tty;
1834 file_move(filp, &tty->tty_files);
1835 check_tty_count(tty, "tty_open");
1836 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1837 tty->driver->subtype == PTY_TYPE_MASTER)
1839 #ifdef TTY_DEBUG_HANGUP
1840 printk(KERN_DEBUG "opening %s...", tty->name);
1843 if (tty->driver->open)
1844 retval = tty->driver->open(tty, filp);
1848 filp->f_flags = saved_flags;
1850 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1854 #ifdef TTY_DEBUG_HANGUP
1855 printk(KERN_DEBUG "error %d in opening %s...", retval,
1859 if (retval != -ERESTARTSYS)
1861 if (signal_pending(current))
1865 * Need to reset f_op in case a hangup happened.
1867 if (filp->f_op == &hung_up_tty_fops)
1868 filp->f_op = &tty_fops;
1872 current->signal->leader &&
1873 !current->signal->tty &&
1874 tty->session == 0) {
1876 current->signal->tty = tty;
1877 task_unlock(current);
1878 current->signal->tty_old_pgrp = 0;
1879 tty->session = current->signal->session;
1880 tty->pgrp = process_group(current);
1885 #ifdef CONFIG_UNIX98_PTYS
1886 static int ptmx_open(struct inode * inode, struct file * filp)
1888 struct tty_struct *tty;
1893 nonseekable_open(inode, filp);
1895 /* find a device that is not in use. */
1896 down(&allocated_ptys_lock);
1897 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1898 up(&allocated_ptys_lock);
1901 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1903 up(&allocated_ptys_lock);
1904 if (idr_ret == -EAGAIN)
1908 if (index >= pty_limit) {
1909 idr_remove(&allocated_ptys, index);
1910 up(&allocated_ptys_lock);
1913 up(&allocated_ptys_lock);
1916 retval = init_dev(ptm_driver, index, &tty);
1922 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1923 filp->private_data = tty;
1924 file_move(filp, &tty->tty_files);
1927 if (devpts_pty_new(tty->link))
1930 check_tty_count(tty, "tty_open");
1931 retval = ptm_driver->open(tty, filp);
1937 down(&allocated_ptys_lock);
1938 idr_remove(&allocated_ptys, index);
1939 up(&allocated_ptys_lock);
1944 static int tty_release(struct inode * inode, struct file * filp)
1952 /* No kernel lock held - fine */
1953 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1955 struct tty_struct * tty;
1956 struct tty_ldisc *ld;
1959 tty = (struct tty_struct *)filp->private_data;
1960 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1963 ld = tty_ldisc_ref_wait(tty);
1965 ret = (ld->poll)(tty, filp, wait);
1966 tty_ldisc_deref(ld);
1970 static int tty_fasync(int fd, struct file * filp, int on)
1972 struct tty_struct * tty;
1975 tty = (struct tty_struct *)filp->private_data;
1976 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1979 retval = fasync_helper(fd, filp, on, &tty->fasync);
1984 if (!waitqueue_active(&tty->read_wait))
1985 tty->minimum_to_wake = 1;
1986 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1990 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1991 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1996 static int tiocsti(struct tty_struct *tty, char __user *p)
1999 struct tty_ldisc *ld;
2001 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2003 if (get_user(ch, p))
2005 ld = tty_ldisc_ref_wait(tty);
2006 ld->receive_buf(tty, &ch, &mbz, 1);
2007 tty_ldisc_deref(ld);
2011 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2013 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2018 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2019 struct winsize __user * arg)
2021 struct winsize tmp_ws;
2023 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2025 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2028 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2031 acquire_console_sem();
2032 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2033 release_console_sem();
2039 kill_pg(tty->pgrp, SIGWINCH, 1);
2040 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2041 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2042 tty->winsize = tmp_ws;
2043 real_tty->winsize = tmp_ws;
2047 static int tioccons(struct file *file)
2049 if (!capable(CAP_SYS_ADMIN))
2051 if (file->f_op->write == redirected_tty_write) {
2053 spin_lock(&redirect_lock);
2056 spin_unlock(&redirect_lock);
2061 spin_lock(&redirect_lock);
2063 spin_unlock(&redirect_lock);
2068 spin_unlock(&redirect_lock);
2073 static int fionbio(struct file *file, int __user *p)
2077 if (get_user(nonblock, p))
2081 file->f_flags |= O_NONBLOCK;
2083 file->f_flags &= ~O_NONBLOCK;
2087 static int tiocsctty(struct tty_struct *tty, int arg)
2091 if (current->signal->leader &&
2092 (current->signal->session == tty->session))
2095 * The process must be a session leader and
2096 * not have a controlling tty already.
2098 if (!current->signal->leader || current->signal->tty)
2100 if (tty->session > 0) {
2102 * This tty is already the controlling
2103 * tty for another session group!
2105 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2110 read_lock(&tasklist_lock);
2111 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2112 p->signal->tty = NULL;
2113 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2114 read_unlock(&tasklist_lock);
2119 current->signal->tty = tty;
2120 task_unlock(current);
2121 current->signal->tty_old_pgrp = 0;
2122 tty->session = current->signal->session;
2123 tty->pgrp = process_group(current);
2127 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2130 * (tty == real_tty) is a cheap way of
2131 * testing if the tty is NOT a master pty.
2133 if (tty == real_tty && current->signal->tty != real_tty)
2135 return put_user(real_tty->pgrp, p);
2138 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2141 int retval = tty_check_change(real_tty);
2147 if (!current->signal->tty ||
2148 (current->signal->tty != real_tty) ||
2149 (real_tty->session != current->signal->session))
2151 if (get_user(pgrp, p))
2155 if (session_of_pgrp(pgrp) != current->signal->session)
2157 real_tty->pgrp = pgrp;
2161 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2164 * (tty == real_tty) is a cheap way of
2165 * testing if the tty is NOT a master pty.
2167 if (tty == real_tty && current->signal->tty != real_tty)
2169 if (real_tty->session <= 0)
2171 return put_user(real_tty->session, p);
2174 static int tiocsetd(struct tty_struct *tty, int __user *p)
2178 if (get_user(ldisc, p))
2180 return tty_set_ldisc(tty, ldisc);
2183 static int send_break(struct tty_struct *tty, int duration)
2185 tty->driver->break_ctl(tty, -1);
2186 if (!signal_pending(current)) {
2187 set_current_state(TASK_INTERRUPTIBLE);
2188 schedule_timeout(duration);
2190 tty->driver->break_ctl(tty, 0);
2191 if (signal_pending(current))
2197 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2199 int retval = -EINVAL;
2201 if (tty->driver->tiocmget) {
2202 retval = tty->driver->tiocmget(tty, file);
2205 retval = put_user(retval, p);
2211 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2214 int retval = -EINVAL;
2216 if (tty->driver->tiocmset) {
2217 unsigned int set, clear, val;
2219 retval = get_user(val, p);
2237 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2238 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2240 retval = tty->driver->tiocmset(tty, file, set, clear);
2246 * Split this up, as gcc can choke on it otherwise..
2248 int tty_ioctl(struct inode * inode, struct file * file,
2249 unsigned int cmd, unsigned long arg)
2251 struct tty_struct *tty, *real_tty;
2252 void __user *p = (void __user *)arg;
2254 struct tty_ldisc *ld;
2256 tty = (struct tty_struct *)file->private_data;
2257 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2261 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2262 tty->driver->subtype == PTY_TYPE_MASTER)
2263 real_tty = tty->link;
2266 * Break handling by driver
2268 if (!tty->driver->break_ctl) {
2272 if (tty->driver->ioctl)
2273 return tty->driver->ioctl(tty, file, cmd, arg);
2276 /* These two ioctl's always return success; even if */
2277 /* the driver doesn't support them. */
2280 if (!tty->driver->ioctl)
2282 retval = tty->driver->ioctl(tty, file, cmd, arg);
2283 if (retval == -ENOIOCTLCMD)
2290 * Factor out some common prep work
2298 retval = tty_check_change(tty);
2301 if (cmd != TIOCCBRK) {
2302 tty_wait_until_sent(tty, 0);
2303 if (signal_pending(current))
2311 return tiocsti(tty, p);
2313 return tiocgwinsz(tty, p);
2315 return tiocswinsz(tty, real_tty, p);
2317 return real_tty!=tty ? -EINVAL : tioccons(file);
2319 return fionbio(file, p);
2321 set_bit(TTY_EXCLUSIVE, &tty->flags);
2324 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2327 if (current->signal->tty != tty)
2329 if (current->signal->leader)
2330 disassociate_ctty(0);
2332 current->signal->tty = NULL;
2333 task_unlock(current);
2336 return tiocsctty(tty, arg);
2338 return tiocgpgrp(tty, real_tty, p);
2340 return tiocspgrp(tty, real_tty, p);
2342 return tiocgsid(tty, real_tty, p);
2344 /* FIXME: check this is ok */
2345 return put_user(tty->ldisc.num, (int __user *)p);
2347 return tiocsetd(tty, p);
2350 return tioclinux(tty, arg);
2355 case TIOCSBRK: /* Turn break on, unconditionally */
2356 tty->driver->break_ctl(tty, -1);
2359 case TIOCCBRK: /* Turn break off, unconditionally */
2360 tty->driver->break_ctl(tty, 0);
2362 case TCSBRK: /* SVID version: non-zero arg --> no break */
2364 * XXX is the above comment correct, or the
2365 * code below correct? Is this ioctl used at
2369 return send_break(tty, HZ/4);
2371 case TCSBRKP: /* support for POSIX tcsendbreak() */
2372 return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
2375 return tty_tiocmget(tty, file, p);
2380 return tty_tiocmset(tty, file, cmd, p);
2382 if (tty->driver->ioctl) {
2383 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2384 if (retval != -ENOIOCTLCMD)
2387 ld = tty_ldisc_ref_wait(tty);
2390 retval = ld->ioctl(tty, file, cmd, arg);
2391 if (retval == -ENOIOCTLCMD)
2394 tty_ldisc_deref(ld);
2400 * This implements the "Secure Attention Key" --- the idea is to
2401 * prevent trojan horses by killing all processes associated with this
2402 * tty when the user hits the "Secure Attention Key". Required for
2403 * super-paranoid applications --- see the Orange Book for more details.
2405 * This code could be nicer; ideally it should send a HUP, wait a few
2406 * seconds, then send a INT, and then a KILL signal. But you then
2407 * have to coordinate with the init process, since all processes associated
2408 * with the current tty must be dead before the new getty is allowed
2411 * Now, if it would be correct ;-/ The current code has a nasty hole -
2412 * it doesn't catch files in flight. We may send the descriptor to ourselves
2413 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2415 * Nasty bug: do_SAK is being called in interrupt context. This can
2416 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2418 static void __do_SAK(void *arg)
2423 struct tty_struct *tty = arg;
2424 struct task_struct *p;
2428 struct tty_ldisc *disc;
2432 session = tty->session;
2434 /* We don't want an ldisc switch during this */
2435 disc = tty_ldisc_ref(tty);
2436 if (disc && disc->flush_buffer)
2437 disc->flush_buffer(tty);
2438 tty_ldisc_deref(disc);
2440 if (tty->driver->flush_buffer)
2441 tty->driver->flush_buffer(tty);
2443 read_lock(&tasklist_lock);
2444 do_each_task_pid(session, PIDTYPE_SID, p) {
2445 if (p->signal->tty == tty || session > 0) {
2446 printk(KERN_NOTICE "SAK: killed process %d"
2447 " (%s): p->signal->session==tty->session\n",
2449 send_sig(SIGKILL, p, 1);
2454 spin_lock(&p->files->file_lock);
2455 for (i=0; i < p->files->max_fds; i++) {
2456 filp = fcheck_files(p->files, i);
2459 if (filp->f_op->read == tty_read &&
2460 filp->private_data == tty) {
2461 printk(KERN_NOTICE "SAK: killed process %d"
2462 " (%s): fd#%d opened to the tty\n",
2463 p->pid, p->comm, i);
2464 send_sig(SIGKILL, p, 1);
2468 spin_unlock(&p->files->file_lock);
2471 } while_each_task_pid(session, PIDTYPE_SID, p);
2472 read_unlock(&tasklist_lock);
2477 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2478 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2479 * the values which we write to it will be identical to the values which it
2480 * already has. --akpm
2482 void do_SAK(struct tty_struct *tty)
2486 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2487 schedule_work(&tty->SAK_work);
2490 EXPORT_SYMBOL(do_SAK);
2493 * This routine is called out of the software interrupt to flush data
2494 * from the flip buffer to the line discipline.
2497 static void flush_to_ldisc(void *private_)
2499 struct tty_struct *tty = (struct tty_struct *) private_;
2503 unsigned long flags;
2504 struct tty_ldisc *disc;
2506 disc = tty_ldisc_ref(tty);
2507 if (disc == NULL) /* !TTY_LDISC */
2510 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2512 * Do it after the next timer tick:
2514 schedule_delayed_work(&tty->flip.work, 1);
2517 spin_lock_irqsave(&tty->read_lock, flags);
2518 if (tty->flip.buf_num) {
2519 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2520 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2521 tty->flip.buf_num = 0;
2522 tty->flip.char_buf_ptr = tty->flip.char_buf;
2523 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2525 cp = tty->flip.char_buf;
2526 fp = tty->flip.flag_buf;
2527 tty->flip.buf_num = 1;
2528 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2529 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2531 count = tty->flip.count;
2532 tty->flip.count = 0;
2533 spin_unlock_irqrestore(&tty->read_lock, flags);
2535 disc->receive_buf(tty, cp, fp, count);
2537 tty_ldisc_deref(disc);
2541 * Routine which returns the baud rate of the tty
2543 * Note that the baud_table needs to be kept in sync with the
2544 * include/asm/termbits.h file.
2546 static int baud_table[] = {
2547 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2548 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2550 76800, 153600, 307200, 614400, 921600
2552 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2553 2500000, 3000000, 3500000, 4000000
2557 static int n_baud_table = ARRAY_SIZE(baud_table);
2560 * tty_termios_baud_rate
2561 * @termios: termios structure
2563 * Convert termios baud rate data into a speed. This should be called
2564 * with the termios lock held if this termios is a terminal termios
2565 * structure. May change the termios data.
2568 int tty_termios_baud_rate(struct termios *termios)
2572 cbaud = termios->c_cflag & CBAUD;
2574 if (cbaud & CBAUDEX) {
2577 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2578 termios->c_cflag &= ~CBAUDEX;
2582 return baud_table[cbaud];
2585 EXPORT_SYMBOL(tty_termios_baud_rate);
2588 * tty_get_baud_rate - get tty bit rates
2589 * @tty: tty to query
2591 * Returns the baud rate as an integer for this terminal. The
2592 * termios lock must be held by the caller and the terminal bit
2593 * flags may be updated.
2596 int tty_get_baud_rate(struct tty_struct *tty)
2598 int baud = tty_termios_baud_rate(tty->termios);
2600 if (baud == 38400 && tty->alt_speed) {
2602 printk(KERN_WARNING "Use of setserial/setrocket to "
2603 "set SPD_* flags is deprecated\n");
2606 baud = tty->alt_speed;
2612 EXPORT_SYMBOL(tty_get_baud_rate);
2615 * tty_flip_buffer_push - terminal
2618 * Queue a push of the terminal flip buffers to the line discipline. This
2619 * function must not be called from IRQ context if tty->low_latency is set.
2621 * In the event of the queue being busy for flipping the work will be
2622 * held off and retried later.
2625 void tty_flip_buffer_push(struct tty_struct *tty)
2627 if (tty->low_latency)
2628 flush_to_ldisc((void *) tty);
2630 schedule_delayed_work(&tty->flip.work, 1);
2633 EXPORT_SYMBOL(tty_flip_buffer_push);
2636 * This subroutine initializes a tty structure.
2638 static void initialize_tty_struct(struct tty_struct *tty)
2640 memset(tty, 0, sizeof(struct tty_struct));
2641 tty->magic = TTY_MAGIC;
2642 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2644 tty->overrun_time = jiffies;
2645 tty->flip.char_buf_ptr = tty->flip.char_buf;
2646 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2647 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2648 init_MUTEX(&tty->flip.pty_sem);
2649 init_MUTEX(&tty->termios_sem);
2650 init_waitqueue_head(&tty->write_wait);
2651 init_waitqueue_head(&tty->read_wait);
2652 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2653 sema_init(&tty->atomic_read, 1);
2654 sema_init(&tty->atomic_write, 1);
2655 spin_lock_init(&tty->read_lock);
2656 INIT_LIST_HEAD(&tty->tty_files);
2657 INIT_WORK(&tty->SAK_work, NULL, NULL);
2661 * The default put_char routine if the driver did not define one.
2663 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2665 tty->driver->write(tty, &ch, 1);
2668 static struct class *tty_class;
2671 * tty_register_device - register a tty device
2672 * @driver: the tty driver that describes the tty device
2673 * @index: the index in the tty driver for this tty device
2674 * @device: a struct device that is associated with this tty device.
2675 * This field is optional, if there is no known struct device for this
2676 * tty device it can be set to NULL safely.
2678 * This call is required to be made to register an individual tty device if
2679 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2680 * bit is not set, this function should not be called.
2682 void tty_register_device(struct tty_driver *driver, unsigned index,
2683 struct device *device)
2686 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2688 if (index >= driver->num) {
2689 printk(KERN_ERR "Attempt to register invalid tty line number "
2694 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2695 "%s%d", driver->devfs_name, index + driver->name_base);
2697 if (driver->type == TTY_DRIVER_TYPE_PTY)
2698 pty_line_name(driver, index, name);
2700 tty_line_name(driver, index, name);
2701 class_device_create(tty_class, dev, device, name);
2705 * tty_unregister_device - unregister a tty device
2706 * @driver: the tty driver that describes the tty device
2707 * @index: the index in the tty driver for this tty device
2709 * If a tty device is registered with a call to tty_register_device() then
2710 * this function must be made when the tty device is gone.
2712 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2714 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2715 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
2718 EXPORT_SYMBOL(tty_register_device);
2719 EXPORT_SYMBOL(tty_unregister_device);
2721 struct tty_driver *alloc_tty_driver(int lines)
2723 struct tty_driver *driver;
2725 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2727 memset(driver, 0, sizeof(struct tty_driver));
2728 driver->magic = TTY_DRIVER_MAGIC;
2729 driver->num = lines;
2730 /* later we'll move allocation of tables here */
2735 void put_tty_driver(struct tty_driver *driver)
2740 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2742 driver->open = op->open;
2743 driver->close = op->close;
2744 driver->write = op->write;
2745 driver->put_char = op->put_char;
2746 driver->flush_chars = op->flush_chars;
2747 driver->write_room = op->write_room;
2748 driver->chars_in_buffer = op->chars_in_buffer;
2749 driver->ioctl = op->ioctl;
2750 driver->set_termios = op->set_termios;
2751 driver->throttle = op->throttle;
2752 driver->unthrottle = op->unthrottle;
2753 driver->stop = op->stop;
2754 driver->start = op->start;
2755 driver->hangup = op->hangup;
2756 driver->break_ctl = op->break_ctl;
2757 driver->flush_buffer = op->flush_buffer;
2758 driver->set_ldisc = op->set_ldisc;
2759 driver->wait_until_sent = op->wait_until_sent;
2760 driver->send_xchar = op->send_xchar;
2761 driver->read_proc = op->read_proc;
2762 driver->write_proc = op->write_proc;
2763 driver->tiocmget = op->tiocmget;
2764 driver->tiocmset = op->tiocmset;
2768 EXPORT_SYMBOL(alloc_tty_driver);
2769 EXPORT_SYMBOL(put_tty_driver);
2770 EXPORT_SYMBOL(tty_set_operations);
2773 * Called by a tty driver to register itself.
2775 int tty_register_driver(struct tty_driver *driver)
2782 if (driver->flags & TTY_DRIVER_INSTALLED)
2785 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2786 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2789 memset(p, 0, driver->num * 3 * sizeof(void *));
2792 if (!driver->major) {
2793 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2794 (char*)driver->name);
2796 driver->major = MAJOR(dev);
2797 driver->minor_start = MINOR(dev);
2800 dev = MKDEV(driver->major, driver->minor_start);
2801 error = register_chrdev_region(dev, driver->num,
2802 (char*)driver->name);
2810 driver->ttys = (struct tty_struct **)p;
2811 driver->termios = (struct termios **)(p + driver->num);
2812 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2814 driver->ttys = NULL;
2815 driver->termios = NULL;
2816 driver->termios_locked = NULL;
2819 cdev_init(&driver->cdev, &tty_fops);
2820 driver->cdev.owner = driver->owner;
2821 error = cdev_add(&driver->cdev, dev, driver->num);
2823 cdev_del(&driver->cdev);
2824 unregister_chrdev_region(dev, driver->num);
2825 driver->ttys = NULL;
2826 driver->termios = driver->termios_locked = NULL;
2831 if (!driver->put_char)
2832 driver->put_char = tty_default_put_char;
2834 list_add(&driver->tty_drivers, &tty_drivers);
2836 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2837 for(i = 0; i < driver->num; i++)
2838 tty_register_device(driver, i, NULL);
2840 proc_tty_register_driver(driver);
2844 EXPORT_SYMBOL(tty_register_driver);
2847 * Called by a tty driver to unregister itself.
2849 int tty_unregister_driver(struct tty_driver *driver)
2855 if (driver->refcount)
2858 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2861 list_del(&driver->tty_drivers);
2864 * Free the termios and termios_locked structures because
2865 * we don't want to get memory leaks when modular tty
2866 * drivers are removed from the kernel.
2868 for (i = 0; i < driver->num; i++) {
2869 tp = driver->termios[i];
2871 driver->termios[i] = NULL;
2874 tp = driver->termios_locked[i];
2876 driver->termios_locked[i] = NULL;
2879 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2880 tty_unregister_device(driver, i);
2883 proc_tty_unregister_driver(driver);
2884 driver->ttys = NULL;
2885 driver->termios = driver->termios_locked = NULL;
2887 cdev_del(&driver->cdev);
2891 EXPORT_SYMBOL(tty_unregister_driver);
2895 * Initialize the console device. This is called *early*, so
2896 * we can't necessarily depend on lots of kernel help here.
2897 * Just do some early initializations, and do the complex setup
2900 void __init console_init(void)
2904 /* Setup the default TTY line discipline. */
2905 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2908 * set up the console device so that later boot sequences can
2909 * inform about problems etc..
2911 #ifdef CONFIG_EARLY_PRINTK
2912 disable_early_printk();
2914 #ifdef CONFIG_SERIAL_68360
2915 /* This is not a console initcall. I know not what it's doing here.
2916 So I haven't moved it. dwmw2 */
2919 call = __con_initcall_start;
2920 while (call < __con_initcall_end) {
2927 extern int vty_init(void);
2930 static int __init tty_class_init(void)
2932 tty_class = class_create(THIS_MODULE, "tty");
2933 if (IS_ERR(tty_class))
2934 return PTR_ERR(tty_class);
2938 postcore_initcall(tty_class_init);
2940 /* 3/2004 jmc: why do these devices exist? */
2942 static struct cdev tty_cdev, console_cdev;
2943 #ifdef CONFIG_UNIX98_PTYS
2944 static struct cdev ptmx_cdev;
2947 static struct cdev vc0_cdev;
2951 * Ok, now we can initialize the rest of the tty devices and can count
2952 * on memory allocations, interrupts etc..
2954 static int __init tty_init(void)
2956 cdev_init(&tty_cdev, &tty_fops);
2957 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2958 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2959 panic("Couldn't register /dev/tty driver\n");
2960 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2961 class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2963 cdev_init(&console_cdev, &console_fops);
2964 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2965 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2966 panic("Couldn't register /dev/console driver\n");
2967 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2968 class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2970 #ifdef CONFIG_UNIX98_PTYS
2971 cdev_init(&ptmx_cdev, &ptmx_fops);
2972 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2973 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2974 panic("Couldn't register /dev/ptmx driver\n");
2975 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2976 class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2980 cdev_init(&vc0_cdev, &console_fops);
2981 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2982 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2983 panic("Couldn't register /dev/tty0 driver\n");
2984 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
2985 class_device_create(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
2991 module_init(tty_init);