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 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 struct tty_driver *console_driver;
1794 driver = console_driver;
1800 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1801 driver = console_device(&index);
1803 /* Don't let /dev/console block */
1804 filp->f_flags |= O_NONBLOCK;
1812 driver = get_tty_driver(device, &index);
1818 retval = init_dev(driver, index, &tty);
1823 filp->private_data = tty;
1824 file_move(filp, &tty->tty_files);
1825 check_tty_count(tty, "tty_open");
1826 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1827 tty->driver->subtype == PTY_TYPE_MASTER)
1829 #ifdef TTY_DEBUG_HANGUP
1830 printk(KERN_DEBUG "opening %s...", tty->name);
1833 if (tty->driver->open)
1834 retval = tty->driver->open(tty, filp);
1838 filp->f_flags = saved_flags;
1840 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1844 #ifdef TTY_DEBUG_HANGUP
1845 printk(KERN_DEBUG "error %d in opening %s...", retval,
1849 if (retval != -ERESTARTSYS)
1851 if (signal_pending(current))
1855 * Need to reset f_op in case a hangup happened.
1857 if (filp->f_op == &hung_up_tty_fops)
1858 filp->f_op = &tty_fops;
1862 current->signal->leader &&
1863 !current->signal->tty &&
1864 tty->session == 0) {
1866 current->signal->tty = tty;
1867 task_unlock(current);
1868 current->signal->tty_old_pgrp = 0;
1869 tty->session = current->signal->session;
1870 tty->pgrp = process_group(current);
1875 #ifdef CONFIG_UNIX98_PTYS
1876 static int ptmx_open(struct inode * inode, struct file * filp)
1878 struct tty_struct *tty;
1883 nonseekable_open(inode, filp);
1885 /* find a device that is not in use. */
1886 down(&allocated_ptys_lock);
1887 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1888 up(&allocated_ptys_lock);
1891 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1893 up(&allocated_ptys_lock);
1894 if (idr_ret == -EAGAIN)
1898 if (index >= pty_limit) {
1899 idr_remove(&allocated_ptys, index);
1900 up(&allocated_ptys_lock);
1903 up(&allocated_ptys_lock);
1906 retval = init_dev(ptm_driver, index, &tty);
1912 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1913 filp->private_data = tty;
1914 file_move(filp, &tty->tty_files);
1917 if (devpts_pty_new(tty->link))
1920 check_tty_count(tty, "tty_open");
1921 retval = ptm_driver->open(tty, filp);
1927 down(&allocated_ptys_lock);
1928 idr_remove(&allocated_ptys, index);
1929 up(&allocated_ptys_lock);
1934 static int tty_release(struct inode * inode, struct file * filp)
1942 /* No kernel lock held - fine */
1943 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1945 struct tty_struct * tty;
1946 struct tty_ldisc *ld;
1949 tty = (struct tty_struct *)filp->private_data;
1950 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1953 ld = tty_ldisc_ref_wait(tty);
1955 ret = (ld->poll)(tty, filp, wait);
1956 tty_ldisc_deref(ld);
1960 static int tty_fasync(int fd, struct file * filp, int on)
1962 struct tty_struct * tty;
1965 tty = (struct tty_struct *)filp->private_data;
1966 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1969 retval = fasync_helper(fd, filp, on, &tty->fasync);
1974 if (!waitqueue_active(&tty->read_wait))
1975 tty->minimum_to_wake = 1;
1976 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1980 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1981 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1986 static int tiocsti(struct tty_struct *tty, char __user *p)
1989 struct tty_ldisc *ld;
1991 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1993 if (get_user(ch, p))
1995 ld = tty_ldisc_ref_wait(tty);
1996 ld->receive_buf(tty, &ch, &mbz, 1);
1997 tty_ldisc_deref(ld);
2001 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2003 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2008 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2009 struct winsize __user * arg)
2011 struct winsize tmp_ws;
2013 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2015 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2018 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2021 acquire_console_sem();
2022 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2023 release_console_sem();
2029 kill_pg(tty->pgrp, SIGWINCH, 1);
2030 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2031 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2032 tty->winsize = tmp_ws;
2033 real_tty->winsize = tmp_ws;
2037 static int tioccons(struct file *file)
2039 if (!capable(CAP_SYS_ADMIN))
2041 if (file->f_op->write == redirected_tty_write) {
2043 spin_lock(&redirect_lock);
2046 spin_unlock(&redirect_lock);
2051 spin_lock(&redirect_lock);
2053 spin_unlock(&redirect_lock);
2058 spin_unlock(&redirect_lock);
2063 static int fionbio(struct file *file, int __user *p)
2067 if (get_user(nonblock, p))
2071 file->f_flags |= O_NONBLOCK;
2073 file->f_flags &= ~O_NONBLOCK;
2077 static int tiocsctty(struct tty_struct *tty, int arg)
2081 if (current->signal->leader &&
2082 (current->signal->session == tty->session))
2085 * The process must be a session leader and
2086 * not have a controlling tty already.
2088 if (!current->signal->leader || current->signal->tty)
2090 if (tty->session > 0) {
2092 * This tty is already the controlling
2093 * tty for another session group!
2095 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2100 read_lock(&tasklist_lock);
2101 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2102 p->signal->tty = NULL;
2103 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2104 read_unlock(&tasklist_lock);
2109 current->signal->tty = tty;
2110 task_unlock(current);
2111 current->signal->tty_old_pgrp = 0;
2112 tty->session = current->signal->session;
2113 tty->pgrp = process_group(current);
2117 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2121 * (tty == real_tty) is a cheap way of
2122 * testing if the tty is NOT a master pty.
2124 if (tty == real_tty && current->signal->tty != real_tty)
2127 pgrp = vx_map_pid(real_tty->pgrp);
2128 return put_user(pgrp, p);
2131 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2134 int retval = tty_check_change(real_tty);
2140 if (!current->signal->tty ||
2141 (current->signal->tty != real_tty) ||
2142 (real_tty->session != current->signal->session))
2144 if (get_user(pgrp, p))
2147 pgrp = vx_rmap_pid(pgrp);
2150 if (session_of_pgrp(pgrp) != current->signal->session)
2152 real_tty->pgrp = pgrp;
2156 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2159 * (tty == real_tty) is a cheap way of
2160 * testing if the tty is NOT a master pty.
2162 if (tty == real_tty && current->signal->tty != real_tty)
2164 if (real_tty->session <= 0)
2166 return put_user(real_tty->session, p);
2169 static int tiocsetd(struct tty_struct *tty, int __user *p)
2173 if (get_user(ldisc, p))
2175 return tty_set_ldisc(tty, ldisc);
2178 static int send_break(struct tty_struct *tty, int duration)
2180 tty->driver->break_ctl(tty, -1);
2181 if (!signal_pending(current)) {
2182 set_current_state(TASK_INTERRUPTIBLE);
2183 schedule_timeout(duration);
2185 tty->driver->break_ctl(tty, 0);
2186 if (signal_pending(current))
2192 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2194 int retval = -EINVAL;
2196 if (tty->driver->tiocmget) {
2197 retval = tty->driver->tiocmget(tty, file);
2200 retval = put_user(retval, p);
2206 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2209 int retval = -EINVAL;
2211 if (tty->driver->tiocmset) {
2212 unsigned int set, clear, val;
2214 retval = get_user(val, p);
2232 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2233 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2235 retval = tty->driver->tiocmset(tty, file, set, clear);
2241 * Split this up, as gcc can choke on it otherwise..
2243 int tty_ioctl(struct inode * inode, struct file * file,
2244 unsigned int cmd, unsigned long arg)
2246 struct tty_struct *tty, *real_tty;
2247 void __user *p = (void __user *)arg;
2249 struct tty_ldisc *ld;
2251 tty = (struct tty_struct *)file->private_data;
2252 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2256 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2257 tty->driver->subtype == PTY_TYPE_MASTER)
2258 real_tty = tty->link;
2261 * Break handling by driver
2263 if (!tty->driver->break_ctl) {
2267 if (tty->driver->ioctl)
2268 return tty->driver->ioctl(tty, file, cmd, arg);
2271 /* These two ioctl's always return success; even if */
2272 /* the driver doesn't support them. */
2275 if (!tty->driver->ioctl)
2277 retval = tty->driver->ioctl(tty, file, cmd, arg);
2278 if (retval == -ENOIOCTLCMD)
2285 * Factor out some common prep work
2293 retval = tty_check_change(tty);
2296 if (cmd != TIOCCBRK) {
2297 tty_wait_until_sent(tty, 0);
2298 if (signal_pending(current))
2306 return tiocsti(tty, p);
2308 return tiocgwinsz(tty, p);
2310 return tiocswinsz(tty, real_tty, p);
2312 return real_tty!=tty ? -EINVAL : tioccons(file);
2314 return fionbio(file, p);
2316 set_bit(TTY_EXCLUSIVE, &tty->flags);
2319 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2322 if (current->signal->tty != tty)
2324 if (current->signal->leader)
2325 disassociate_ctty(0);
2327 current->signal->tty = NULL;
2328 task_unlock(current);
2331 return tiocsctty(tty, arg);
2333 return tiocgpgrp(tty, real_tty, p);
2335 return tiocspgrp(tty, real_tty, p);
2337 return tiocgsid(tty, real_tty, p);
2339 /* FIXME: check this is ok */
2340 return put_user(tty->ldisc.num, (int __user *)p);
2342 return tiocsetd(tty, p);
2345 return tioclinux(tty, arg);
2350 case TIOCSBRK: /* Turn break on, unconditionally */
2351 tty->driver->break_ctl(tty, -1);
2354 case TIOCCBRK: /* Turn break off, unconditionally */
2355 tty->driver->break_ctl(tty, 0);
2357 case TCSBRK: /* SVID version: non-zero arg --> no break */
2359 * XXX is the above comment correct, or the
2360 * code below correct? Is this ioctl used at
2364 return send_break(tty, HZ/4);
2366 case TCSBRKP: /* support for POSIX tcsendbreak() */
2367 return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
2370 return tty_tiocmget(tty, file, p);
2375 return tty_tiocmset(tty, file, cmd, p);
2377 if (tty->driver->ioctl) {
2378 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2379 if (retval != -ENOIOCTLCMD)
2382 ld = tty_ldisc_ref_wait(tty);
2385 retval = ld->ioctl(tty, file, cmd, arg);
2386 if (retval == -ENOIOCTLCMD)
2389 tty_ldisc_deref(ld);
2395 * This implements the "Secure Attention Key" --- the idea is to
2396 * prevent trojan horses by killing all processes associated with this
2397 * tty when the user hits the "Secure Attention Key". Required for
2398 * super-paranoid applications --- see the Orange Book for more details.
2400 * This code could be nicer; ideally it should send a HUP, wait a few
2401 * seconds, then send a INT, and then a KILL signal. But you then
2402 * have to coordinate with the init process, since all processes associated
2403 * with the current tty must be dead before the new getty is allowed
2406 * Now, if it would be correct ;-/ The current code has a nasty hole -
2407 * it doesn't catch files in flight. We may send the descriptor to ourselves
2408 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2410 * Nasty bug: do_SAK is being called in interrupt context. This can
2411 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2413 static void __do_SAK(void *arg)
2418 struct tty_struct *tty = arg;
2419 struct task_struct *p;
2423 struct tty_ldisc *disc;
2427 session = tty->session;
2429 /* We don't want an ldisc switch during this */
2430 disc = tty_ldisc_ref(tty);
2431 if (disc && disc->flush_buffer)
2432 disc->flush_buffer(tty);
2433 tty_ldisc_deref(disc);
2435 if (tty->driver->flush_buffer)
2436 tty->driver->flush_buffer(tty);
2438 read_lock(&tasklist_lock);
2439 do_each_task_pid(session, PIDTYPE_SID, p) {
2440 if (p->signal->tty == tty || session > 0) {
2441 printk(KERN_NOTICE "SAK: killed process %d"
2442 " (%s): p->signal->session==tty->session\n",
2444 send_sig(SIGKILL, p, 1);
2449 spin_lock(&p->files->file_lock);
2450 for (i=0; i < p->files->max_fds; i++) {
2451 filp = fcheck_files(p->files, i);
2454 if (filp->f_op->read == tty_read &&
2455 filp->private_data == tty) {
2456 printk(KERN_NOTICE "SAK: killed process %d"
2457 " (%s): fd#%d opened to the tty\n",
2458 p->pid, p->comm, i);
2459 send_sig(SIGKILL, p, 1);
2463 spin_unlock(&p->files->file_lock);
2466 } while_each_task_pid(session, PIDTYPE_SID, p);
2467 read_unlock(&tasklist_lock);
2472 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2473 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2474 * the values which we write to it will be identical to the values which it
2475 * already has. --akpm
2477 void do_SAK(struct tty_struct *tty)
2481 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2482 schedule_work(&tty->SAK_work);
2485 EXPORT_SYMBOL(do_SAK);
2488 * This routine is called out of the software interrupt to flush data
2489 * from the flip buffer to the line discipline.
2492 static void flush_to_ldisc(void *private_)
2494 struct tty_struct *tty = (struct tty_struct *) private_;
2498 unsigned long flags;
2499 struct tty_ldisc *disc;
2501 disc = tty_ldisc_ref(tty);
2502 if (disc == NULL) /* !TTY_LDISC */
2505 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2507 * Do it after the next timer tick:
2509 schedule_delayed_work(&tty->flip.work, 1);
2512 spin_lock_irqsave(&tty->read_lock, flags);
2513 if (tty->flip.buf_num) {
2514 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2515 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2516 tty->flip.buf_num = 0;
2517 tty->flip.char_buf_ptr = tty->flip.char_buf;
2518 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2520 cp = tty->flip.char_buf;
2521 fp = tty->flip.flag_buf;
2522 tty->flip.buf_num = 1;
2523 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2524 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2526 count = tty->flip.count;
2527 tty->flip.count = 0;
2528 spin_unlock_irqrestore(&tty->read_lock, flags);
2530 disc->receive_buf(tty, cp, fp, count);
2532 tty_ldisc_deref(disc);
2536 * Routine which returns the baud rate of the tty
2538 * Note that the baud_table needs to be kept in sync with the
2539 * include/asm/termbits.h file.
2541 static int baud_table[] = {
2542 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2543 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2545 76800, 153600, 307200, 614400, 921600
2547 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2548 2500000, 3000000, 3500000, 4000000
2552 static int n_baud_table = ARRAY_SIZE(baud_table);
2555 * tty_termios_baud_rate
2556 * @termios: termios structure
2558 * Convert termios baud rate data into a speed. This should be called
2559 * with the termios lock held if this termios is a terminal termios
2560 * structure. May change the termios data.
2563 int tty_termios_baud_rate(struct termios *termios)
2567 cbaud = termios->c_cflag & CBAUD;
2569 if (cbaud & CBAUDEX) {
2572 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2573 termios->c_cflag &= ~CBAUDEX;
2577 return baud_table[cbaud];
2580 EXPORT_SYMBOL(tty_termios_baud_rate);
2583 * tty_get_baud_rate - get tty bit rates
2584 * @tty: tty to query
2586 * Returns the baud rate as an integer for this terminal. The
2587 * termios lock must be held by the caller and the terminal bit
2588 * flags may be updated.
2591 int tty_get_baud_rate(struct tty_struct *tty)
2593 int baud = tty_termios_baud_rate(tty->termios);
2595 if (baud == 38400 && tty->alt_speed) {
2597 printk(KERN_WARNING "Use of setserial/setrocket to "
2598 "set SPD_* flags is deprecated\n");
2601 baud = tty->alt_speed;
2607 EXPORT_SYMBOL(tty_get_baud_rate);
2610 * tty_flip_buffer_push - terminal
2613 * Queue a push of the terminal flip buffers to the line discipline. This
2614 * function must not be called from IRQ context if tty->low_latency is set.
2616 * In the event of the queue being busy for flipping the work will be
2617 * held off and retried later.
2620 void tty_flip_buffer_push(struct tty_struct *tty)
2622 if (tty->low_latency)
2623 flush_to_ldisc((void *) tty);
2625 schedule_delayed_work(&tty->flip.work, 1);
2628 EXPORT_SYMBOL(tty_flip_buffer_push);
2631 * This subroutine initializes a tty structure.
2633 static void initialize_tty_struct(struct tty_struct *tty)
2635 memset(tty, 0, sizeof(struct tty_struct));
2636 tty->magic = TTY_MAGIC;
2637 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2639 tty->overrun_time = jiffies;
2640 tty->flip.char_buf_ptr = tty->flip.char_buf;
2641 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2642 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2643 init_MUTEX(&tty->flip.pty_sem);
2644 init_MUTEX(&tty->termios_sem);
2645 init_waitqueue_head(&tty->write_wait);
2646 init_waitqueue_head(&tty->read_wait);
2647 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2648 sema_init(&tty->atomic_read, 1);
2649 sema_init(&tty->atomic_write, 1);
2650 spin_lock_init(&tty->read_lock);
2651 INIT_LIST_HEAD(&tty->tty_files);
2652 INIT_WORK(&tty->SAK_work, NULL, NULL);
2656 * The default put_char routine if the driver did not define one.
2658 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2660 tty->driver->write(tty, &ch, 1);
2663 static struct class_simple *tty_class;
2666 * tty_register_device - register a tty device
2667 * @driver: the tty driver that describes the tty device
2668 * @index: the index in the tty driver for this tty device
2669 * @device: a struct device that is associated with this tty device.
2670 * This field is optional, if there is no known struct device for this
2671 * tty device it can be set to NULL safely.
2673 * This call is required to be made to register an individual tty device if
2674 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2675 * bit is not set, this function should not be called.
2677 void tty_register_device(struct tty_driver *driver, unsigned index,
2678 struct device *device)
2681 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2683 if (index >= driver->num) {
2684 printk(KERN_ERR "Attempt to register invalid tty line number "
2689 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2690 "%s%d", driver->devfs_name, index + driver->name_base);
2692 if (driver->type == TTY_DRIVER_TYPE_PTY)
2693 pty_line_name(driver, index, name);
2695 tty_line_name(driver, index, name);
2696 class_simple_device_add(tty_class, dev, device, name);
2700 * tty_unregister_device - unregister a tty device
2701 * @driver: the tty driver that describes the tty device
2702 * @index: the index in the tty driver for this tty device
2704 * If a tty device is registered with a call to tty_register_device() then
2705 * this function must be made when the tty device is gone.
2707 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2709 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2710 class_simple_device_remove(MKDEV(driver->major, driver->minor_start) + index);
2713 EXPORT_SYMBOL(tty_register_device);
2714 EXPORT_SYMBOL(tty_unregister_device);
2716 struct tty_driver *alloc_tty_driver(int lines)
2718 struct tty_driver *driver;
2720 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2722 memset(driver, 0, sizeof(struct tty_driver));
2723 driver->magic = TTY_DRIVER_MAGIC;
2724 driver->num = lines;
2725 /* later we'll move allocation of tables here */
2730 void put_tty_driver(struct tty_driver *driver)
2735 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2737 driver->open = op->open;
2738 driver->close = op->close;
2739 driver->write = op->write;
2740 driver->put_char = op->put_char;
2741 driver->flush_chars = op->flush_chars;
2742 driver->write_room = op->write_room;
2743 driver->chars_in_buffer = op->chars_in_buffer;
2744 driver->ioctl = op->ioctl;
2745 driver->set_termios = op->set_termios;
2746 driver->throttle = op->throttle;
2747 driver->unthrottle = op->unthrottle;
2748 driver->stop = op->stop;
2749 driver->start = op->start;
2750 driver->hangup = op->hangup;
2751 driver->break_ctl = op->break_ctl;
2752 driver->flush_buffer = op->flush_buffer;
2753 driver->set_ldisc = op->set_ldisc;
2754 driver->wait_until_sent = op->wait_until_sent;
2755 driver->send_xchar = op->send_xchar;
2756 driver->read_proc = op->read_proc;
2757 driver->write_proc = op->write_proc;
2758 driver->tiocmget = op->tiocmget;
2759 driver->tiocmset = op->tiocmset;
2763 EXPORT_SYMBOL(alloc_tty_driver);
2764 EXPORT_SYMBOL(put_tty_driver);
2765 EXPORT_SYMBOL(tty_set_operations);
2768 * Called by a tty driver to register itself.
2770 int tty_register_driver(struct tty_driver *driver)
2777 if (driver->flags & TTY_DRIVER_INSTALLED)
2780 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2781 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2784 memset(p, 0, driver->num * 3 * sizeof(void *));
2787 if (!driver->major) {
2788 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2789 (char*)driver->name);
2791 driver->major = MAJOR(dev);
2792 driver->minor_start = MINOR(dev);
2795 dev = MKDEV(driver->major, driver->minor_start);
2796 error = register_chrdev_region(dev, driver->num,
2797 (char*)driver->name);
2805 driver->ttys = (struct tty_struct **)p;
2806 driver->termios = (struct termios **)(p + driver->num);
2807 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2809 driver->ttys = NULL;
2810 driver->termios = NULL;
2811 driver->termios_locked = NULL;
2814 cdev_init(&driver->cdev, &tty_fops);
2815 driver->cdev.owner = driver->owner;
2816 error = cdev_add(&driver->cdev, dev, driver->num);
2818 cdev_del(&driver->cdev);
2819 unregister_chrdev_region(dev, driver->num);
2820 driver->ttys = NULL;
2821 driver->termios = driver->termios_locked = NULL;
2826 if (!driver->put_char)
2827 driver->put_char = tty_default_put_char;
2829 list_add(&driver->tty_drivers, &tty_drivers);
2831 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2832 for(i = 0; i < driver->num; i++)
2833 tty_register_device(driver, i, NULL);
2835 proc_tty_register_driver(driver);
2839 EXPORT_SYMBOL(tty_register_driver);
2842 * Called by a tty driver to unregister itself.
2844 int tty_unregister_driver(struct tty_driver *driver)
2850 if (driver->refcount)
2853 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2856 list_del(&driver->tty_drivers);
2859 * Free the termios and termios_locked structures because
2860 * we don't want to get memory leaks when modular tty
2861 * drivers are removed from the kernel.
2863 for (i = 0; i < driver->num; i++) {
2864 tp = driver->termios[i];
2866 driver->termios[i] = NULL;
2869 tp = driver->termios_locked[i];
2871 driver->termios_locked[i] = NULL;
2874 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2875 tty_unregister_device(driver, i);
2878 proc_tty_unregister_driver(driver);
2879 driver->ttys = NULL;
2880 driver->termios = driver->termios_locked = NULL;
2882 cdev_del(&driver->cdev);
2886 EXPORT_SYMBOL(tty_unregister_driver);
2890 * Initialize the console device. This is called *early*, so
2891 * we can't necessarily depend on lots of kernel help here.
2892 * Just do some early initializations, and do the complex setup
2895 void __init console_init(void)
2899 /* Setup the default TTY line discipline. */
2900 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2903 * set up the console device so that later boot sequences can
2904 * inform about problems etc..
2906 #ifdef CONFIG_EARLY_PRINTK
2907 disable_early_printk();
2909 #ifdef CONFIG_SERIAL_68360
2910 /* This is not a console initcall. I know not what it's doing here.
2911 So I haven't moved it. dwmw2 */
2914 call = __con_initcall_start;
2915 while (call < __con_initcall_end) {
2922 extern int vty_init(void);
2925 static int __init tty_class_init(void)
2927 tty_class = class_simple_create(THIS_MODULE, "tty");
2928 if (IS_ERR(tty_class))
2929 return PTR_ERR(tty_class);
2933 postcore_initcall(tty_class_init);
2935 /* 3/2004 jmc: why do these devices exist? */
2937 static struct cdev tty_cdev, console_cdev;
2938 #ifdef CONFIG_UNIX98_PTYS
2939 static struct cdev ptmx_cdev;
2942 static struct cdev vc0_cdev;
2946 * Ok, now we can initialize the rest of the tty devices and can count
2947 * on memory allocations, interrupts etc..
2949 static int __init tty_init(void)
2951 cdev_init(&tty_cdev, &tty_fops);
2952 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2953 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2954 panic("Couldn't register /dev/tty driver\n");
2955 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2956 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2958 cdev_init(&console_cdev, &console_fops);
2959 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2960 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2961 panic("Couldn't register /dev/console driver\n");
2962 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2963 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2965 #ifdef CONFIG_UNIX98_PTYS
2966 cdev_init(&ptmx_cdev, &ptmx_fops);
2967 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2968 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2969 panic("Couldn't register /dev/ptmx driver\n");
2970 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2971 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2975 cdev_init(&vc0_cdev, &console_fops);
2976 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2977 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2978 panic("Couldn't register /dev/tty0 driver\n");
2979 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
2980 class_simple_device_add(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
2986 module_init(tty_init);