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>
105 #include <linux/vs_cvirt.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 extern void rs_360_init(void);
157 static void release_mem(struct tty_struct *tty, int idx);
160 static struct tty_struct *alloc_tty_struct(void)
162 struct tty_struct *tty;
164 tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
166 memset(tty, 0, sizeof(struct tty_struct));
170 static inline void free_tty_struct(struct tty_struct *tty)
172 kfree(tty->write_buf);
176 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
178 char *tty_name(struct tty_struct *tty, char *buf)
180 if (!tty) /* Hmm. NULL pointer. That's fun. */
181 strcpy(buf, "NULL tty");
183 strcpy(buf, tty->name);
187 EXPORT_SYMBOL(tty_name);
189 inline int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
192 #ifdef TTY_PARANOIA_CHECK
195 "null TTY for (%d:%d) in %s\n",
196 imajor(inode), iminor(inode), routine);
199 if (tty->magic != TTY_MAGIC) {
201 "bad magic number for tty struct (%d:%d) in %s\n",
202 imajor(inode), iminor(inode), routine);
209 static int check_tty_count(struct tty_struct *tty, const char *routine)
211 #ifdef CHECK_TTY_COUNT
216 list_for_each(p, &tty->tty_files) {
220 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
221 tty->driver->subtype == PTY_TYPE_SLAVE &&
222 tty->link && tty->link->count)
224 if (tty->count != count) {
225 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
226 "!= #fd's(%d) in %s\n",
227 tty->name, tty->count, count, routine);
235 * This is probably overkill for real world processors but
236 * they are not on hot paths so a little discipline won't do
240 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
242 down(&tty->termios_sem);
243 tty->termios->c_line = num;
244 up(&tty->termios_sem);
248 * This guards the refcounted line discipline lists. The lock
249 * must be taken with irqs off because there are hangup path
250 * callers who will do ldisc lookups and cannot sleep.
253 static DEFINE_SPINLOCK(tty_ldisc_lock);
254 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
255 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
257 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
262 if (disc < N_TTY || disc >= NR_LDISCS)
265 spin_lock_irqsave(&tty_ldisc_lock, flags);
267 tty_ldiscs[disc] = *new_ldisc;
268 tty_ldiscs[disc].num = disc;
269 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
270 tty_ldiscs[disc].refcount = 0;
272 if(tty_ldiscs[disc].refcount)
275 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
277 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
282 EXPORT_SYMBOL(tty_register_ldisc);
284 struct tty_ldisc *tty_ldisc_get(int disc)
287 struct tty_ldisc *ld;
289 if (disc < N_TTY || disc >= NR_LDISCS)
292 spin_lock_irqsave(&tty_ldisc_lock, flags);
294 ld = &tty_ldiscs[disc];
295 /* Check the entry is defined */
296 if(ld->flags & LDISC_FLAG_DEFINED)
298 /* If the module is being unloaded we can't use it */
299 if (!try_module_get(ld->owner))
306 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
310 EXPORT_SYMBOL_GPL(tty_ldisc_get);
312 void tty_ldisc_put(int disc)
314 struct tty_ldisc *ld;
317 if (disc < N_TTY || disc >= NR_LDISCS)
320 spin_lock_irqsave(&tty_ldisc_lock, flags);
321 ld = &tty_ldiscs[disc];
322 if(ld->refcount == 0)
325 module_put(ld->owner);
326 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
329 EXPORT_SYMBOL_GPL(tty_ldisc_put);
331 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
334 tty->ldisc.refcount = 0;
338 * tty_ldisc_try - internal helper
341 * Make a single attempt to grab and bump the refcount on
342 * the tty ldisc. Return 0 on failure or 1 on success. This is
343 * used to implement both the waiting and non waiting versions
347 static int tty_ldisc_try(struct tty_struct *tty)
350 struct tty_ldisc *ld;
353 spin_lock_irqsave(&tty_ldisc_lock, flags);
355 if(test_bit(TTY_LDISC, &tty->flags))
360 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
365 * tty_ldisc_ref_wait - wait for the tty ldisc
368 * Dereference the line discipline for the terminal and take a
369 * reference to it. If the line discipline is in flux then
370 * wait patiently until it changes.
372 * Note: Must not be called from an IRQ/timer context. The caller
373 * must also be careful not to hold other locks that will deadlock
374 * against a discipline change, such as an existing ldisc reference
375 * (which we check for)
378 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
380 /* wait_event is a macro */
381 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
382 if(tty->ldisc.refcount == 0)
383 printk(KERN_ERR "tty_ldisc_ref_wait\n");
387 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
390 * tty_ldisc_ref - get the tty ldisc
393 * Dereference the line discipline for the terminal and take a
394 * reference to it. If the line discipline is in flux then
395 * return NULL. Can be called from IRQ and timer functions.
398 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
400 if(tty_ldisc_try(tty))
405 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
408 * tty_ldisc_deref - free a tty ldisc reference
409 * @ld: reference to free up
411 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
412 * be called in IRQ context.
415 void tty_ldisc_deref(struct tty_ldisc *ld)
422 spin_lock_irqsave(&tty_ldisc_lock, flags);
423 if(ld->refcount == 0)
424 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
427 if(ld->refcount == 0)
428 wake_up(&tty_ldisc_wait);
429 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
432 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
435 * tty_ldisc_enable - allow ldisc use
436 * @tty: terminal to activate ldisc on
438 * Set the TTY_LDISC flag when the line discipline can be called
439 * again. Do neccessary wakeups for existing sleepers.
441 * Note: nobody should set this bit except via this function. Clearing
442 * directly is allowed.
445 static void tty_ldisc_enable(struct tty_struct *tty)
447 set_bit(TTY_LDISC, &tty->flags);
448 wake_up(&tty_ldisc_wait);
452 * tty_set_ldisc - set line discipline
453 * @tty: the terminal to set
454 * @ldisc: the line discipline
456 * Set the discipline of a tty line. Must be called from a process
460 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
463 struct tty_ldisc o_ldisc;
467 struct tty_ldisc *ld;
469 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
474 if (tty->ldisc.num == ldisc)
475 return 0; /* We are already in the desired discipline */
477 ld = tty_ldisc_get(ldisc);
478 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
479 /* Cyrus Durgin <cider@speakeasy.org> */
481 request_module("tty-ldisc-%d", ldisc);
482 ld = tty_ldisc_get(ldisc);
487 o_ldisc = tty->ldisc;
489 tty_wait_until_sent(tty, 0);
492 * Make sure we don't change while someone holds a
493 * reference to the line discipline. The TTY_LDISC bit
494 * prevents anyone taking a reference once it is clear.
495 * We need the lock to avoid racing reference takers.
498 spin_lock_irqsave(&tty_ldisc_lock, flags);
499 if(tty->ldisc.refcount)
501 /* Free the new ldisc we grabbed. Must drop the lock
503 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
504 tty_ldisc_put(ldisc);
506 * There are several reasons we may be busy, including
507 * random momentary I/O traffic. We must therefore
508 * retry. We could distinguish between blocking ops
509 * and retries if we made tty_ldisc_wait() smarter. That
510 * is up for discussion.
512 if(wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
516 clear_bit(TTY_LDISC, &tty->flags);
517 clear_bit(TTY_DONT_FLIP, &tty->flags);
518 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
521 * From this point on we know nobody has an ldisc
522 * usage reference, nor can they obtain one until
523 * we say so later on.
526 work = cancel_delayed_work(&tty->flip.work);
528 * Wait for ->hangup_work and ->flip.work handlers to terminate
531 flush_scheduled_work();
532 /* Shutdown the current discipline. */
533 if (tty->ldisc.close)
534 (tty->ldisc.close)(tty);
536 /* Now set up the new line discipline. */
537 tty_ldisc_assign(tty, ld);
538 tty_set_termios_ldisc(tty, ldisc);
540 retval = (tty->ldisc.open)(tty);
542 tty_ldisc_put(ldisc);
543 /* There is an outstanding reference here so this is safe */
544 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
545 tty_set_termios_ldisc(tty, tty->ldisc.num);
546 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
547 tty_ldisc_put(o_ldisc.num);
548 /* This driver is always present */
549 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
550 tty_set_termios_ldisc(tty, N_TTY);
551 if (tty->ldisc.open) {
552 int r = tty->ldisc.open(tty);
555 panic("Couldn't open N_TTY ldisc for "
557 tty_name(tty, buf), r);
561 /* At this point we hold a reference to the new ldisc and a
562 a reference to the old ldisc. If we ended up flipping back
563 to the existing ldisc we have two references to it */
565 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
566 tty->driver->set_ldisc(tty);
568 tty_ldisc_put(o_ldisc.num);
571 * Allow ldisc referencing to occur as soon as the driver
572 * ldisc callback completes.
575 tty_ldisc_enable(tty);
577 /* Restart it in case no characters kick it off. Safe if
580 schedule_delayed_work(&tty->flip.work, 1);
585 * This routine returns a tty driver structure, given a device number
587 static struct tty_driver *get_tty_driver(dev_t device, int *index)
589 struct tty_driver *p;
591 list_for_each_entry(p, &tty_drivers, tty_drivers) {
592 dev_t base = MKDEV(p->major, p->minor_start);
593 if (device < base || device >= base + p->num)
595 *index = device - base;
602 * If we try to write to, or set the state of, a terminal and we're
603 * not in the foreground, send a SIGTTOU. If the signal is blocked or
604 * ignored, go ahead and perform the operation. (POSIX 7.2)
606 int tty_check_change(struct tty_struct * tty)
608 if (current->signal->tty != tty)
610 if (tty->pgrp <= 0) {
611 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
614 if (process_group(current) == tty->pgrp)
616 if (is_ignored(SIGTTOU))
618 if (is_orphaned_pgrp(process_group(current)))
620 (void) kill_pg(process_group(current), SIGTTOU, 1);
624 EXPORT_SYMBOL(tty_check_change);
626 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
627 size_t count, loff_t *ppos)
632 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
633 size_t count, loff_t *ppos)
638 /* No kernel lock held - none needed ;) */
639 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
641 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
644 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
645 unsigned int cmd, unsigned long arg)
647 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
650 static struct file_operations tty_fops = {
657 .release = tty_release,
658 .fasync = tty_fasync,
661 #ifdef CONFIG_UNIX98_PTYS
662 static struct file_operations ptmx_fops = {
669 .release = tty_release,
670 .fasync = tty_fasync,
674 static struct file_operations console_fops = {
677 .write = redirected_tty_write,
681 .release = tty_release,
682 .fasync = tty_fasync,
685 static struct file_operations hung_up_tty_fops = {
687 .read = hung_up_tty_read,
688 .write = hung_up_tty_write,
689 .poll = hung_up_tty_poll,
690 .ioctl = hung_up_tty_ioctl,
691 .release = tty_release,
694 static DEFINE_SPINLOCK(redirect_lock);
695 static struct file *redirect;
698 * tty_wakeup - request more data
701 * Internal and external helper for wakeups of tty. This function
702 * informs the line discipline if present that the driver is ready
703 * to receive more output data.
706 void tty_wakeup(struct tty_struct *tty)
708 struct tty_ldisc *ld;
710 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
711 ld = tty_ldisc_ref(tty);
714 ld->write_wakeup(tty);
718 wake_up_interruptible(&tty->write_wait);
721 EXPORT_SYMBOL_GPL(tty_wakeup);
724 * tty_ldisc_flush - flush line discipline queue
727 * Flush the line discipline queue (if any) for this tty. If there
728 * is no line discipline active this is a no-op.
731 void tty_ldisc_flush(struct tty_struct *tty)
733 struct tty_ldisc *ld = tty_ldisc_ref(tty);
736 ld->flush_buffer(tty);
741 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
744 * This can be called by the "eventd" kernel thread. That is process synchronous,
745 * but doesn't hold any locks, so we need to make sure we have the appropriate
746 * locks for what we're doing..
748 static void do_tty_hangup(void *data)
750 struct tty_struct *tty = (struct tty_struct *) data;
751 struct file * cons_filp = NULL;
752 struct file *filp, *f = NULL;
753 struct task_struct *p;
754 struct tty_ldisc *ld;
755 int closecount = 0, n;
760 /* inuse_filps is protected by the single kernel lock */
763 spin_lock(&redirect_lock);
764 if (redirect && redirect->private_data == tty) {
768 spin_unlock(&redirect_lock);
770 check_tty_count(tty, "do_tty_hangup");
772 /* This breaks for file handles being sent over AF_UNIX sockets ? */
773 list_for_each_entry(filp, &tty->tty_files, f_list) {
774 if (filp->f_op->write == redirected_tty_write)
776 if (filp->f_op->write != tty_write)
779 tty_fasync(-1, filp, 0); /* can't block */
780 filp->f_op = &hung_up_tty_fops;
784 /* FIXME! What are the locking issues here? This may me overdoing things..
785 * this question is especially important now that we've removed the irqlock. */
787 ld = tty_ldisc_ref(tty);
788 if(ld != NULL) /* We may have no line discipline at this point */
790 if (ld->flush_buffer)
791 ld->flush_buffer(tty);
792 if (tty->driver->flush_buffer)
793 tty->driver->flush_buffer(tty);
794 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
796 ld->write_wakeup(tty);
801 /* FIXME: Once we trust the LDISC code better we can wait here for
802 ldisc completion and fix the driver call race */
804 wake_up_interruptible(&tty->write_wait);
805 wake_up_interruptible(&tty->read_wait);
808 * Shutdown the current line discipline, and reset it to
811 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
813 down(&tty->termios_sem);
814 *tty->termios = tty->driver->init_termios;
815 up(&tty->termios_sem);
818 /* Defer ldisc switch */
819 /* tty_deferred_ldisc_switch(N_TTY);
821 This should get done automatically when the port closes and
822 tty_release is called */
824 read_lock(&tasklist_lock);
825 if (tty->session > 0) {
826 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
827 if (p->signal->tty == tty)
828 p->signal->tty = NULL;
829 if (!p->signal->leader)
831 send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
832 send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
834 p->signal->tty_old_pgrp = tty->pgrp;
835 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
837 read_unlock(&tasklist_lock);
842 tty->ctrl_status = 0;
844 * If one of the devices matches a console pointer, we
845 * cannot just call hangup() because that will cause
846 * tty->count and state->count to go out of sync.
847 * So we just call close() the right number of times.
850 if (tty->driver->close)
851 for (n = 0; n < closecount; n++)
852 tty->driver->close(tty, cons_filp);
853 } else if (tty->driver->hangup)
854 (tty->driver->hangup)(tty);
856 /* We don't want to have driver/ldisc interactions beyond
857 the ones we did here. The driver layer expects no
858 calls after ->hangup() from the ldisc side. However we
859 can't yet guarantee all that */
861 set_bit(TTY_HUPPED, &tty->flags);
863 tty_ldisc_enable(tty);
871 void tty_hangup(struct tty_struct * tty)
873 #ifdef TTY_DEBUG_HANGUP
876 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
878 schedule_work(&tty->hangup_work);
881 EXPORT_SYMBOL(tty_hangup);
883 void tty_vhangup(struct tty_struct * tty)
885 #ifdef TTY_DEBUG_HANGUP
888 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
890 do_tty_hangup((void *) tty);
892 EXPORT_SYMBOL(tty_vhangup);
894 int tty_hung_up_p(struct file * filp)
896 return (filp->f_op == &hung_up_tty_fops);
899 EXPORT_SYMBOL(tty_hung_up_p);
902 * This function is typically called only by the session leader, when
903 * it wants to disassociate itself from its controlling tty.
905 * It performs the following functions:
906 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
907 * (2) Clears the tty from being controlling the session
908 * (3) Clears the controlling tty for all processes in the
911 * The argument on_exit is set to 1 if called when a process is
912 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
914 void disassociate_ctty(int on_exit)
916 struct tty_struct *tty;
917 struct task_struct *p;
923 tty = current->signal->tty;
925 tty_pgrp = tty->pgrp;
927 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
930 if (current->signal->tty_old_pgrp) {
931 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
932 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
939 kill_pg(tty_pgrp, SIGHUP, on_exit);
941 kill_pg(tty_pgrp, SIGCONT, on_exit);
944 /* Must lock changes to tty_old_pgrp */
946 current->signal->tty_old_pgrp = 0;
950 /* Now clear signal->tty under the lock */
951 read_lock(&tasklist_lock);
952 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
953 p->signal->tty = NULL;
954 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
955 read_unlock(&tasklist_lock);
960 void stop_tty(struct tty_struct *tty)
965 if (tty->link && tty->link->packet) {
966 tty->ctrl_status &= ~TIOCPKT_START;
967 tty->ctrl_status |= TIOCPKT_STOP;
968 wake_up_interruptible(&tty->link->read_wait);
970 if (tty->driver->stop)
971 (tty->driver->stop)(tty);
974 EXPORT_SYMBOL(stop_tty);
976 void start_tty(struct tty_struct *tty)
978 if (!tty->stopped || tty->flow_stopped)
981 if (tty->link && tty->link->packet) {
982 tty->ctrl_status &= ~TIOCPKT_STOP;
983 tty->ctrl_status |= TIOCPKT_START;
984 wake_up_interruptible(&tty->link->read_wait);
986 if (tty->driver->start)
987 (tty->driver->start)(tty);
989 /* If we have a running line discipline it may need kicking */
991 wake_up_interruptible(&tty->write_wait);
994 EXPORT_SYMBOL(start_tty);
996 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1000 struct tty_struct * tty;
1001 struct inode *inode;
1002 struct tty_ldisc *ld;
1004 tty = (struct tty_struct *)file->private_data;
1005 inode = file->f_dentry->d_inode;
1006 if (tty_paranoia_check(tty, inode, "tty_read"))
1008 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1011 /* We want to wait for the line discipline to sort out in this
1013 ld = tty_ldisc_ref_wait(tty);
1016 i = (ld->read)(tty,file,buf,count);
1019 tty_ldisc_deref(ld);
1022 inode->i_atime = current_fs_time(inode->i_sb);
1027 * Split writes up in sane blocksizes to avoid
1028 * denial-of-service type attacks
1030 static inline ssize_t do_tty_write(
1031 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1032 struct tty_struct *tty,
1034 const char __user *buf,
1037 ssize_t ret = 0, written = 0;
1040 if (down_interruptible(&tty->atomic_write)) {
1041 return -ERESTARTSYS;
1045 * We chunk up writes into a temporary buffer. This
1046 * simplifies low-level drivers immensely, since they
1047 * don't have locking issues and user mode accesses.
1049 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1052 * The default chunk-size is 2kB, because the NTTY
1053 * layer has problems with bigger chunks. It will
1054 * claim to be able to handle more characters than
1058 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1063 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1064 if (tty->write_cnt < chunk) {
1070 buf = kmalloc(chunk, GFP_KERNEL);
1072 up(&tty->atomic_write);
1075 kfree(tty->write_buf);
1076 tty->write_cnt = chunk;
1077 tty->write_buf = buf;
1080 /* Do the write .. */
1082 size_t size = count;
1086 if (copy_from_user(tty->write_buf, buf, size))
1089 ret = write(tty, file, tty->write_buf, size);
1099 if (signal_pending(current))
1104 struct inode *inode = file->f_dentry->d_inode;
1105 inode->i_mtime = current_fs_time(inode->i_sb);
1108 up(&tty->atomic_write);
1113 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1116 struct tty_struct * tty;
1117 struct inode *inode = file->f_dentry->d_inode;
1119 struct tty_ldisc *ld;
1121 tty = (struct tty_struct *)file->private_data;
1122 if (tty_paranoia_check(tty, inode, "tty_write"))
1124 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1127 ld = tty_ldisc_ref_wait(tty);
1131 ret = do_tty_write(ld->write, tty, file, buf, count);
1132 tty_ldisc_deref(ld);
1136 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1139 struct file *p = NULL;
1141 spin_lock(&redirect_lock);
1146 spin_unlock(&redirect_lock);
1150 res = vfs_write(p, buf, count, &p->f_pos);
1155 return tty_write(file, buf, count, ppos);
1158 static char ptychar[] = "pqrstuvwxyzabcde";
1160 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1162 int i = index + driver->name_base;
1163 /* ->name is initialized to "ttyp", but "tty" is expected */
1164 sprintf(p, "%s%c%x",
1165 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1166 ptychar[i >> 4 & 0xf], i & 0xf);
1169 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1171 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1175 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1176 * failed open. The new code protects the open with a semaphore, so it's
1177 * really quite straightforward. The semaphore locking can probably be
1178 * relaxed for the (most common) case of reopening a tty.
1180 static int init_dev(struct tty_driver *driver, int idx,
1181 struct tty_struct **ret_tty)
1183 struct tty_struct *tty, *o_tty;
1184 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1185 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1188 /* check whether we're reopening an existing tty */
1189 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1190 tty = devpts_get_tty(idx);
1191 if (tty && driver->subtype == PTY_TYPE_MASTER)
1194 tty = driver->ttys[idx];
1196 if (tty) goto fast_track;
1199 * First time open is complex, especially for PTY devices.
1200 * This code guarantees that either everything succeeds and the
1201 * TTY is ready for operation, or else the table slots are vacated
1202 * and the allocated memory released. (Except that the termios
1203 * and locked termios may be retained.)
1206 if (!try_module_get(driver->owner)) {
1215 tty = alloc_tty_struct();
1218 initialize_tty_struct(tty);
1219 tty->driver = driver;
1221 tty_line_name(driver, idx, tty->name);
1223 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1224 tp_loc = &tty->termios;
1225 ltp_loc = &tty->termios_locked;
1227 tp_loc = &driver->termios[idx];
1228 ltp_loc = &driver->termios_locked[idx];
1232 tp = (struct termios *) kmalloc(sizeof(struct termios),
1236 *tp = driver->init_termios;
1240 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1244 memset(ltp, 0, sizeof(struct termios));
1247 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1248 o_tty = alloc_tty_struct();
1251 initialize_tty_struct(o_tty);
1252 o_tty->driver = driver->other;
1254 tty_line_name(driver->other, idx, o_tty->name);
1256 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1257 o_tp_loc = &o_tty->termios;
1258 o_ltp_loc = &o_tty->termios_locked;
1260 o_tp_loc = &driver->other->termios[idx];
1261 o_ltp_loc = &driver->other->termios_locked[idx];
1265 o_tp = (struct termios *)
1266 kmalloc(sizeof(struct termios), GFP_KERNEL);
1269 *o_tp = driver->other->init_termios;
1273 o_ltp = (struct termios *)
1274 kmalloc(sizeof(struct termios), GFP_KERNEL);
1277 memset(o_ltp, 0, sizeof(struct termios));
1281 * Everything allocated ... set up the o_tty structure.
1283 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1284 driver->other->ttys[idx] = o_tty;
1290 o_tty->termios = *o_tp_loc;
1291 o_tty->termios_locked = *o_ltp_loc;
1292 driver->other->refcount++;
1293 if (driver->subtype == PTY_TYPE_MASTER)
1296 /* Establish the links in both directions */
1302 * All structures have been allocated, so now we install them.
1303 * Failures after this point use release_mem to clean up, so
1304 * there's no need to null out the local pointers.
1306 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1307 driver->ttys[idx] = tty;
1314 tty->termios = *tp_loc;
1315 tty->termios_locked = *ltp_loc;
1320 * Structures all installed ... call the ldisc open routines.
1321 * If we fail here just call release_mem to clean up. No need
1322 * to decrement the use counts, as release_mem doesn't care.
1325 if (tty->ldisc.open) {
1326 retval = (tty->ldisc.open)(tty);
1328 goto release_mem_out;
1330 if (o_tty && o_tty->ldisc.open) {
1331 retval = (o_tty->ldisc.open)(o_tty);
1333 if (tty->ldisc.close)
1334 (tty->ldisc.close)(tty);
1335 goto release_mem_out;
1337 tty_ldisc_enable(o_tty);
1339 tty_ldisc_enable(tty);
1343 * This fast open can be used if the tty is already open.
1344 * No memory is allocated, and the only failures are from
1345 * attempting to open a closing tty or attempting multiple
1346 * opens on a pty master.
1349 if (test_bit(TTY_CLOSING, &tty->flags)) {
1353 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1354 driver->subtype == PTY_TYPE_MASTER) {
1356 * special case for PTY masters: only one open permitted,
1357 * and the slave side open count is incremented as well.
1366 tty->driver = driver; /* N.B. why do this every time?? */
1369 if(!test_bit(TTY_LDISC, &tty->flags))
1370 printk(KERN_ERR "init_dev but no ldisc\n");
1374 /* All paths come through here to release the semaphore */
1378 /* Release locally allocated memory ... nothing placed in slots */
1383 free_tty_struct(o_tty);
1388 free_tty_struct(tty);
1391 module_put(driver->owner);
1395 /* call the tty release_mem routine to clean out this slot */
1397 printk(KERN_INFO "init_dev: ldisc open failed, "
1398 "clearing slot %d\n", idx);
1399 release_mem(tty, idx);
1404 * Releases memory associated with a tty structure, and clears out the
1405 * driver table slots.
1407 static void release_mem(struct tty_struct *tty, int idx)
1409 struct tty_struct *o_tty;
1411 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1413 if ((o_tty = tty->link) != NULL) {
1415 o_tty->driver->ttys[idx] = NULL;
1416 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1417 tp = o_tty->termios;
1419 o_tty->driver->termios[idx] = NULL;
1422 tp = o_tty->termios_locked;
1424 o_tty->driver->termios_locked[idx] = NULL;
1428 o_tty->driver->refcount--;
1430 list_del_init(&o_tty->tty_files);
1432 free_tty_struct(o_tty);
1436 tty->driver->ttys[idx] = NULL;
1437 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1440 tty->driver->termios[idx] = NULL;
1443 tp = tty->termios_locked;
1445 tty->driver->termios_locked[idx] = NULL;
1450 tty->driver->refcount--;
1452 list_del_init(&tty->tty_files);
1454 module_put(tty->driver->owner);
1455 free_tty_struct(tty);
1459 * Even releasing the tty structures is a tricky business.. We have
1460 * to be very careful that the structures are all released at the
1461 * same time, as interrupts might otherwise get the wrong pointers.
1463 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1464 * lead to double frees or releasing memory still in use.
1466 static void release_dev(struct file * filp)
1468 struct tty_struct *tty, *o_tty;
1469 int pty_master, tty_closing, o_tty_closing, do_sleep;
1470 int devpts_master, devpts;
1473 unsigned long flags;
1475 tty = (struct tty_struct *)filp->private_data;
1476 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1479 check_tty_count(tty, "release_dev");
1481 tty_fasync(-1, filp, 0);
1484 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1485 tty->driver->subtype == PTY_TYPE_MASTER);
1486 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1487 devpts_master = pty_master && devpts;
1490 #ifdef TTY_PARANOIA_CHECK
1491 if (idx < 0 || idx >= tty->driver->num) {
1492 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1493 "free (%s)\n", tty->name);
1496 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1497 if (tty != tty->driver->ttys[idx]) {
1498 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1499 "for (%s)\n", idx, tty->name);
1502 if (tty->termios != tty->driver->termios[idx]) {
1503 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1508 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1509 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1510 "termios_locked for (%s)\n",
1517 #ifdef TTY_DEBUG_HANGUP
1518 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1519 tty_name(tty, buf), tty->count);
1522 #ifdef TTY_PARANOIA_CHECK
1523 if (tty->driver->other &&
1524 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1525 if (o_tty != tty->driver->other->ttys[idx]) {
1526 printk(KERN_DEBUG "release_dev: other->table[%d] "
1527 "not o_tty for (%s)\n",
1531 if (o_tty->termios != tty->driver->other->termios[idx]) {
1532 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1533 "not o_termios for (%s)\n",
1537 if (o_tty->termios_locked !=
1538 tty->driver->other->termios_locked[idx]) {
1539 printk(KERN_DEBUG "release_dev: other->termios_locked["
1540 "%d] not o_termios_locked for (%s)\n",
1544 if (o_tty->link != tty) {
1545 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1550 if (tty->driver->close)
1551 tty->driver->close(tty, filp);
1554 * Sanity check: if tty->count is going to zero, there shouldn't be
1555 * any waiters on tty->read_wait or tty->write_wait. We test the
1556 * wait queues and kick everyone out _before_ actually starting to
1557 * close. This ensures that we won't block while releasing the tty
1560 * The test for the o_tty closing is necessary, since the master and
1561 * slave sides may close in any order. If the slave side closes out
1562 * first, its count will be one, since the master side holds an open.
1563 * Thus this test wouldn't be triggered at the time the slave closes,
1566 * Note that it's possible for the tty to be opened again while we're
1567 * flushing out waiters. By recalculating the closing flags before
1568 * each iteration we avoid any problems.
1571 /* Guard against races with tty->count changes elsewhere and
1572 opens on /dev/tty */
1575 tty_closing = tty->count <= 1;
1576 o_tty_closing = o_tty &&
1577 (o_tty->count <= (pty_master ? 1 : 0));
1582 if (waitqueue_active(&tty->read_wait)) {
1583 wake_up(&tty->read_wait);
1586 if (waitqueue_active(&tty->write_wait)) {
1587 wake_up(&tty->write_wait);
1591 if (o_tty_closing) {
1592 if (waitqueue_active(&o_tty->read_wait)) {
1593 wake_up(&o_tty->read_wait);
1596 if (waitqueue_active(&o_tty->write_wait)) {
1597 wake_up(&o_tty->write_wait);
1604 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1605 "active!\n", tty_name(tty, buf));
1610 * The closing flags are now consistent with the open counts on
1611 * both sides, and we've completed the last operation that could
1612 * block, so it's safe to proceed with closing.
1617 if (--o_tty->count < 0) {
1618 printk(KERN_WARNING "release_dev: bad pty slave count "
1620 o_tty->count, tty_name(o_tty, buf));
1624 if (--tty->count < 0) {
1625 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1626 tty->count, tty_name(tty, buf));
1632 * We've decremented tty->count, so we need to remove this file
1633 * descriptor off the tty->tty_files list; this serves two
1635 * - check_tty_count sees the correct number of file descriptors
1636 * associated with this tty.
1637 * - do_tty_hangup no longer sees this file descriptor as
1638 * something that needs to be handled for hangups.
1641 filp->private_data = NULL;
1644 * Perform some housekeeping before deciding whether to return.
1646 * Set the TTY_CLOSING flag if this was the last open. In the
1647 * case of a pty we may have to wait around for the other side
1648 * to close, and TTY_CLOSING makes sure we can't be reopened.
1651 set_bit(TTY_CLOSING, &tty->flags);
1653 set_bit(TTY_CLOSING, &o_tty->flags);
1656 * If _either_ side is closing, make sure there aren't any
1657 * processes that still think tty or o_tty is their controlling
1660 if (tty_closing || o_tty_closing) {
1661 struct task_struct *p;
1663 read_lock(&tasklist_lock);
1664 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1665 p->signal->tty = NULL;
1666 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1668 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1669 p->signal->tty = NULL;
1670 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1671 read_unlock(&tasklist_lock);
1674 /* check whether both sides are closing ... */
1675 if (!tty_closing || (o_tty && !o_tty_closing))
1678 #ifdef TTY_DEBUG_HANGUP
1679 printk(KERN_DEBUG "freeing tty structure...");
1682 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1683 * kill any delayed work. As this is the final close it does not
1684 * race with the set_ldisc code path.
1686 clear_bit(TTY_LDISC, &tty->flags);
1687 clear_bit(TTY_DONT_FLIP, &tty->flags);
1688 cancel_delayed_work(&tty->flip.work);
1691 * Wait for ->hangup_work and ->flip.work handlers to terminate
1694 flush_scheduled_work();
1697 * Wait for any short term users (we know they are just driver
1698 * side waiters as the file is closing so user count on the file
1701 spin_lock_irqsave(&tty_ldisc_lock, flags);
1702 while(tty->ldisc.refcount)
1704 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1705 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1706 spin_lock_irqsave(&tty_ldisc_lock, flags);
1708 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1710 * Shutdown the current line discipline, and reset it to N_TTY.
1711 * N.B. why reset ldisc when we're releasing the memory??
1713 * FIXME: this MUST get fixed for the new reflocking
1715 if (tty->ldisc.close)
1716 (tty->ldisc.close)(tty);
1717 tty_ldisc_put(tty->ldisc.num);
1720 * Switch the line discipline back
1722 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1723 tty_set_termios_ldisc(tty,N_TTY);
1725 /* FIXME: could o_tty be in setldisc here ? */
1726 clear_bit(TTY_LDISC, &o_tty->flags);
1727 if (o_tty->ldisc.close)
1728 (o_tty->ldisc.close)(o_tty);
1729 tty_ldisc_put(o_tty->ldisc.num);
1730 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1731 tty_set_termios_ldisc(o_tty,N_TTY);
1734 * The release_mem function takes care of the details of clearing
1735 * the slots and preserving the termios structure.
1737 release_mem(tty, idx);
1739 #ifdef CONFIG_UNIX98_PTYS
1740 /* Make this pty number available for reallocation */
1742 down(&allocated_ptys_lock);
1743 idr_remove(&allocated_ptys, idx);
1744 up(&allocated_ptys_lock);
1751 * tty_open and tty_release keep up the tty count that contains the
1752 * number of opens done on a tty. We cannot use the inode-count, as
1753 * different inodes might point to the same tty.
1755 * Open-counting is needed for pty masters, as well as for keeping
1756 * track of serial lines: DTR is dropped when the last close happens.
1757 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1759 * The termios state of a pty is reset on first open so that
1760 * settings don't persist across reuse.
1762 static int tty_open(struct inode * inode, struct file * filp)
1764 struct tty_struct *tty;
1766 struct tty_driver *driver;
1768 dev_t device = inode->i_rdev;
1769 unsigned short saved_flags = filp->f_flags;
1771 nonseekable_open(inode, filp);
1774 noctty = filp->f_flags & O_NOCTTY;
1780 if (device == MKDEV(TTYAUX_MAJOR,0)) {
1781 if (!current->signal->tty) {
1785 driver = current->signal->tty->driver;
1786 index = current->signal->tty->index;
1787 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1792 if (device == MKDEV(TTY_MAJOR,0)) {
1793 extern int fg_console;
1794 extern struct tty_driver *console_driver;
1795 driver = console_driver;
1801 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1802 driver = console_device(&index);
1804 /* Don't let /dev/console block */
1805 filp->f_flags |= O_NONBLOCK;
1813 driver = get_tty_driver(device, &index);
1819 retval = init_dev(driver, index, &tty);
1824 filp->private_data = tty;
1825 file_move(filp, &tty->tty_files);
1826 check_tty_count(tty, "tty_open");
1827 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1828 tty->driver->subtype == PTY_TYPE_MASTER)
1830 #ifdef TTY_DEBUG_HANGUP
1831 printk(KERN_DEBUG "opening %s...", tty->name);
1834 if (tty->driver->open)
1835 retval = tty->driver->open(tty, filp);
1839 filp->f_flags = saved_flags;
1841 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1845 #ifdef TTY_DEBUG_HANGUP
1846 printk(KERN_DEBUG "error %d in opening %s...", retval,
1850 if (retval != -ERESTARTSYS)
1852 if (signal_pending(current))
1856 * Need to reset f_op in case a hangup happened.
1858 if (filp->f_op == &hung_up_tty_fops)
1859 filp->f_op = &tty_fops;
1863 current->signal->leader &&
1864 !current->signal->tty &&
1865 tty->session == 0) {
1867 current->signal->tty = tty;
1868 task_unlock(current);
1869 current->signal->tty_old_pgrp = 0;
1870 tty->session = current->signal->session;
1871 tty->pgrp = process_group(current);
1876 #ifdef CONFIG_UNIX98_PTYS
1877 static int ptmx_open(struct inode * inode, struct file * filp)
1879 struct tty_struct *tty;
1884 nonseekable_open(inode, filp);
1886 /* find a device that is not in use. */
1887 down(&allocated_ptys_lock);
1888 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1889 up(&allocated_ptys_lock);
1892 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1894 up(&allocated_ptys_lock);
1895 if (idr_ret == -EAGAIN)
1899 if (index >= pty_limit) {
1900 idr_remove(&allocated_ptys, index);
1901 up(&allocated_ptys_lock);
1904 up(&allocated_ptys_lock);
1907 retval = init_dev(ptm_driver, index, &tty);
1913 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1914 filp->private_data = tty;
1915 file_move(filp, &tty->tty_files);
1918 if (devpts_pty_new(tty->link))
1921 check_tty_count(tty, "tty_open");
1922 retval = ptm_driver->open(tty, filp);
1928 down(&allocated_ptys_lock);
1929 idr_remove(&allocated_ptys, index);
1930 up(&allocated_ptys_lock);
1935 static int tty_release(struct inode * inode, struct file * filp)
1943 /* No kernel lock held - fine */
1944 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1946 struct tty_struct * tty;
1947 struct tty_ldisc *ld;
1950 tty = (struct tty_struct *)filp->private_data;
1951 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1954 ld = tty_ldisc_ref_wait(tty);
1956 ret = (ld->poll)(tty, filp, wait);
1957 tty_ldisc_deref(ld);
1961 static int tty_fasync(int fd, struct file * filp, int on)
1963 struct tty_struct * tty;
1966 tty = (struct tty_struct *)filp->private_data;
1967 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1970 retval = fasync_helper(fd, filp, on, &tty->fasync);
1975 if (!waitqueue_active(&tty->read_wait))
1976 tty->minimum_to_wake = 1;
1977 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1981 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1982 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1987 static int tiocsti(struct tty_struct *tty, char __user *p)
1990 struct tty_ldisc *ld;
1992 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1994 if (get_user(ch, p))
1996 ld = tty_ldisc_ref_wait(tty);
1997 ld->receive_buf(tty, &ch, &mbz, 1);
1998 tty_ldisc_deref(ld);
2002 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2004 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2009 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2010 struct winsize __user * arg)
2012 struct winsize tmp_ws;
2014 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2016 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2019 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2020 unsigned int currcons = tty->index;
2023 acquire_console_sem();
2024 rc = vc_resize(currcons, tmp_ws.ws_col, tmp_ws.ws_row);
2025 release_console_sem();
2031 kill_pg(tty->pgrp, SIGWINCH, 1);
2032 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2033 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2034 tty->winsize = tmp_ws;
2035 real_tty->winsize = tmp_ws;
2039 static int tioccons(struct file *file)
2041 if (!capable(CAP_SYS_ADMIN))
2043 if (file->f_op->write == redirected_tty_write) {
2045 spin_lock(&redirect_lock);
2048 spin_unlock(&redirect_lock);
2053 spin_lock(&redirect_lock);
2055 spin_unlock(&redirect_lock);
2060 spin_unlock(&redirect_lock);
2065 static int fionbio(struct file *file, int __user *p)
2069 if (get_user(nonblock, p))
2073 file->f_flags |= O_NONBLOCK;
2075 file->f_flags &= ~O_NONBLOCK;
2079 static int tiocsctty(struct tty_struct *tty, int arg)
2083 if (current->signal->leader &&
2084 (current->signal->session == tty->session))
2087 * The process must be a session leader and
2088 * not have a controlling tty already.
2090 if (!current->signal->leader || current->signal->tty)
2092 if (tty->session > 0) {
2094 * This tty is already the controlling
2095 * tty for another session group!
2097 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2102 read_lock(&tasklist_lock);
2103 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2104 p->signal->tty = NULL;
2105 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2106 read_unlock(&tasklist_lock);
2111 current->signal->tty = tty;
2112 task_unlock(current);
2113 current->signal->tty_old_pgrp = 0;
2114 tty->session = current->signal->session;
2115 tty->pgrp = process_group(current);
2119 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2123 * (tty == real_tty) is a cheap way of
2124 * testing if the tty is NOT a master pty.
2126 if (tty == real_tty && current->signal->tty != real_tty)
2129 pgrp = vx_map_pid(real_tty->pgrp);
2130 return put_user(pgrp, p);
2133 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2136 int retval = tty_check_change(real_tty);
2142 if (!current->signal->tty ||
2143 (current->signal->tty != real_tty) ||
2144 (real_tty->session != current->signal->session))
2146 if (get_user(pgrp, p))
2149 pgrp = vx_rmap_pid(pgrp);
2152 if (session_of_pgrp(pgrp) != current->signal->session)
2154 real_tty->pgrp = pgrp;
2158 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2161 * (tty == real_tty) is a cheap way of
2162 * testing if the tty is NOT a master pty.
2164 if (tty == real_tty && current->signal->tty != real_tty)
2166 if (real_tty->session <= 0)
2168 return put_user(real_tty->session, p);
2171 static int tiocsetd(struct tty_struct *tty, int __user *p)
2175 if (get_user(ldisc, p))
2177 return tty_set_ldisc(tty, ldisc);
2180 static int send_break(struct tty_struct *tty, int duration)
2182 tty->driver->break_ctl(tty, -1);
2183 if (!signal_pending(current)) {
2184 set_current_state(TASK_INTERRUPTIBLE);
2185 schedule_timeout(duration);
2187 tty->driver->break_ctl(tty, 0);
2188 if (signal_pending(current))
2194 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2196 int retval = -EINVAL;
2198 if (tty->driver->tiocmget) {
2199 retval = tty->driver->tiocmget(tty, file);
2202 retval = put_user(retval, p);
2208 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2211 int retval = -EINVAL;
2213 if (tty->driver->tiocmset) {
2214 unsigned int set, clear, val;
2216 retval = get_user(val, p);
2234 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2235 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2237 retval = tty->driver->tiocmset(tty, file, set, clear);
2243 * Split this up, as gcc can choke on it otherwise..
2245 int tty_ioctl(struct inode * inode, struct file * file,
2246 unsigned int cmd, unsigned long arg)
2248 struct tty_struct *tty, *real_tty;
2249 void __user *p = (void __user *)arg;
2251 struct tty_ldisc *ld;
2253 tty = (struct tty_struct *)file->private_data;
2254 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2258 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2259 tty->driver->subtype == PTY_TYPE_MASTER)
2260 real_tty = tty->link;
2263 * Break handling by driver
2265 if (!tty->driver->break_ctl) {
2269 if (tty->driver->ioctl)
2270 return tty->driver->ioctl(tty, file, cmd, arg);
2273 /* These two ioctl's always return success; even if */
2274 /* the driver doesn't support them. */
2277 if (!tty->driver->ioctl)
2279 retval = tty->driver->ioctl(tty, file, cmd, arg);
2280 if (retval == -ENOIOCTLCMD)
2287 * Factor out some common prep work
2295 retval = tty_check_change(tty);
2298 if (cmd != TIOCCBRK) {
2299 tty_wait_until_sent(tty, 0);
2300 if (signal_pending(current))
2308 return tiocsti(tty, p);
2310 return tiocgwinsz(tty, p);
2312 return tiocswinsz(tty, real_tty, p);
2314 return real_tty!=tty ? -EINVAL : tioccons(file);
2316 return fionbio(file, p);
2318 set_bit(TTY_EXCLUSIVE, &tty->flags);
2321 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2324 if (current->signal->tty != tty)
2326 if (current->signal->leader)
2327 disassociate_ctty(0);
2329 current->signal->tty = NULL;
2330 task_unlock(current);
2333 return tiocsctty(tty, arg);
2335 return tiocgpgrp(tty, real_tty, p);
2337 return tiocspgrp(tty, real_tty, p);
2339 return tiocgsid(tty, real_tty, p);
2341 /* FIXME: check this is ok */
2342 return put_user(tty->ldisc.num, (int __user *)p);
2344 return tiocsetd(tty, p);
2347 return tioclinux(tty, arg);
2352 case TIOCSBRK: /* Turn break on, unconditionally */
2353 tty->driver->break_ctl(tty, -1);
2356 case TIOCCBRK: /* Turn break off, unconditionally */
2357 tty->driver->break_ctl(tty, 0);
2359 case TCSBRK: /* SVID version: non-zero arg --> no break */
2361 * XXX is the above comment correct, or the
2362 * code below correct? Is this ioctl used at
2366 return send_break(tty, HZ/4);
2368 case TCSBRKP: /* support for POSIX tcsendbreak() */
2369 return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
2372 return tty_tiocmget(tty, file, p);
2377 return tty_tiocmset(tty, file, cmd, p);
2379 if (tty->driver->ioctl) {
2380 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2381 if (retval != -ENOIOCTLCMD)
2384 ld = tty_ldisc_ref_wait(tty);
2387 retval = ld->ioctl(tty, file, cmd, arg);
2388 if (retval == -ENOIOCTLCMD)
2391 tty_ldisc_deref(ld);
2397 * This implements the "Secure Attention Key" --- the idea is to
2398 * prevent trojan horses by killing all processes associated with this
2399 * tty when the user hits the "Secure Attention Key". Required for
2400 * super-paranoid applications --- see the Orange Book for more details.
2402 * This code could be nicer; ideally it should send a HUP, wait a few
2403 * seconds, then send a INT, and then a KILL signal. But you then
2404 * have to coordinate with the init process, since all processes associated
2405 * with the current tty must be dead before the new getty is allowed
2408 * Now, if it would be correct ;-/ The current code has a nasty hole -
2409 * it doesn't catch files in flight. We may send the descriptor to ourselves
2410 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2412 * Nasty bug: do_SAK is being called in interrupt context. This can
2413 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2415 static void __do_SAK(void *arg)
2420 struct tty_struct *tty = arg;
2421 struct task_struct *p;
2425 struct tty_ldisc *disc;
2429 session = tty->session;
2431 /* We don't want an ldisc switch during this */
2432 disc = tty_ldisc_ref(tty);
2433 if (disc && disc->flush_buffer)
2434 disc->flush_buffer(tty);
2435 tty_ldisc_deref(disc);
2437 if (tty->driver->flush_buffer)
2438 tty->driver->flush_buffer(tty);
2440 read_lock(&tasklist_lock);
2441 do_each_task_pid(session, PIDTYPE_SID, p) {
2442 if (p->signal->tty == tty || session > 0) {
2443 printk(KERN_NOTICE "SAK: killed process %d"
2444 " (%s): p->signal->session==tty->session\n",
2446 send_sig(SIGKILL, p, 1);
2451 spin_lock(&p->files->file_lock);
2452 for (i=0; i < p->files->max_fds; i++) {
2453 filp = fcheck_files(p->files, i);
2456 if (filp->f_op->read == tty_read &&
2457 filp->private_data == tty) {
2458 printk(KERN_NOTICE "SAK: killed process %d"
2459 " (%s): fd#%d opened to the tty\n",
2460 p->pid, p->comm, i);
2461 send_sig(SIGKILL, p, 1);
2465 spin_unlock(&p->files->file_lock);
2468 } while_each_task_pid(session, PIDTYPE_SID, p);
2469 read_unlock(&tasklist_lock);
2474 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2475 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2476 * the values which we write to it will be identical to the values which it
2477 * already has. --akpm
2479 void do_SAK(struct tty_struct *tty)
2483 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2484 schedule_work(&tty->SAK_work);
2487 EXPORT_SYMBOL(do_SAK);
2490 * This routine is called out of the software interrupt to flush data
2491 * from the flip buffer to the line discipline.
2494 static void flush_to_ldisc(void *private_)
2496 struct tty_struct *tty = (struct tty_struct *) private_;
2500 unsigned long flags;
2501 struct tty_ldisc *disc;
2503 disc = tty_ldisc_ref(tty);
2504 if (disc == NULL) /* !TTY_LDISC */
2507 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2509 * Do it after the next timer tick:
2511 schedule_delayed_work(&tty->flip.work, 1);
2514 spin_lock_irqsave(&tty->read_lock, flags);
2515 if (tty->flip.buf_num) {
2516 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2517 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2518 tty->flip.buf_num = 0;
2519 tty->flip.char_buf_ptr = tty->flip.char_buf;
2520 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2522 cp = tty->flip.char_buf;
2523 fp = tty->flip.flag_buf;
2524 tty->flip.buf_num = 1;
2525 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2526 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2528 count = tty->flip.count;
2529 tty->flip.count = 0;
2530 spin_unlock_irqrestore(&tty->read_lock, flags);
2532 disc->receive_buf(tty, cp, fp, count);
2534 tty_ldisc_deref(disc);
2538 * Routine which returns the baud rate of the tty
2540 * Note that the baud_table needs to be kept in sync with the
2541 * include/asm/termbits.h file.
2543 static int baud_table[] = {
2544 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2545 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2547 76800, 153600, 307200, 614400, 921600
2549 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2550 2500000, 3000000, 3500000, 4000000
2554 static int n_baud_table = ARRAY_SIZE(baud_table);
2557 * tty_termios_baud_rate
2558 * @termios: termios structure
2560 * Convert termios baud rate data into a speed. This should be called
2561 * with the termios lock held if this termios is a terminal termios
2562 * structure. May change the termios data.
2565 int tty_termios_baud_rate(struct termios *termios)
2569 cbaud = termios->c_cflag & CBAUD;
2571 if (cbaud & CBAUDEX) {
2574 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2575 termios->c_cflag &= ~CBAUDEX;
2579 return baud_table[cbaud];
2582 EXPORT_SYMBOL(tty_termios_baud_rate);
2585 * tty_get_baud_rate - get tty bit rates
2586 * @tty: tty to query
2588 * Returns the baud rate as an integer for this terminal. The
2589 * termios lock must be held by the caller and the terminal bit
2590 * flags may be updated.
2593 int tty_get_baud_rate(struct tty_struct *tty)
2595 int baud = tty_termios_baud_rate(tty->termios);
2597 if (baud == 38400 && tty->alt_speed) {
2599 printk(KERN_WARNING "Use of setserial/setrocket to "
2600 "set SPD_* flags is deprecated\n");
2603 baud = tty->alt_speed;
2609 EXPORT_SYMBOL(tty_get_baud_rate);
2612 * tty_flip_buffer_push - terminal
2615 * Queue a push of the terminal flip buffers to the line discipline. This
2616 * function must not be called from IRQ context if tty->low_latency is set.
2618 * In the event of the queue being busy for flipping the work will be
2619 * held off and retried later.
2622 void tty_flip_buffer_push(struct tty_struct *tty)
2624 if (tty->low_latency)
2625 flush_to_ldisc((void *) tty);
2627 schedule_delayed_work(&tty->flip.work, 1);
2630 EXPORT_SYMBOL(tty_flip_buffer_push);
2633 * This subroutine initializes a tty structure.
2635 static void initialize_tty_struct(struct tty_struct *tty)
2637 memset(tty, 0, sizeof(struct tty_struct));
2638 tty->magic = TTY_MAGIC;
2639 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2641 tty->flip.char_buf_ptr = tty->flip.char_buf;
2642 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2643 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2644 init_MUTEX(&tty->flip.pty_sem);
2645 init_MUTEX(&tty->termios_sem);
2646 init_waitqueue_head(&tty->write_wait);
2647 init_waitqueue_head(&tty->read_wait);
2648 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2649 sema_init(&tty->atomic_read, 1);
2650 sema_init(&tty->atomic_write, 1);
2651 spin_lock_init(&tty->read_lock);
2652 INIT_LIST_HEAD(&tty->tty_files);
2653 INIT_WORK(&tty->SAK_work, NULL, NULL);
2657 * The default put_char routine if the driver did not define one.
2659 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2661 tty->driver->write(tty, &ch, 1);
2664 static struct class_simple *tty_class;
2667 * tty_register_device - register a tty device
2668 * @driver: the tty driver that describes the tty device
2669 * @index: the index in the tty driver for this tty device
2670 * @device: a struct device that is associated with this tty device.
2671 * This field is optional, if there is no known struct device for this
2672 * tty device it can be set to NULL safely.
2674 * This call is required to be made to register an individual tty device if
2675 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2676 * bit is not set, this function should not be called.
2678 void tty_register_device(struct tty_driver *driver, unsigned index,
2679 struct device *device)
2682 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2684 if (index >= driver->num) {
2685 printk(KERN_ERR "Attempt to register invalid tty line number "
2690 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2691 "%s%d", driver->devfs_name, index + driver->name_base);
2693 if (driver->type == TTY_DRIVER_TYPE_PTY)
2694 pty_line_name(driver, index, name);
2696 tty_line_name(driver, index, name);
2697 class_simple_device_add(tty_class, dev, device, name);
2701 * tty_unregister_device - unregister a tty device
2702 * @driver: the tty driver that describes the tty device
2703 * @index: the index in the tty driver for this tty device
2705 * If a tty device is registered with a call to tty_register_device() then
2706 * this function must be made when the tty device is gone.
2708 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2710 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2711 class_simple_device_remove(MKDEV(driver->major, driver->minor_start) + index);
2714 EXPORT_SYMBOL(tty_register_device);
2715 EXPORT_SYMBOL(tty_unregister_device);
2717 struct tty_driver *alloc_tty_driver(int lines)
2719 struct tty_driver *driver;
2721 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2723 memset(driver, 0, sizeof(struct tty_driver));
2724 driver->magic = TTY_DRIVER_MAGIC;
2725 driver->num = lines;
2726 /* later we'll move allocation of tables here */
2731 void put_tty_driver(struct tty_driver *driver)
2736 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2738 driver->open = op->open;
2739 driver->close = op->close;
2740 driver->write = op->write;
2741 driver->put_char = op->put_char;
2742 driver->flush_chars = op->flush_chars;
2743 driver->write_room = op->write_room;
2744 driver->chars_in_buffer = op->chars_in_buffer;
2745 driver->ioctl = op->ioctl;
2746 driver->set_termios = op->set_termios;
2747 driver->throttle = op->throttle;
2748 driver->unthrottle = op->unthrottle;
2749 driver->stop = op->stop;
2750 driver->start = op->start;
2751 driver->hangup = op->hangup;
2752 driver->break_ctl = op->break_ctl;
2753 driver->flush_buffer = op->flush_buffer;
2754 driver->set_ldisc = op->set_ldisc;
2755 driver->wait_until_sent = op->wait_until_sent;
2756 driver->send_xchar = op->send_xchar;
2757 driver->read_proc = op->read_proc;
2758 driver->write_proc = op->write_proc;
2759 driver->tiocmget = op->tiocmget;
2760 driver->tiocmset = op->tiocmset;
2764 EXPORT_SYMBOL(alloc_tty_driver);
2765 EXPORT_SYMBOL(put_tty_driver);
2766 EXPORT_SYMBOL(tty_set_operations);
2769 * Called by a tty driver to register itself.
2771 int tty_register_driver(struct tty_driver *driver)
2778 if (driver->flags & TTY_DRIVER_INSTALLED)
2781 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2782 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2785 memset(p, 0, driver->num * 3 * sizeof(void *));
2788 if (!driver->major) {
2789 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2790 (char*)driver->name);
2792 driver->major = MAJOR(dev);
2793 driver->minor_start = MINOR(dev);
2796 dev = MKDEV(driver->major, driver->minor_start);
2797 error = register_chrdev_region(dev, driver->num,
2798 (char*)driver->name);
2806 driver->ttys = (struct tty_struct **)p;
2807 driver->termios = (struct termios **)(p + driver->num);
2808 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2810 driver->ttys = NULL;
2811 driver->termios = NULL;
2812 driver->termios_locked = NULL;
2815 cdev_init(&driver->cdev, &tty_fops);
2816 driver->cdev.owner = driver->owner;
2817 error = cdev_add(&driver->cdev, dev, driver->num);
2819 cdev_del(&driver->cdev);
2820 unregister_chrdev_region(dev, driver->num);
2821 driver->ttys = NULL;
2822 driver->termios = driver->termios_locked = NULL;
2827 if (!driver->put_char)
2828 driver->put_char = tty_default_put_char;
2830 list_add(&driver->tty_drivers, &tty_drivers);
2832 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2833 for(i = 0; i < driver->num; i++)
2834 tty_register_device(driver, i, NULL);
2836 proc_tty_register_driver(driver);
2840 EXPORT_SYMBOL(tty_register_driver);
2843 * Called by a tty driver to unregister itself.
2845 int tty_unregister_driver(struct tty_driver *driver)
2851 if (driver->refcount)
2854 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2857 list_del(&driver->tty_drivers);
2860 * Free the termios and termios_locked structures because
2861 * we don't want to get memory leaks when modular tty
2862 * drivers are removed from the kernel.
2864 for (i = 0; i < driver->num; i++) {
2865 tp = driver->termios[i];
2867 driver->termios[i] = NULL;
2870 tp = driver->termios_locked[i];
2872 driver->termios_locked[i] = NULL;
2875 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2876 tty_unregister_device(driver, i);
2879 proc_tty_unregister_driver(driver);
2880 driver->ttys = NULL;
2881 driver->termios = driver->termios_locked = NULL;
2883 cdev_del(&driver->cdev);
2887 EXPORT_SYMBOL(tty_unregister_driver);
2891 * Initialize the console device. This is called *early*, so
2892 * we can't necessarily depend on lots of kernel help here.
2893 * Just do some early initializations, and do the complex setup
2896 void __init console_init(void)
2900 /* Setup the default TTY line discipline. */
2901 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2904 * set up the console device so that later boot sequences can
2905 * inform about problems etc..
2907 #ifdef CONFIG_EARLY_PRINTK
2908 disable_early_printk();
2910 #ifdef CONFIG_SERIAL_68360
2911 /* This is not a console initcall. I know not what it's doing here.
2912 So I haven't moved it. dwmw2 */
2915 call = __con_initcall_start;
2916 while (call < __con_initcall_end) {
2923 extern int vty_init(void);
2926 static int __init tty_class_init(void)
2928 tty_class = class_simple_create(THIS_MODULE, "tty");
2929 if (IS_ERR(tty_class))
2930 return PTR_ERR(tty_class);
2934 postcore_initcall(tty_class_init);
2936 /* 3/2004 jmc: why do these devices exist? */
2938 static struct cdev tty_cdev, console_cdev;
2939 #ifdef CONFIG_UNIX98_PTYS
2940 static struct cdev ptmx_cdev;
2943 static struct cdev vc0_cdev;
2947 * Ok, now we can initialize the rest of the tty devices and can count
2948 * on memory allocations, interrupts etc..
2950 static int __init tty_init(void)
2952 cdev_init(&tty_cdev, &tty_fops);
2953 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2954 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2955 panic("Couldn't register /dev/tty driver\n");
2956 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2957 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2959 cdev_init(&console_cdev, &console_fops);
2960 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2961 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2962 panic("Couldn't register /dev/console driver\n");
2963 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2964 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2966 #ifdef CONFIG_UNIX98_PTYS
2967 cdev_init(&ptmx_cdev, &ptmx_fops);
2968 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2969 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2970 panic("Couldn't register /dev/ptmx driver\n");
2971 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2972 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2976 cdev_init(&vc0_cdev, &console_fops);
2977 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2978 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2979 panic("Couldn't register /dev/tty0 driver\n");
2980 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
2981 class_simple_device_add(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
2987 module_init(tty_init);