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 spinlock_t tty_ldisc_lock = SPIN_LOCK_UNLOCKED;
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 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 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 spinlock_t redirect_lock = SPIN_LOCK_UNLOCKED;
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 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_TIME;
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
1053 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1058 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1059 if (tty->write_cnt < chunk) {
1065 buf = kmalloc(chunk, GFP_KERNEL);
1067 up(&tty->atomic_write);
1070 kfree(tty->write_buf);
1071 tty->write_cnt = chunk;
1072 tty->write_buf = buf;
1075 /* Do the write .. */
1077 size_t size = count;
1081 if (copy_from_user(tty->write_buf, buf, size))
1084 ret = write(tty, file, tty->write_buf, size);
1094 if (signal_pending(current))
1099 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
1102 up(&tty->atomic_write);
1107 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1110 struct tty_struct * tty;
1111 struct inode *inode = file->f_dentry->d_inode;
1113 struct tty_ldisc *ld;
1115 tty = (struct tty_struct *)file->private_data;
1116 if (tty_paranoia_check(tty, inode, "tty_write"))
1118 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1121 ld = tty_ldisc_ref_wait(tty);
1125 ret = do_tty_write(ld->write, tty, file, buf, count);
1126 tty_ldisc_deref(ld);
1130 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1133 struct file *p = NULL;
1135 spin_lock(&redirect_lock);
1140 spin_unlock(&redirect_lock);
1144 res = vfs_write(p, buf, count, &p->f_pos);
1149 return tty_write(file, buf, count, ppos);
1152 static char ptychar[] = "pqrstuvwxyzabcde";
1154 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1156 int i = index + driver->name_base;
1157 /* ->name is initialized to "ttyp", but "tty" is expected */
1158 sprintf(p, "%s%c%x",
1159 driver->subtype == PTY_TYPE_SLAVE ? "pty" : driver->name,
1160 ptychar[i >> 4 & 0xf], i & 0xf);
1163 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1165 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1169 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1170 * failed open. The new code protects the open with a semaphore, so it's
1171 * really quite straightforward. The semaphore locking can probably be
1172 * relaxed for the (most common) case of reopening a tty.
1174 static int init_dev(struct tty_driver *driver, int idx,
1175 struct tty_struct **ret_tty)
1177 struct tty_struct *tty, *o_tty;
1178 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1179 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1182 /* check whether we're reopening an existing tty */
1183 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1184 tty = devpts_get_tty(idx);
1185 if (tty && driver->subtype == PTY_TYPE_MASTER)
1188 tty = driver->ttys[idx];
1190 if (tty) goto fast_track;
1193 * First time open is complex, especially for PTY devices.
1194 * This code guarantees that either everything succeeds and the
1195 * TTY is ready for operation, or else the table slots are vacated
1196 * and the allocated memory released. (Except that the termios
1197 * and locked termios may be retained.)
1200 if (!try_module_get(driver->owner)) {
1209 tty = alloc_tty_struct();
1212 initialize_tty_struct(tty);
1213 tty->driver = driver;
1215 tty_line_name(driver, idx, tty->name);
1217 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1218 tp_loc = &tty->termios;
1219 ltp_loc = &tty->termios_locked;
1221 tp_loc = &driver->termios[idx];
1222 ltp_loc = &driver->termios_locked[idx];
1226 tp = (struct termios *) kmalloc(sizeof(struct termios),
1230 *tp = driver->init_termios;
1234 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1238 memset(ltp, 0, sizeof(struct termios));
1241 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1242 o_tty = alloc_tty_struct();
1245 initialize_tty_struct(o_tty);
1246 o_tty->driver = driver->other;
1248 tty_line_name(driver->other, idx, o_tty->name);
1250 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1251 o_tp_loc = &o_tty->termios;
1252 o_ltp_loc = &o_tty->termios_locked;
1254 o_tp_loc = &driver->other->termios[idx];
1255 o_ltp_loc = &driver->other->termios_locked[idx];
1259 o_tp = (struct termios *)
1260 kmalloc(sizeof(struct termios), GFP_KERNEL);
1263 *o_tp = driver->other->init_termios;
1267 o_ltp = (struct termios *)
1268 kmalloc(sizeof(struct termios), GFP_KERNEL);
1271 memset(o_ltp, 0, sizeof(struct termios));
1275 * Everything allocated ... set up the o_tty structure.
1277 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1278 driver->other->ttys[idx] = o_tty;
1284 o_tty->termios = *o_tp_loc;
1285 o_tty->termios_locked = *o_ltp_loc;
1286 driver->other->refcount++;
1287 if (driver->subtype == PTY_TYPE_MASTER)
1290 /* Establish the links in both directions */
1296 * All structures have been allocated, so now we install them.
1297 * Failures after this point use release_mem to clean up, so
1298 * there's no need to null out the local pointers.
1300 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1301 driver->ttys[idx] = tty;
1308 tty->termios = *tp_loc;
1309 tty->termios_locked = *ltp_loc;
1314 * Structures all installed ... call the ldisc open routines.
1315 * If we fail here just call release_mem to clean up. No need
1316 * to decrement the use counts, as release_mem doesn't care.
1319 if (tty->ldisc.open) {
1320 retval = (tty->ldisc.open)(tty);
1322 goto release_mem_out;
1324 if (o_tty && o_tty->ldisc.open) {
1325 retval = (o_tty->ldisc.open)(o_tty);
1327 if (tty->ldisc.close)
1328 (tty->ldisc.close)(tty);
1329 goto release_mem_out;
1331 tty_ldisc_enable(o_tty);
1333 tty_ldisc_enable(tty);
1337 * This fast open can be used if the tty is already open.
1338 * No memory is allocated, and the only failures are from
1339 * attempting to open a closing tty or attempting multiple
1340 * opens on a pty master.
1343 if (test_bit(TTY_CLOSING, &tty->flags)) {
1347 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1348 driver->subtype == PTY_TYPE_MASTER) {
1350 * special case for PTY masters: only one open permitted,
1351 * and the slave side open count is incremented as well.
1360 tty->driver = driver; /* N.B. why do this every time?? */
1363 if(!test_bit(TTY_LDISC, &tty->flags))
1364 printk(KERN_ERR "init_dev but no ldisc\n");
1368 /* All paths come through here to release the semaphore */
1372 /* Release locally allocated memory ... nothing placed in slots */
1377 free_tty_struct(o_tty);
1382 free_tty_struct(tty);
1385 module_put(driver->owner);
1389 /* call the tty release_mem routine to clean out this slot */
1391 printk(KERN_INFO "init_dev: ldisc open failed, "
1392 "clearing slot %d\n", idx);
1393 release_mem(tty, idx);
1398 * Releases memory associated with a tty structure, and clears out the
1399 * driver table slots.
1401 static void release_mem(struct tty_struct *tty, int idx)
1403 struct tty_struct *o_tty;
1405 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1407 if ((o_tty = tty->link) != NULL) {
1409 o_tty->driver->ttys[idx] = NULL;
1410 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1411 tp = o_tty->termios;
1413 o_tty->driver->termios[idx] = NULL;
1416 tp = o_tty->termios_locked;
1418 o_tty->driver->termios_locked[idx] = NULL;
1422 o_tty->driver->refcount--;
1424 list_del_init(&o_tty->tty_files);
1426 free_tty_struct(o_tty);
1430 tty->driver->ttys[idx] = NULL;
1431 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1434 tty->driver->termios[idx] = NULL;
1437 tp = tty->termios_locked;
1439 tty->driver->termios_locked[idx] = NULL;
1444 tty->driver->refcount--;
1446 list_del_init(&tty->tty_files);
1448 module_put(tty->driver->owner);
1449 free_tty_struct(tty);
1453 * Even releasing the tty structures is a tricky business.. We have
1454 * to be very careful that the structures are all released at the
1455 * same time, as interrupts might otherwise get the wrong pointers.
1457 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1458 * lead to double frees or releasing memory still in use.
1460 static void release_dev(struct file * filp)
1462 struct tty_struct *tty, *o_tty;
1463 int pty_master, tty_closing, o_tty_closing, do_sleep;
1464 int devpts_master, devpts;
1467 unsigned long flags;
1469 tty = (struct tty_struct *)filp->private_data;
1470 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1473 check_tty_count(tty, "release_dev");
1475 tty_fasync(-1, filp, 0);
1478 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1479 tty->driver->subtype == PTY_TYPE_MASTER);
1480 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1481 devpts_master = pty_master && devpts;
1484 #ifdef TTY_PARANOIA_CHECK
1485 if (idx < 0 || idx >= tty->driver->num) {
1486 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1487 "free (%s)\n", tty->name);
1490 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1491 if (tty != tty->driver->ttys[idx]) {
1492 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1493 "for (%s)\n", idx, tty->name);
1496 if (tty->termios != tty->driver->termios[idx]) {
1497 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1502 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1503 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1504 "termios_locked for (%s)\n",
1511 #ifdef TTY_DEBUG_HANGUP
1512 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1513 tty_name(tty, buf), tty->count);
1516 #ifdef TTY_PARANOIA_CHECK
1517 if (tty->driver->other &&
1518 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1519 if (o_tty != tty->driver->other->ttys[idx]) {
1520 printk(KERN_DEBUG "release_dev: other->table[%d] "
1521 "not o_tty for (%s)\n",
1525 if (o_tty->termios != tty->driver->other->termios[idx]) {
1526 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1527 "not o_termios for (%s)\n",
1531 if (o_tty->termios_locked !=
1532 tty->driver->other->termios_locked[idx]) {
1533 printk(KERN_DEBUG "release_dev: other->termios_locked["
1534 "%d] not o_termios_locked for (%s)\n",
1538 if (o_tty->link != tty) {
1539 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1544 if (tty->driver->close)
1545 tty->driver->close(tty, filp);
1548 * Sanity check: if tty->count is going to zero, there shouldn't be
1549 * any waiters on tty->read_wait or tty->write_wait. We test the
1550 * wait queues and kick everyone out _before_ actually starting to
1551 * close. This ensures that we won't block while releasing the tty
1554 * The test for the o_tty closing is necessary, since the master and
1555 * slave sides may close in any order. If the slave side closes out
1556 * first, its count will be one, since the master side holds an open.
1557 * Thus this test wouldn't be triggered at the time the slave closes,
1560 * Note that it's possible for the tty to be opened again while we're
1561 * flushing out waiters. By recalculating the closing flags before
1562 * each iteration we avoid any problems.
1565 /* Guard against races with tty->count changes elsewhere and
1566 opens on /dev/tty */
1569 tty_closing = tty->count <= 1;
1570 o_tty_closing = o_tty &&
1571 (o_tty->count <= (pty_master ? 1 : 0));
1576 if (waitqueue_active(&tty->read_wait)) {
1577 wake_up(&tty->read_wait);
1580 if (waitqueue_active(&tty->write_wait)) {
1581 wake_up(&tty->write_wait);
1585 if (o_tty_closing) {
1586 if (waitqueue_active(&o_tty->read_wait)) {
1587 wake_up(&o_tty->read_wait);
1590 if (waitqueue_active(&o_tty->write_wait)) {
1591 wake_up(&o_tty->write_wait);
1598 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1599 "active!\n", tty_name(tty, buf));
1604 * The closing flags are now consistent with the open counts on
1605 * both sides, and we've completed the last operation that could
1606 * block, so it's safe to proceed with closing.
1611 if (--o_tty->count < 0) {
1612 printk(KERN_WARNING "release_dev: bad pty slave count "
1614 o_tty->count, tty_name(o_tty, buf));
1618 if (--tty->count < 0) {
1619 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1620 tty->count, tty_name(tty, buf));
1626 * We've decremented tty->count, so we need to remove this file
1627 * descriptor off the tty->tty_files list; this serves two
1629 * - check_tty_count sees the correct number of file descriptors
1630 * associated with this tty.
1631 * - do_tty_hangup no longer sees this file descriptor as
1632 * something that needs to be handled for hangups.
1635 filp->private_data = NULL;
1638 * Perform some housekeeping before deciding whether to return.
1640 * Set the TTY_CLOSING flag if this was the last open. In the
1641 * case of a pty we may have to wait around for the other side
1642 * to close, and TTY_CLOSING makes sure we can't be reopened.
1645 set_bit(TTY_CLOSING, &tty->flags);
1647 set_bit(TTY_CLOSING, &o_tty->flags);
1650 * If _either_ side is closing, make sure there aren't any
1651 * processes that still think tty or o_tty is their controlling
1654 if (tty_closing || o_tty_closing) {
1655 struct task_struct *p;
1657 read_lock(&tasklist_lock);
1658 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1659 p->signal->tty = NULL;
1660 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1662 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1663 p->signal->tty = NULL;
1664 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1665 read_unlock(&tasklist_lock);
1668 /* check whether both sides are closing ... */
1669 if (!tty_closing || (o_tty && !o_tty_closing))
1672 #ifdef TTY_DEBUG_HANGUP
1673 printk(KERN_DEBUG "freeing tty structure...");
1676 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1677 * kill any delayed work. As this is the final close it does not
1678 * race with the set_ldisc code path.
1680 clear_bit(TTY_LDISC, &tty->flags);
1681 clear_bit(TTY_DONT_FLIP, &tty->flags);
1682 cancel_delayed_work(&tty->flip.work);
1685 * Wait for ->hangup_work and ->flip.work handlers to terminate
1688 flush_scheduled_work();
1691 * Wait for any short term users (we know they are just driver
1692 * side waiters as the file is closing so user count on the file
1695 spin_lock_irqsave(&tty_ldisc_lock, flags);
1696 while(tty->ldisc.refcount)
1698 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1699 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1700 spin_lock_irqsave(&tty_ldisc_lock, flags);
1702 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1704 * Shutdown the current line discipline, and reset it to N_TTY.
1705 * N.B. why reset ldisc when we're releasing the memory??
1707 * FIXME: this MUST get fixed for the new reflocking
1709 if (tty->ldisc.close)
1710 (tty->ldisc.close)(tty);
1711 tty_ldisc_put(tty->ldisc.num);
1714 * Switch the line discipline back
1716 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1717 tty_set_termios_ldisc(tty,N_TTY);
1719 /* FIXME: could o_tty be in setldisc here ? */
1720 clear_bit(TTY_LDISC, &o_tty->flags);
1721 if (o_tty->ldisc.close)
1722 (o_tty->ldisc.close)(o_tty);
1723 tty_ldisc_put(o_tty->ldisc.num);
1724 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1725 tty_set_termios_ldisc(o_tty,N_TTY);
1728 * The release_mem function takes care of the details of clearing
1729 * the slots and preserving the termios structure.
1731 release_mem(tty, idx);
1733 #ifdef CONFIG_UNIX98_PTYS
1734 /* Make this pty number available for reallocation */
1736 down(&allocated_ptys_lock);
1737 idr_remove(&allocated_ptys, idx);
1738 up(&allocated_ptys_lock);
1745 * tty_open and tty_release keep up the tty count that contains the
1746 * number of opens done on a tty. We cannot use the inode-count, as
1747 * different inodes might point to the same tty.
1749 * Open-counting is needed for pty masters, as well as for keeping
1750 * track of serial lines: DTR is dropped when the last close happens.
1751 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1753 * The termios state of a pty is reset on first open so that
1754 * settings don't persist across reuse.
1756 static int tty_open(struct inode * inode, struct file * filp)
1758 struct tty_struct *tty;
1760 struct tty_driver *driver;
1762 dev_t device = inode->i_rdev;
1763 unsigned short saved_flags = filp->f_flags;
1765 nonseekable_open(inode, filp);
1768 noctty = filp->f_flags & O_NOCTTY;
1774 if (device == MKDEV(TTYAUX_MAJOR,0)) {
1775 if (!current->signal->tty) {
1779 driver = current->signal->tty->driver;
1780 index = current->signal->tty->index;
1781 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1786 if (device == MKDEV(TTY_MAJOR,0)) {
1787 extern int fg_console;
1788 extern struct tty_driver *console_driver;
1789 driver = console_driver;
1795 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1796 driver = console_device(&index);
1798 /* Don't let /dev/console block */
1799 filp->f_flags |= O_NONBLOCK;
1807 driver = get_tty_driver(device, &index);
1813 retval = init_dev(driver, index, &tty);
1818 filp->private_data = tty;
1819 file_move(filp, &tty->tty_files);
1820 check_tty_count(tty, "tty_open");
1821 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1822 tty->driver->subtype == PTY_TYPE_MASTER)
1824 #ifdef TTY_DEBUG_HANGUP
1825 printk(KERN_DEBUG "opening %s...", tty->name);
1828 if (tty->driver->open)
1829 retval = tty->driver->open(tty, filp);
1833 filp->f_flags = saved_flags;
1835 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1839 #ifdef TTY_DEBUG_HANGUP
1840 printk(KERN_DEBUG "error %d in opening %s...", retval,
1844 if (retval != -ERESTARTSYS)
1846 if (signal_pending(current))
1850 * Need to reset f_op in case a hangup happened.
1852 if (filp->f_op == &hung_up_tty_fops)
1853 filp->f_op = &tty_fops;
1857 current->signal->leader &&
1858 !current->signal->tty &&
1859 tty->session == 0) {
1861 current->signal->tty = tty;
1862 task_unlock(current);
1863 current->signal->tty_old_pgrp = 0;
1864 tty->session = current->signal->session;
1865 tty->pgrp = process_group(current);
1870 #ifdef CONFIG_UNIX98_PTYS
1871 static int ptmx_open(struct inode * inode, struct file * filp)
1873 struct tty_struct *tty;
1878 nonseekable_open(inode, filp);
1880 /* find a device that is not in use. */
1881 down(&allocated_ptys_lock);
1882 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1883 up(&allocated_ptys_lock);
1886 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1888 up(&allocated_ptys_lock);
1889 if (idr_ret == -EAGAIN)
1893 if (index >= pty_limit) {
1894 idr_remove(&allocated_ptys, index);
1895 up(&allocated_ptys_lock);
1898 up(&allocated_ptys_lock);
1901 retval = init_dev(ptm_driver, index, &tty);
1907 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1908 filp->private_data = tty;
1909 file_move(filp, &tty->tty_files);
1912 if (devpts_pty_new(tty->link))
1915 check_tty_count(tty, "tty_open");
1916 retval = ptm_driver->open(tty, filp);
1922 down(&allocated_ptys_lock);
1923 idr_remove(&allocated_ptys, index);
1924 up(&allocated_ptys_lock);
1929 static int tty_release(struct inode * inode, struct file * filp)
1937 /* No kernel lock held - fine */
1938 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1940 struct tty_struct * tty;
1941 struct tty_ldisc *ld;
1944 tty = (struct tty_struct *)filp->private_data;
1945 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1948 ld = tty_ldisc_ref_wait(tty);
1950 ret = (ld->poll)(tty, filp, wait);
1951 tty_ldisc_deref(ld);
1955 static int tty_fasync(int fd, struct file * filp, int on)
1957 struct tty_struct * tty;
1960 tty = (struct tty_struct *)filp->private_data;
1961 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1964 retval = fasync_helper(fd, filp, on, &tty->fasync);
1969 if (!waitqueue_active(&tty->read_wait))
1970 tty->minimum_to_wake = 1;
1971 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1975 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1976 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1981 static int tiocsti(struct tty_struct *tty, char __user *p)
1984 struct tty_ldisc *ld;
1986 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1988 if (get_user(ch, p))
1990 ld = tty_ldisc_ref_wait(tty);
1991 ld->receive_buf(tty, &ch, &mbz, 1);
1992 tty_ldisc_deref(ld);
1996 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
1998 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2003 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2004 struct winsize __user * arg)
2006 struct winsize tmp_ws;
2008 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2010 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2013 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2014 unsigned int currcons = tty->index;
2017 acquire_console_sem();
2018 rc = vc_resize(currcons, tmp_ws.ws_col, tmp_ws.ws_row);
2019 release_console_sem();
2025 kill_pg(tty->pgrp, SIGWINCH, 1);
2026 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2027 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2028 tty->winsize = tmp_ws;
2029 real_tty->winsize = tmp_ws;
2033 static int tioccons(struct file *file)
2035 if (!capable(CAP_SYS_ADMIN))
2037 if (file->f_op->write == redirected_tty_write) {
2039 spin_lock(&redirect_lock);
2042 spin_unlock(&redirect_lock);
2047 spin_lock(&redirect_lock);
2049 spin_unlock(&redirect_lock);
2054 spin_unlock(&redirect_lock);
2059 static int fionbio(struct file *file, int __user *p)
2063 if (get_user(nonblock, p))
2067 file->f_flags |= O_NONBLOCK;
2069 file->f_flags &= ~O_NONBLOCK;
2073 static int tiocsctty(struct tty_struct *tty, int arg)
2077 if (current->signal->leader &&
2078 (current->signal->session == tty->session))
2081 * The process must be a session leader and
2082 * not have a controlling tty already.
2084 if (!current->signal->leader || current->signal->tty)
2086 if (tty->session > 0) {
2088 * This tty is already the controlling
2089 * tty for another session group!
2091 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2096 read_lock(&tasklist_lock);
2097 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2098 p->signal->tty = NULL;
2099 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2100 read_unlock(&tasklist_lock);
2105 current->signal->tty = tty;
2106 task_unlock(current);
2107 current->signal->tty_old_pgrp = 0;
2108 tty->session = current->signal->session;
2109 tty->pgrp = process_group(current);
2113 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2117 * (tty == real_tty) is a cheap way of
2118 * testing if the tty is NOT a master pty.
2120 if (tty == real_tty && current->signal->tty != real_tty)
2123 pgrp = vx_map_pid(real_tty->pgrp);
2124 return put_user(pgrp, p);
2127 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2130 int retval = tty_check_change(real_tty);
2136 if (!current->signal->tty ||
2137 (current->signal->tty != real_tty) ||
2138 (real_tty->session != current->signal->session))
2140 if (get_user(pgrp, p))
2143 pgrp = vx_rmap_pid(pgrp);
2146 if (session_of_pgrp(pgrp) != current->signal->session)
2148 real_tty->pgrp = pgrp;
2152 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2155 * (tty == real_tty) is a cheap way of
2156 * testing if the tty is NOT a master pty.
2158 if (tty == real_tty && current->signal->tty != real_tty)
2160 if (real_tty->session <= 0)
2162 return put_user(real_tty->session, p);
2165 static int tiocsetd(struct tty_struct *tty, int __user *p)
2169 if (get_user(ldisc, p))
2171 return tty_set_ldisc(tty, ldisc);
2174 static int send_break(struct tty_struct *tty, int duration)
2176 tty->driver->break_ctl(tty, -1);
2177 if (!signal_pending(current)) {
2178 set_current_state(TASK_INTERRUPTIBLE);
2179 schedule_timeout(duration);
2181 tty->driver->break_ctl(tty, 0);
2182 if (signal_pending(current))
2188 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2190 int retval = -EINVAL;
2192 if (tty->driver->tiocmget) {
2193 retval = tty->driver->tiocmget(tty, file);
2196 retval = put_user(retval, p);
2202 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2205 int retval = -EINVAL;
2207 if (tty->driver->tiocmset) {
2208 unsigned int set, clear, val;
2210 retval = get_user(val, p);
2228 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2229 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2231 retval = tty->driver->tiocmset(tty, file, set, clear);
2237 * Split this up, as gcc can choke on it otherwise..
2239 int tty_ioctl(struct inode * inode, struct file * file,
2240 unsigned int cmd, unsigned long arg)
2242 struct tty_struct *tty, *real_tty;
2243 void __user *p = (void __user *)arg;
2245 struct tty_ldisc *ld;
2247 tty = (struct tty_struct *)file->private_data;
2248 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2252 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2253 tty->driver->subtype == PTY_TYPE_MASTER)
2254 real_tty = tty->link;
2257 * Break handling by driver
2259 if (!tty->driver->break_ctl) {
2263 if (tty->driver->ioctl)
2264 return tty->driver->ioctl(tty, file, cmd, arg);
2267 /* These two ioctl's always return success; even if */
2268 /* the driver doesn't support them. */
2271 if (!tty->driver->ioctl)
2273 retval = tty->driver->ioctl(tty, file, cmd, arg);
2274 if (retval == -ENOIOCTLCMD)
2281 * Factor out some common prep work
2289 retval = tty_check_change(tty);
2292 if (cmd != TIOCCBRK) {
2293 tty_wait_until_sent(tty, 0);
2294 if (signal_pending(current))
2302 return tiocsti(tty, p);
2304 return tiocgwinsz(tty, p);
2306 return tiocswinsz(tty, real_tty, p);
2308 return real_tty!=tty ? -EINVAL : tioccons(file);
2310 return fionbio(file, p);
2312 set_bit(TTY_EXCLUSIVE, &tty->flags);
2315 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2318 if (current->signal->tty != tty)
2320 if (current->signal->leader)
2321 disassociate_ctty(0);
2323 current->signal->tty = NULL;
2324 task_unlock(current);
2327 return tiocsctty(tty, arg);
2329 return tiocgpgrp(tty, real_tty, p);
2331 return tiocspgrp(tty, real_tty, p);
2333 return tiocgsid(tty, real_tty, p);
2335 /* FIXME: check this is ok */
2336 return put_user(tty->ldisc.num, (int __user *)p);
2338 return tiocsetd(tty, p);
2341 return tioclinux(tty, arg);
2346 case TIOCSBRK: /* Turn break on, unconditionally */
2347 tty->driver->break_ctl(tty, -1);
2350 case TIOCCBRK: /* Turn break off, unconditionally */
2351 tty->driver->break_ctl(tty, 0);
2353 case TCSBRK: /* SVID version: non-zero arg --> no break */
2355 * XXX is the above comment correct, or the
2356 * code below correct? Is this ioctl used at
2360 return send_break(tty, HZ/4);
2362 case TCSBRKP: /* support for POSIX tcsendbreak() */
2363 return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
2366 return tty_tiocmget(tty, file, p);
2371 return tty_tiocmset(tty, file, cmd, p);
2373 if (tty->driver->ioctl) {
2374 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2375 if (retval != -ENOIOCTLCMD)
2378 ld = tty_ldisc_ref_wait(tty);
2381 retval = ld->ioctl(tty, file, cmd, arg);
2382 if (retval == -ENOIOCTLCMD)
2385 tty_ldisc_deref(ld);
2391 * This implements the "Secure Attention Key" --- the idea is to
2392 * prevent trojan horses by killing all processes associated with this
2393 * tty when the user hits the "Secure Attention Key". Required for
2394 * super-paranoid applications --- see the Orange Book for more details.
2396 * This code could be nicer; ideally it should send a HUP, wait a few
2397 * seconds, then send a INT, and then a KILL signal. But you then
2398 * have to coordinate with the init process, since all processes associated
2399 * with the current tty must be dead before the new getty is allowed
2402 * Now, if it would be correct ;-/ The current code has a nasty hole -
2403 * it doesn't catch files in flight. We may send the descriptor to ourselves
2404 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2406 * Nasty bug: do_SAK is being called in interrupt context. This can
2407 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2409 static void __do_SAK(void *arg)
2414 struct tty_struct *tty = arg;
2415 struct task_struct *p;
2419 struct tty_ldisc *disc;
2423 session = tty->session;
2425 /* We don't want an ldisc switch during this */
2426 disc = tty_ldisc_ref(tty);
2427 if (disc && disc->flush_buffer)
2428 disc->flush_buffer(tty);
2429 tty_ldisc_deref(disc);
2431 if (tty->driver->flush_buffer)
2432 tty->driver->flush_buffer(tty);
2434 read_lock(&tasklist_lock);
2435 do_each_task_pid(session, PIDTYPE_SID, p) {
2436 if (p->signal->tty == tty || session > 0) {
2437 printk(KERN_NOTICE "SAK: killed process %d"
2438 " (%s): p->signal->session==tty->session\n",
2440 send_sig(SIGKILL, p, 1);
2445 spin_lock(&p->files->file_lock);
2446 for (i=0; i < p->files->max_fds; i++) {
2447 filp = fcheck_files(p->files, i);
2450 if (filp->f_op->read == tty_read &&
2451 filp->private_data == tty) {
2452 printk(KERN_NOTICE "SAK: killed process %d"
2453 " (%s): fd#%d opened to the tty\n",
2454 p->pid, p->comm, i);
2455 send_sig(SIGKILL, p, 1);
2459 spin_unlock(&p->files->file_lock);
2462 } while_each_task_pid(session, PIDTYPE_SID, p);
2463 read_unlock(&tasklist_lock);
2468 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2469 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2470 * the values which we write to it will be identical to the values which it
2471 * already has. --akpm
2473 void do_SAK(struct tty_struct *tty)
2477 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2478 schedule_work(&tty->SAK_work);
2481 EXPORT_SYMBOL(do_SAK);
2484 * This routine is called out of the software interrupt to flush data
2485 * from the flip buffer to the line discipline.
2488 static void flush_to_ldisc(void *private_)
2490 struct tty_struct *tty = (struct tty_struct *) private_;
2494 unsigned long flags;
2495 struct tty_ldisc *disc;
2497 disc = tty_ldisc_ref(tty);
2498 if (disc == NULL) /* !TTY_LDISC */
2501 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2503 * Do it after the next timer tick:
2505 schedule_delayed_work(&tty->flip.work, 1);
2508 spin_lock_irqsave(&tty->read_lock, flags);
2509 if (tty->flip.buf_num) {
2510 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2511 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2512 tty->flip.buf_num = 0;
2513 tty->flip.char_buf_ptr = tty->flip.char_buf;
2514 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2516 cp = tty->flip.char_buf;
2517 fp = tty->flip.flag_buf;
2518 tty->flip.buf_num = 1;
2519 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2520 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2522 count = tty->flip.count;
2523 tty->flip.count = 0;
2524 spin_unlock_irqrestore(&tty->read_lock, flags);
2526 disc->receive_buf(tty, cp, fp, count);
2528 tty_ldisc_deref(disc);
2532 * Call the ldisc flush directly from a driver. This function may
2533 * return an error and need retrying by the user.
2536 int tty_push_data(struct tty_struct *tty, unsigned char *cp, unsigned char *fp, int count)
2539 struct tty_ldisc *disc;
2541 disc = tty_ldisc_ref(tty);
2542 if(test_bit(TTY_DONT_FLIP, &tty->flags))
2544 else if(disc == NULL)
2547 disc->receive_buf(tty, cp, fp, count);
2548 tty_ldisc_deref(disc);
2554 * Routine which returns the baud rate of the tty
2556 * Note that the baud_table needs to be kept in sync with the
2557 * include/asm/termbits.h file.
2559 static int baud_table[] = {
2560 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2561 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2563 76800, 153600, 307200, 614400, 921600
2565 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2566 2500000, 3000000, 3500000, 4000000
2570 static int n_baud_table = ARRAY_SIZE(baud_table);
2573 * tty_termios_baud_rate
2574 * @termios: termios structure
2576 * Convert termios baud rate data into a speed. This should be called
2577 * with the termios lock held if this termios is a terminal termios
2578 * structure. May change the termios data.
2581 int tty_termios_baud_rate(struct termios *termios)
2585 cbaud = termios->c_cflag & CBAUD;
2587 if (cbaud & CBAUDEX) {
2590 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2591 termios->c_cflag &= ~CBAUDEX;
2595 return baud_table[cbaud];
2598 EXPORT_SYMBOL(tty_termios_baud_rate);
2601 * tty_get_baud_rate - get tty bit rates
2602 * @tty: tty to query
2604 * Returns the baud rate as an integer for this terminal. The
2605 * termios lock must be held by the caller and the terminal bit
2606 * flags may be updated.
2609 int tty_get_baud_rate(struct tty_struct *tty)
2611 int baud = tty_termios_baud_rate(tty->termios);
2613 if (baud == 38400 && tty->alt_speed) {
2615 printk(KERN_WARNING "Use of setserial/setrocket to "
2616 "set SPD_* flags is deprecated\n");
2619 baud = tty->alt_speed;
2625 EXPORT_SYMBOL(tty_get_baud_rate);
2628 * tty_flip_buffer_push - terminal
2631 * Queue a push of the terminal flip buffers to the line discipline. This
2632 * function must not be called from IRQ context if tty->low_latency is set.
2634 * In the event of the queue being busy for flipping the work will be
2635 * held off and retried later.
2638 void tty_flip_buffer_push(struct tty_struct *tty)
2640 if (tty->low_latency)
2641 flush_to_ldisc((void *) tty);
2643 schedule_delayed_work(&tty->flip.work, 1);
2646 EXPORT_SYMBOL(tty_flip_buffer_push);
2649 * This subroutine initializes a tty structure.
2651 static void initialize_tty_struct(struct tty_struct *tty)
2653 memset(tty, 0, sizeof(struct tty_struct));
2654 tty->magic = TTY_MAGIC;
2655 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2657 tty->flip.char_buf_ptr = tty->flip.char_buf;
2658 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2659 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2660 init_MUTEX(&tty->flip.pty_sem);
2661 init_MUTEX(&tty->termios_sem);
2662 init_waitqueue_head(&tty->write_wait);
2663 init_waitqueue_head(&tty->read_wait);
2664 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2665 sema_init(&tty->atomic_read, 1);
2666 sema_init(&tty->atomic_write, 1);
2667 spin_lock_init(&tty->read_lock);
2668 INIT_LIST_HEAD(&tty->tty_files);
2669 INIT_WORK(&tty->SAK_work, NULL, NULL);
2673 * The default put_char routine if the driver did not define one.
2675 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2677 tty->driver->write(tty, &ch, 1);
2680 static struct class_simple *tty_class;
2683 * tty_register_device - register a tty device
2684 * @driver: the tty driver that describes the tty device
2685 * @index: the index in the tty driver for this tty device
2686 * @device: a struct device that is associated with this tty device.
2687 * This field is optional, if there is no known struct device for this
2688 * tty device it can be set to NULL safely.
2690 * This call is required to be made to register an individual tty device if
2691 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2692 * bit is not set, this function should not be called.
2694 void tty_register_device(struct tty_driver *driver, unsigned index,
2695 struct device *device)
2698 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2700 if (index >= driver->num) {
2701 printk(KERN_ERR "Attempt to register invalid tty line number "
2706 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2707 "%s%d", driver->devfs_name, index + driver->name_base);
2709 if (driver->type == TTY_DRIVER_TYPE_PTY)
2710 pty_line_name(driver, index, name);
2712 tty_line_name(driver, index, name);
2713 class_simple_device_add(tty_class, dev, device, name);
2717 * tty_unregister_device - unregister a tty device
2718 * @driver: the tty driver that describes the tty device
2719 * @index: the index in the tty driver for this tty device
2721 * If a tty device is registered with a call to tty_register_device() then
2722 * this function must be made when the tty device is gone.
2724 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2726 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2727 class_simple_device_remove(MKDEV(driver->major, driver->minor_start) + index);
2730 EXPORT_SYMBOL(tty_register_device);
2731 EXPORT_SYMBOL(tty_unregister_device);
2733 struct tty_driver *alloc_tty_driver(int lines)
2735 struct tty_driver *driver;
2737 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2739 memset(driver, 0, sizeof(struct tty_driver));
2740 driver->magic = TTY_DRIVER_MAGIC;
2741 driver->num = lines;
2742 /* later we'll move allocation of tables here */
2747 void put_tty_driver(struct tty_driver *driver)
2752 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2754 driver->open = op->open;
2755 driver->close = op->close;
2756 driver->write = op->write;
2757 driver->put_char = op->put_char;
2758 driver->flush_chars = op->flush_chars;
2759 driver->write_room = op->write_room;
2760 driver->chars_in_buffer = op->chars_in_buffer;
2761 driver->ioctl = op->ioctl;
2762 driver->set_termios = op->set_termios;
2763 driver->throttle = op->throttle;
2764 driver->unthrottle = op->unthrottle;
2765 driver->stop = op->stop;
2766 driver->start = op->start;
2767 driver->hangup = op->hangup;
2768 driver->break_ctl = op->break_ctl;
2769 driver->flush_buffer = op->flush_buffer;
2770 driver->set_ldisc = op->set_ldisc;
2771 driver->wait_until_sent = op->wait_until_sent;
2772 driver->send_xchar = op->send_xchar;
2773 driver->read_proc = op->read_proc;
2774 driver->write_proc = op->write_proc;
2775 driver->tiocmget = op->tiocmget;
2776 driver->tiocmset = op->tiocmset;
2780 EXPORT_SYMBOL(alloc_tty_driver);
2781 EXPORT_SYMBOL(put_tty_driver);
2782 EXPORT_SYMBOL(tty_set_operations);
2785 * Called by a tty driver to register itself.
2787 int tty_register_driver(struct tty_driver *driver)
2794 if (driver->flags & TTY_DRIVER_INSTALLED)
2797 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2798 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2801 memset(p, 0, driver->num * 3 * sizeof(void *));
2804 if (!driver->major) {
2805 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2806 (char*)driver->name);
2808 driver->major = MAJOR(dev);
2809 driver->minor_start = MINOR(dev);
2812 dev = MKDEV(driver->major, driver->minor_start);
2813 error = register_chrdev_region(dev, driver->num,
2814 (char*)driver->name);
2822 driver->ttys = (struct tty_struct **)p;
2823 driver->termios = (struct termios **)(p + driver->num);
2824 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2826 driver->ttys = NULL;
2827 driver->termios = NULL;
2828 driver->termios_locked = NULL;
2831 cdev_init(&driver->cdev, &tty_fops);
2832 driver->cdev.owner = driver->owner;
2833 error = cdev_add(&driver->cdev, dev, driver->num);
2835 cdev_del(&driver->cdev);
2836 unregister_chrdev_region(dev, driver->num);
2837 driver->ttys = NULL;
2838 driver->termios = driver->termios_locked = NULL;
2843 if (!driver->put_char)
2844 driver->put_char = tty_default_put_char;
2846 list_add(&driver->tty_drivers, &tty_drivers);
2848 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2849 for(i = 0; i < driver->num; i++)
2850 tty_register_device(driver, i, NULL);
2852 proc_tty_register_driver(driver);
2856 EXPORT_SYMBOL(tty_register_driver);
2859 * Called by a tty driver to unregister itself.
2861 int tty_unregister_driver(struct tty_driver *driver)
2867 if (driver->refcount)
2870 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2873 list_del(&driver->tty_drivers);
2876 * Free the termios and termios_locked structures because
2877 * we don't want to get memory leaks when modular tty
2878 * drivers are removed from the kernel.
2880 for (i = 0; i < driver->num; i++) {
2881 tp = driver->termios[i];
2883 driver->termios[i] = NULL;
2886 tp = driver->termios_locked[i];
2888 driver->termios_locked[i] = NULL;
2891 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2892 tty_unregister_device(driver, i);
2895 proc_tty_unregister_driver(driver);
2896 driver->ttys = NULL;
2897 driver->termios = driver->termios_locked = NULL;
2899 cdev_del(&driver->cdev);
2903 EXPORT_SYMBOL(tty_unregister_driver);
2907 * Initialize the console device. This is called *early*, so
2908 * we can't necessarily depend on lots of kernel help here.
2909 * Just do some early initializations, and do the complex setup
2912 void __init console_init(void)
2916 /* Setup the default TTY line discipline. */
2917 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2920 * set up the console device so that later boot sequences can
2921 * inform about problems etc..
2923 #ifdef CONFIG_EARLY_PRINTK
2924 disable_early_printk();
2926 #ifdef CONFIG_SERIAL_68360
2927 /* This is not a console initcall. I know not what it's doing here.
2928 So I haven't moved it. dwmw2 */
2931 call = &__con_initcall_start;
2932 while (call < &__con_initcall_end) {
2939 extern int vty_init(void);
2942 static int __init tty_class_init(void)
2944 tty_class = class_simple_create(THIS_MODULE, "tty");
2945 if (IS_ERR(tty_class))
2946 return PTR_ERR(tty_class);
2950 postcore_initcall(tty_class_init);
2952 /* 3/2004 jmc: why do these devices exist? */
2954 static struct cdev tty_cdev, console_cdev;
2955 #ifdef CONFIG_UNIX98_PTYS
2956 static struct cdev ptmx_cdev;
2959 static struct cdev vc0_cdev;
2963 * Ok, now we can initialize the rest of the tty devices and can count
2964 * on memory allocations, interrupts etc..
2966 static int __init tty_init(void)
2968 cdev_init(&tty_cdev, &tty_fops);
2969 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2970 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2971 panic("Couldn't register /dev/tty driver\n");
2972 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2973 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2975 cdev_init(&console_cdev, &console_fops);
2976 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2977 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2978 panic("Couldn't register /dev/console driver\n");
2979 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2980 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2982 #ifdef CONFIG_UNIX98_PTYS
2983 cdev_init(&ptmx_cdev, &ptmx_fops);
2984 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2985 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2986 panic("Couldn't register /dev/ptmx driver\n");
2987 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2988 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2992 cdev_init(&vc0_cdev, &console_fops);
2993 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2994 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2995 panic("Couldn't register /dev/tty0 driver\n");
2996 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
2997 class_simple_device_add(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3003 module_init(tty_init);