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>
97 #include <asm/uaccess.h>
98 #include <asm/system.h>
99 #include <asm/bitops.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);
142 extern void disable_early_printk(void);
144 static void initialize_tty_struct(struct tty_struct *tty);
146 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149 static unsigned int tty_poll(struct file *, poll_table *);
150 static int tty_open(struct inode *, struct file *);
151 static int ptmx_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)
175 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
177 char *tty_name(struct tty_struct *tty, char *buf)
179 if (!tty) /* Hmm. NULL pointer. That's fun. */
180 strcpy(buf, "NULL tty");
182 strcpy(buf, tty->name);
186 EXPORT_SYMBOL(tty_name);
188 inline int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
191 #ifdef TTY_PARANOIA_CHECK
194 "null TTY for (%d:%d) in %s\n",
195 imajor(inode), iminor(inode), routine);
198 if (tty->magic != TTY_MAGIC) {
200 "bad magic number for tty struct (%d:%d) in %s\n",
201 imajor(inode), iminor(inode), routine);
208 static int check_tty_count(struct tty_struct *tty, const char *routine)
210 #ifdef CHECK_TTY_COUNT
215 list_for_each(p, &tty->tty_files) {
219 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
220 tty->driver->subtype == PTY_TYPE_SLAVE &&
221 tty->link && tty->link->count)
223 if (tty->count != count) {
224 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
225 "!= #fd's(%d) in %s\n",
226 tty->name, tty->count, count, routine);
234 * This is probably overkill for real world processors but
235 * they are not on hot paths so a little discipline won't do
239 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
241 down(&tty->termios_sem);
242 tty->termios->c_line = num;
243 up(&tty->termios_sem);
247 * This guards the refcounted line discipline lists. The lock
248 * must be taken with irqs off because there are hangup path
249 * callers who will do ldisc lookups and cannot sleep.
252 static spinlock_t tty_ldisc_lock = SPIN_LOCK_UNLOCKED;
253 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
254 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
256 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
261 if (disc < N_TTY || disc >= NR_LDISCS)
264 spin_lock_irqsave(&tty_ldisc_lock, flags);
266 tty_ldiscs[disc] = *new_ldisc;
267 tty_ldiscs[disc].num = disc;
268 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
269 tty_ldiscs[disc].refcount = 0;
271 if(tty_ldiscs[disc].refcount)
274 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
276 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
281 EXPORT_SYMBOL(tty_register_ldisc);
283 struct tty_ldisc *tty_ldisc_get(int disc)
286 struct tty_ldisc *ld;
288 if (disc < N_TTY || disc >= NR_LDISCS)
291 spin_lock_irqsave(&tty_ldisc_lock, flags);
293 ld = &tty_ldiscs[disc];
294 /* Check the entry is defined */
295 if(ld->flags & LDISC_FLAG_DEFINED)
297 /* If the module is being unloaded we can't use it */
298 if (!try_module_get(ld->owner))
305 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
309 EXPORT_SYMBOL_GPL(tty_ldisc_get);
311 void tty_ldisc_put(int disc)
313 struct tty_ldisc *ld;
316 if (disc < N_TTY || disc >= NR_LDISCS)
319 spin_lock_irqsave(&tty_ldisc_lock, flags);
320 ld = &tty_ldiscs[disc];
321 if(ld->refcount == 0)
324 module_put(ld->owner);
325 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
328 EXPORT_SYMBOL_GPL(tty_ldisc_put);
330 void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
333 tty->ldisc.refcount = 0;
337 * tty_ldisc_try - internal helper
340 * Make a single attempt to grab and bump the refcount on
341 * the tty ldisc. Return 0 on failure or 1 on success. This is
342 * used to implement both the waiting and non waiting versions
346 static int tty_ldisc_try(struct tty_struct *tty)
349 struct tty_ldisc *ld;
352 spin_lock_irqsave(&tty_ldisc_lock, flags);
354 if(test_bit(TTY_LDISC, &tty->flags))
359 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
364 * tty_ldisc_ref_wait - wait for the tty ldisc
367 * Dereference the line discipline for the terminal and take a
368 * reference to it. If the line discipline is in flux then
369 * wait patiently until it changes.
371 * Note: Must not be called from an IRQ/timer context. The caller
372 * must also be careful not to hold other locks that will deadlock
373 * against a discipline change, such as an existing ldisc reference
374 * (which we check for)
377 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
379 /* wait_event is a macro */
380 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
381 if(tty->ldisc.refcount == 0)
382 printk(KERN_ERR "tty_ldisc_ref_wait\n");
386 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
389 * tty_ldisc_ref - get the tty ldisc
392 * Dereference the line discipline for the terminal and take a
393 * reference to it. If the line discipline is in flux then
394 * return NULL. Can be called from IRQ and timer functions.
397 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
399 if(tty_ldisc_try(tty))
404 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
407 * tty_ldisc_deref - free a tty ldisc reference
408 * @ld: reference to free up
410 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
411 * be called in IRQ context.
414 void tty_ldisc_deref(struct tty_ldisc *ld)
421 spin_lock_irqsave(&tty_ldisc_lock, flags);
422 if(ld->refcount == 0)
423 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
426 if(ld->refcount == 0)
427 wake_up(&tty_ldisc_wait);
428 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
431 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
434 * tty_ldisc_enable - allow ldisc use
435 * @tty: terminal to activate ldisc on
437 * Set the TTY_LDISC flag when the line discipline can be called
438 * again. Do neccessary wakeups for existing sleepers.
440 * Note: nobody should set this bit except via this function. Clearing
441 * directly is allowed.
444 static void tty_ldisc_enable(struct tty_struct *tty)
446 set_bit(TTY_LDISC, &tty->flags);
447 wake_up(&tty_ldisc_wait);
451 * tty_set_ldisc - set line discipline
452 * @tty: the terminal to set
453 * @ldisc: the line discipline
455 * Set the discipline of a tty line. Must be called from a process
459 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
462 struct tty_ldisc o_ldisc;
466 struct tty_ldisc *ld;
468 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
473 if (tty->ldisc.num == ldisc)
474 return 0; /* We are already in the desired discipline */
476 ld = tty_ldisc_get(ldisc);
477 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
478 /* Cyrus Durgin <cider@speakeasy.org> */
480 request_module("tty-ldisc-%d", ldisc);
481 ld = tty_ldisc_get(ldisc);
486 o_ldisc = tty->ldisc;
488 tty_wait_until_sent(tty, 0);
491 * Make sure we don't change while someone holds a
492 * reference to the line discipline. The TTY_LDISC bit
493 * prevents anyone taking a reference once it is clear.
494 * We need the lock to avoid racing reference takers.
497 spin_lock_irqsave(&tty_ldisc_lock, flags);
498 if(tty->ldisc.refcount)
500 /* Free the new ldisc we grabbed. Must drop the lock
502 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
503 tty_ldisc_put(ldisc);
505 * There are several reasons we may be busy, including
506 * random momentary I/O traffic. We must therefore
507 * retry. We could distinguish between blocking ops
508 * and retries if we made tty_ldisc_wait() smarter. That
509 * is up for discussion.
511 if(wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
515 clear_bit(TTY_LDISC, &tty->flags);
516 clear_bit(TTY_DONT_FLIP, &tty->flags);
517 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
520 * From this point on we know nobody has an ldisc
521 * usage reference, nor can they obtain one until
522 * we say so later on.
525 work = cancel_delayed_work(&tty->flip.work);
527 * Wait for ->hangup_work and ->flip.work handlers to terminate
530 flush_scheduled_work();
531 /* Shutdown the current discipline. */
532 if (tty->ldisc.close)
533 (tty->ldisc.close)(tty);
535 /* Now set up the new line discipline. */
536 tty_ldisc_assign(tty, ld);
537 tty_set_termios_ldisc(tty, ldisc);
539 retval = (tty->ldisc.open)(tty);
541 tty_ldisc_put(ldisc);
542 /* There is an outstanding reference here so this is safe */
543 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
544 tty_set_termios_ldisc(tty, tty->ldisc.num);
545 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
546 tty_ldisc_put(o_ldisc.num);
547 /* This driver is always present */
548 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
549 tty_set_termios_ldisc(tty, N_TTY);
550 if (tty->ldisc.open) {
551 int r = tty->ldisc.open(tty);
554 panic("Couldn't open N_TTY ldisc for "
556 tty_name(tty, buf), r);
560 /* At this point we hold a reference to the new ldisc and a
561 a reference to the old ldisc. If we ended up flipping back
562 to the existing ldisc we have two references to it */
564 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
565 tty->driver->set_ldisc(tty);
567 tty_ldisc_put(o_ldisc.num);
570 * Allow ldisc referencing to occur as soon as the driver
571 * ldisc callback completes.
574 tty_ldisc_enable(tty);
576 /* Restart it in case no characters kick it off. Safe if
579 schedule_delayed_work(&tty->flip.work, 1);
584 * This routine returns a tty driver structure, given a device number
586 struct tty_driver *get_tty_driver(dev_t device, int *index)
588 struct tty_driver *p;
590 list_for_each_entry(p, &tty_drivers, tty_drivers) {
591 dev_t base = MKDEV(p->major, p->minor_start);
592 if (device < base || device >= base + p->num)
594 *index = device - base;
601 * If we try to write to, or set the state of, a terminal and we're
602 * not in the foreground, send a SIGTTOU. If the signal is blocked or
603 * ignored, go ahead and perform the operation. (POSIX 7.2)
605 int tty_check_change(struct tty_struct * tty)
607 if (current->signal->tty != tty)
609 if (tty->pgrp <= 0) {
610 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
613 if (process_group(current) == tty->pgrp)
615 if (is_ignored(SIGTTOU))
617 if (is_orphaned_pgrp(process_group(current)))
619 (void) kill_pg(process_group(current), SIGTTOU, 1);
623 EXPORT_SYMBOL(tty_check_change);
625 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
626 size_t count, loff_t *ppos)
631 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
632 size_t count, loff_t *ppos)
637 /* No kernel lock held - none needed ;) */
638 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
640 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
643 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
644 unsigned int cmd, unsigned long arg)
646 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
649 static struct file_operations tty_fops = {
656 .release = tty_release,
657 .fasync = tty_fasync,
660 #ifdef CONFIG_UNIX98_PTYS
661 static struct file_operations ptmx_fops = {
668 .release = tty_release,
669 .fasync = tty_fasync,
673 static struct file_operations console_fops = {
676 .write = redirected_tty_write,
680 .release = tty_release,
681 .fasync = tty_fasync,
684 static struct file_operations hung_up_tty_fops = {
686 .read = hung_up_tty_read,
687 .write = hung_up_tty_write,
688 .poll = hung_up_tty_poll,
689 .ioctl = hung_up_tty_ioctl,
690 .release = tty_release,
693 static spinlock_t redirect_lock = SPIN_LOCK_UNLOCKED;
694 static struct file *redirect;
697 * tty_wakeup - request more data
700 * Internal and external helper for wakeups of tty. This function
701 * informs the line discipline if present that the driver is ready
702 * to receive more output data.
705 void tty_wakeup(struct tty_struct *tty)
707 struct tty_ldisc *ld;
709 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
710 ld = tty_ldisc_ref(tty);
713 ld->write_wakeup(tty);
717 wake_up_interruptible(&tty->write_wait);
720 EXPORT_SYMBOL_GPL(tty_wakeup);
723 * tty_ldisc_flush - flush line discipline queue
726 * Flush the line discipline queue (if any) for this tty. If there
727 * is no line discipline active this is a no-op.
730 void tty_ldisc_flush(struct tty_struct *tty)
732 struct tty_ldisc *ld = tty_ldisc_ref(tty);
735 ld->flush_buffer(tty);
740 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
743 * This can be called by the "eventd" kernel thread. That is process synchronous,
744 * but doesn't hold any locks, so we need to make sure we have the appropriate
745 * locks for what we're doing..
747 void do_tty_hangup(void *data)
749 struct tty_struct *tty = (struct tty_struct *) data;
750 struct file * cons_filp = NULL;
751 struct file *filp, *f = NULL;
752 struct task_struct *p;
753 struct tty_ldisc *ld;
754 int closecount = 0, n;
759 /* inuse_filps is protected by the single kernel lock */
762 spin_lock(&redirect_lock);
763 if (redirect && redirect->private_data == tty) {
767 spin_unlock(&redirect_lock);
769 check_tty_count(tty, "do_tty_hangup");
771 /* This breaks for file handles being sent over AF_UNIX sockets ? */
772 list_for_each_entry(filp, &tty->tty_files, f_list) {
773 if (filp->f_op->write == redirected_tty_write)
775 if (filp->f_op->write != tty_write)
778 tty_fasync(-1, filp, 0); /* can't block */
779 filp->f_op = &hung_up_tty_fops;
783 /* FIXME! What are the locking issues here? This may me overdoing things..
784 * this question is especially important now that we've removed the irqlock. */
786 ld = tty_ldisc_ref(tty);
787 if(ld != NULL) /* We may have no line discipline at this point */
789 if (ld->flush_buffer)
790 ld->flush_buffer(tty);
791 if (tty->driver->flush_buffer)
792 tty->driver->flush_buffer(tty);
793 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
795 ld->write_wakeup(tty);
800 /* FIXME: Once we trust the LDISC code better we can wait here for
801 ldisc completion and fix the driver call race */
803 wake_up_interruptible(&tty->write_wait);
804 wake_up_interruptible(&tty->read_wait);
807 * Shutdown the current line discipline, and reset it to
810 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
812 down(&tty->termios_sem);
813 *tty->termios = tty->driver->init_termios;
814 up(&tty->termios_sem);
817 /* Defer ldisc switch */
818 /* tty_deferred_ldisc_switch(N_TTY);
820 This should get done automatically when the port closes and
821 tty_release is called */
823 read_lock(&tasklist_lock);
824 if (tty->session > 0) {
825 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
826 if (p->signal->tty == tty)
827 p->signal->tty = NULL;
828 if (!p->signal->leader)
830 send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
831 send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
833 p->signal->tty_old_pgrp = tty->pgrp;
834 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
836 read_unlock(&tasklist_lock);
841 tty->ctrl_status = 0;
843 * If one of the devices matches a console pointer, we
844 * cannot just call hangup() because that will cause
845 * tty->count and state->count to go out of sync.
846 * So we just call close() the right number of times.
849 if (tty->driver->close)
850 for (n = 0; n < closecount; n++)
851 tty->driver->close(tty, cons_filp);
852 } else if (tty->driver->hangup)
853 (tty->driver->hangup)(tty);
855 /* We don't want to have driver/ldisc interactions beyond
856 the ones we did here. The driver layer expects no
857 calls after ->hangup() from the ldisc side. However we
858 can't yet guarantee all that */
860 set_bit(TTY_HUPPED, &tty->flags);
862 tty_ldisc_enable(tty);
870 void tty_hangup(struct tty_struct * tty)
872 #ifdef TTY_DEBUG_HANGUP
875 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
877 schedule_work(&tty->hangup_work);
880 EXPORT_SYMBOL(tty_hangup);
882 void tty_vhangup(struct tty_struct * tty)
884 #ifdef TTY_DEBUG_HANGUP
887 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
889 do_tty_hangup((void *) tty);
891 EXPORT_SYMBOL(tty_vhangup);
893 int tty_hung_up_p(struct file * filp)
895 return (filp->f_op == &hung_up_tty_fops);
898 EXPORT_SYMBOL(tty_hung_up_p);
901 * This function is typically called only by the session leader, when
902 * it wants to disassociate itself from its controlling tty.
904 * It performs the following functions:
905 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
906 * (2) Clears the tty from being controlling the session
907 * (3) Clears the controlling tty for all processes in the
910 * The argument on_exit is set to 1 if called when a process is
911 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
913 void disassociate_ctty(int on_exit)
915 struct tty_struct *tty;
916 struct task_struct *p;
921 tty = current->signal->tty;
923 tty_pgrp = tty->pgrp;
924 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
927 if (current->signal->tty_old_pgrp) {
928 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
929 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
935 kill_pg(tty_pgrp, SIGHUP, on_exit);
937 kill_pg(tty_pgrp, SIGCONT, on_exit);
940 current->signal->tty_old_pgrp = 0;
944 read_lock(&tasklist_lock);
945 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
946 p->signal->tty = NULL;
947 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
948 read_unlock(&tasklist_lock);
952 void stop_tty(struct tty_struct *tty)
957 if (tty->link && tty->link->packet) {
958 tty->ctrl_status &= ~TIOCPKT_START;
959 tty->ctrl_status |= TIOCPKT_STOP;
960 wake_up_interruptible(&tty->link->read_wait);
962 if (tty->driver->stop)
963 (tty->driver->stop)(tty);
966 EXPORT_SYMBOL(stop_tty);
968 void start_tty(struct tty_struct *tty)
970 if (!tty->stopped || tty->flow_stopped)
973 if (tty->link && tty->link->packet) {
974 tty->ctrl_status &= ~TIOCPKT_STOP;
975 tty->ctrl_status |= TIOCPKT_START;
976 wake_up_interruptible(&tty->link->read_wait);
978 if (tty->driver->start)
979 (tty->driver->start)(tty);
981 /* If we have a running line discipline it may need kicking */
983 wake_up_interruptible(&tty->write_wait);
986 EXPORT_SYMBOL(start_tty);
988 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
992 struct tty_struct * tty;
994 struct tty_ldisc *ld;
996 tty = (struct tty_struct *)file->private_data;
997 inode = file->f_dentry->d_inode;
998 if (tty_paranoia_check(tty, inode, "tty_read"))
1000 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1003 /* We want to wait for the line discipline to sort out in this
1005 ld = tty_ldisc_ref_wait(tty);
1008 i = (ld->read)(tty,file,buf,count);
1011 tty_ldisc_deref(ld);
1014 inode->i_atime = CURRENT_TIME;
1019 * Split writes up in sane blocksizes to avoid
1020 * denial-of-service type attacks
1022 static inline ssize_t do_tty_write(
1023 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char __user *, size_t),
1024 struct tty_struct *tty,
1026 const unsigned char __user *buf,
1029 ssize_t ret = 0, written = 0;
1031 if (down_interruptible(&tty->atomic_write)) {
1032 return -ERESTARTSYS;
1034 if ( test_bit(TTY_NO_WRITE_SPLIT, &tty->flags) ) {
1036 written = write(tty, file, buf, count);
1040 unsigned long size = max((unsigned long)PAGE_SIZE*2, 16384UL);
1044 ret = write(tty, file, buf, size);
1054 if (signal_pending(current))
1060 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
1063 up(&tty->atomic_write);
1068 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1071 struct tty_struct * tty;
1072 struct inode *inode = file->f_dentry->d_inode;
1074 struct tty_ldisc *ld;
1076 tty = (struct tty_struct *)file->private_data;
1077 if (tty_paranoia_check(tty, inode, "tty_write"))
1079 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1082 ld = tty_ldisc_ref_wait(tty);
1086 ret = do_tty_write(ld->write, tty, file,
1087 (const unsigned char __user *)buf, count);
1088 tty_ldisc_deref(ld);
1092 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1095 struct file *p = NULL;
1097 spin_lock(&redirect_lock);
1102 spin_unlock(&redirect_lock);
1106 res = vfs_write(p, buf, count, &p->f_pos);
1111 return tty_write(file, buf, count, ppos);
1114 static char ptychar[] = "pqrstuvwxyzabcde";
1116 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1118 int i = index + driver->name_base;
1119 /* ->name is initialized to "ttyp", but "tty" is expected */
1120 sprintf(p, "%s%c%x",
1121 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1122 ptychar[i >> 4 & 0xf], i & 0xf);
1125 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1127 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1131 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1132 * failed open. The new code protects the open with a semaphore, so it's
1133 * really quite straightforward. The semaphore locking can probably be
1134 * relaxed for the (most common) case of reopening a tty.
1136 static int init_dev(struct tty_driver *driver, int idx,
1137 struct tty_struct **ret_tty)
1139 struct tty_struct *tty, *o_tty;
1140 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1141 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1145 * Check whether we need to acquire the tty semaphore to avoid
1146 * race conditions. For now, play it safe.
1150 /* check whether we're reopening an existing tty */
1151 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1152 tty = devpts_get_tty(idx);
1153 if (tty && driver->subtype == PTY_TYPE_MASTER)
1156 tty = driver->ttys[idx];
1158 if (tty) goto fast_track;
1161 * First time open is complex, especially for PTY devices.
1162 * This code guarantees that either everything succeeds and the
1163 * TTY is ready for operation, or else the table slots are vacated
1164 * and the allocated memory released. (Except that the termios
1165 * and locked termios may be retained.)
1168 if (!try_module_get(driver->owner)) {
1177 tty = alloc_tty_struct();
1180 initialize_tty_struct(tty);
1181 tty->driver = driver;
1183 tty_line_name(driver, idx, tty->name);
1185 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1186 tp_loc = &tty->termios;
1187 ltp_loc = &tty->termios_locked;
1189 tp_loc = &driver->termios[idx];
1190 ltp_loc = &driver->termios_locked[idx];
1194 tp = (struct termios *) kmalloc(sizeof(struct termios),
1198 *tp = driver->init_termios;
1202 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1206 memset(ltp, 0, sizeof(struct termios));
1209 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1210 o_tty = alloc_tty_struct();
1213 initialize_tty_struct(o_tty);
1214 o_tty->driver = driver->other;
1216 tty_line_name(driver->other, idx, o_tty->name);
1218 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1219 o_tp_loc = &o_tty->termios;
1220 o_ltp_loc = &o_tty->termios_locked;
1222 o_tp_loc = &driver->other->termios[idx];
1223 o_ltp_loc = &driver->other->termios_locked[idx];
1227 o_tp = (struct termios *)
1228 kmalloc(sizeof(struct termios), GFP_KERNEL);
1231 *o_tp = driver->other->init_termios;
1235 o_ltp = (struct termios *)
1236 kmalloc(sizeof(struct termios), GFP_KERNEL);
1239 memset(o_ltp, 0, sizeof(struct termios));
1243 * Everything allocated ... set up the o_tty structure.
1245 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1246 driver->other->ttys[idx] = o_tty;
1252 o_tty->termios = *o_tp_loc;
1253 o_tty->termios_locked = *o_ltp_loc;
1254 driver->other->refcount++;
1255 if (driver->subtype == PTY_TYPE_MASTER)
1258 /* Establish the links in both directions */
1264 * All structures have been allocated, so now we install them.
1265 * Failures after this point use release_mem to clean up, so
1266 * there's no need to null out the local pointers.
1268 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1269 driver->ttys[idx] = tty;
1276 tty->termios = *tp_loc;
1277 tty->termios_locked = *ltp_loc;
1282 * Structures all installed ... call the ldisc open routines.
1283 * If we fail here just call release_mem to clean up. No need
1284 * to decrement the use counts, as release_mem doesn't care.
1287 if (tty->ldisc.open) {
1288 retval = (tty->ldisc.open)(tty);
1290 goto release_mem_out;
1292 if (o_tty && o_tty->ldisc.open) {
1293 retval = (o_tty->ldisc.open)(o_tty);
1295 if (tty->ldisc.close)
1296 (tty->ldisc.close)(tty);
1297 goto release_mem_out;
1299 tty_ldisc_enable(o_tty);
1301 tty_ldisc_enable(tty);
1305 * This fast open can be used if the tty is already open.
1306 * No memory is allocated, and the only failures are from
1307 * attempting to open a closing tty or attempting multiple
1308 * opens on a pty master.
1311 if (test_bit(TTY_CLOSING, &tty->flags)) {
1315 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1316 driver->subtype == PTY_TYPE_MASTER) {
1318 * special case for PTY masters: only one open permitted,
1319 * and the slave side open count is incremented as well.
1328 tty->driver = driver; /* N.B. why do this every time?? */
1331 if(!test_bit(TTY_LDISC, &tty->flags))
1332 printk(KERN_ERR "init_dev but no ldisc\n");
1336 /* All paths come through here to release the semaphore */
1341 /* Release locally allocated memory ... nothing placed in slots */
1346 free_tty_struct(o_tty);
1351 free_tty_struct(tty);
1354 module_put(driver->owner);
1358 /* call the tty release_mem routine to clean out this slot */
1360 printk(KERN_INFO "init_dev: ldisc open failed, "
1361 "clearing slot %d\n", idx);
1362 release_mem(tty, idx);
1367 * Releases memory associated with a tty structure, and clears out the
1368 * driver table slots.
1370 static void release_mem(struct tty_struct *tty, int idx)
1372 struct tty_struct *o_tty;
1374 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1376 if ((o_tty = tty->link) != NULL) {
1378 o_tty->driver->ttys[idx] = NULL;
1379 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1380 tp = o_tty->termios;
1382 o_tty->driver->termios[idx] = NULL;
1385 tp = o_tty->termios_locked;
1387 o_tty->driver->termios_locked[idx] = NULL;
1391 o_tty->driver->refcount--;
1393 list_del_init(&o_tty->tty_files);
1395 free_tty_struct(o_tty);
1399 tty->driver->ttys[idx] = NULL;
1400 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1403 tty->driver->termios[idx] = NULL;
1406 tp = tty->termios_locked;
1408 tty->driver->termios_locked[idx] = NULL;
1413 tty->driver->refcount--;
1415 list_del_init(&tty->tty_files);
1417 module_put(tty->driver->owner);
1418 free_tty_struct(tty);
1422 * Even releasing the tty structures is a tricky business.. We have
1423 * to be very careful that the structures are all released at the
1424 * same time, as interrupts might otherwise get the wrong pointers.
1426 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1427 * lead to double frees or releasing memory still in use.
1429 static void release_dev(struct file * filp)
1431 struct tty_struct *tty, *o_tty;
1432 int pty_master, tty_closing, o_tty_closing, do_sleep;
1433 int devpts_master, devpts;
1436 unsigned long flags;
1438 tty = (struct tty_struct *)filp->private_data;
1439 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1442 check_tty_count(tty, "release_dev");
1444 tty_fasync(-1, filp, 0);
1447 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1448 tty->driver->subtype == PTY_TYPE_MASTER);
1449 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1450 devpts_master = pty_master && devpts;
1453 #ifdef TTY_PARANOIA_CHECK
1454 if (idx < 0 || idx >= tty->driver->num) {
1455 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1456 "free (%s)\n", tty->name);
1459 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1460 if (tty != tty->driver->ttys[idx]) {
1461 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1462 "for (%s)\n", idx, tty->name);
1465 if (tty->termios != tty->driver->termios[idx]) {
1466 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1471 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1472 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1473 "termios_locked for (%s)\n",
1480 #ifdef TTY_DEBUG_HANGUP
1481 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1482 tty_name(tty, buf), tty->count);
1485 #ifdef TTY_PARANOIA_CHECK
1486 if (tty->driver->other &&
1487 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1488 if (o_tty != tty->driver->other->ttys[idx]) {
1489 printk(KERN_DEBUG "release_dev: other->table[%d] "
1490 "not o_tty for (%s)\n",
1494 if (o_tty->termios != tty->driver->other->termios[idx]) {
1495 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1496 "not o_termios for (%s)\n",
1500 if (o_tty->termios_locked !=
1501 tty->driver->other->termios_locked[idx]) {
1502 printk(KERN_DEBUG "release_dev: other->termios_locked["
1503 "%d] not o_termios_locked for (%s)\n",
1507 if (o_tty->link != tty) {
1508 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1513 if (tty->driver->close)
1514 tty->driver->close(tty, filp);
1517 * Sanity check: if tty->count is going to zero, there shouldn't be
1518 * any waiters on tty->read_wait or tty->write_wait. We test the
1519 * wait queues and kick everyone out _before_ actually starting to
1520 * close. This ensures that we won't block while releasing the tty
1523 * The test for the o_tty closing is necessary, since the master and
1524 * slave sides may close in any order. If the slave side closes out
1525 * first, its count will be one, since the master side holds an open.
1526 * Thus this test wouldn't be triggered at the time the slave closes,
1529 * Note that it's possible for the tty to be opened again while we're
1530 * flushing out waiters. By recalculating the closing flags before
1531 * each iteration we avoid any problems.
1534 tty_closing = tty->count <= 1;
1535 o_tty_closing = o_tty &&
1536 (o_tty->count <= (pty_master ? 1 : 0));
1540 if (waitqueue_active(&tty->read_wait)) {
1541 wake_up(&tty->read_wait);
1544 if (waitqueue_active(&tty->write_wait)) {
1545 wake_up(&tty->write_wait);
1549 if (o_tty_closing) {
1550 if (waitqueue_active(&o_tty->read_wait)) {
1551 wake_up(&o_tty->read_wait);
1554 if (waitqueue_active(&o_tty->write_wait)) {
1555 wake_up(&o_tty->write_wait);
1562 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1563 "active!\n", tty_name(tty, buf));
1568 * The closing flags are now consistent with the open counts on
1569 * both sides, and we've completed the last operation that could
1570 * block, so it's safe to proceed with closing.
1573 if (--o_tty->count < 0) {
1574 printk(KERN_WARNING "release_dev: bad pty slave count "
1576 o_tty->count, tty_name(o_tty, buf));
1580 if (--tty->count < 0) {
1581 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1582 tty->count, tty_name(tty, buf));
1587 * We've decremented tty->count, so we need to remove this file
1588 * descriptor off the tty->tty_files list; this serves two
1590 * - check_tty_count sees the correct number of file descriptors
1591 * associated with this tty.
1592 * - do_tty_hangup no longer sees this file descriptor as
1593 * something that needs to be handled for hangups.
1596 filp->private_data = NULL;
1599 * Perform some housekeeping before deciding whether to return.
1601 * Set the TTY_CLOSING flag if this was the last open. In the
1602 * case of a pty we may have to wait around for the other side
1603 * to close, and TTY_CLOSING makes sure we can't be reopened.
1606 set_bit(TTY_CLOSING, &tty->flags);
1608 set_bit(TTY_CLOSING, &o_tty->flags);
1611 * If _either_ side is closing, make sure there aren't any
1612 * processes that still think tty or o_tty is their controlling
1615 if (tty_closing || o_tty_closing) {
1616 struct task_struct *p;
1618 read_lock(&tasklist_lock);
1619 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1620 p->signal->tty = NULL;
1621 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1623 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1624 p->signal->tty = NULL;
1625 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1626 read_unlock(&tasklist_lock);
1629 /* check whether both sides are closing ... */
1630 if (!tty_closing || (o_tty && !o_tty_closing))
1633 #ifdef TTY_DEBUG_HANGUP
1634 printk(KERN_DEBUG "freeing tty structure...");
1637 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1638 * kill any delayed work. As this is the final close it does not
1639 * race with the set_ldisc code path.
1641 clear_bit(TTY_LDISC, &tty->flags);
1642 clear_bit(TTY_DONT_FLIP, &tty->flags);
1643 cancel_delayed_work(&tty->flip.work);
1646 * Wait for ->hangup_work and ->flip.work handlers to terminate
1649 flush_scheduled_work();
1652 * Wait for any short term users (we know they are just driver
1653 * side waiters as the file is closing so user count on the file
1656 spin_lock_irqsave(&tty_ldisc_lock, flags);
1657 while(tty->ldisc.refcount)
1659 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1660 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1661 spin_lock_irqsave(&tty_ldisc_lock, flags);
1663 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1665 * Shutdown the current line discipline, and reset it to N_TTY.
1666 * N.B. why reset ldisc when we're releasing the memory??
1668 * FIXME: this MUST get fixed for the new reflocking
1670 if (tty->ldisc.close)
1671 (tty->ldisc.close)(tty);
1672 tty_ldisc_put(tty->ldisc.num);
1675 * Switch the line discipline back
1677 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1678 tty_set_termios_ldisc(tty,N_TTY);
1680 /* FIXME: could o_tty be in setldisc here ? */
1681 clear_bit(TTY_LDISC, &o_tty->flags);
1682 if (o_tty->ldisc.close)
1683 (o_tty->ldisc.close)(o_tty);
1684 tty_ldisc_put(o_tty->ldisc.num);
1685 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1686 tty_set_termios_ldisc(o_tty,N_TTY);
1689 * The release_mem function takes care of the details of clearing
1690 * the slots and preserving the termios structure.
1692 release_mem(tty, idx);
1694 #ifdef CONFIG_UNIX98_PTYS
1695 /* Make this pty number available for reallocation */
1697 down(&allocated_ptys_lock);
1698 idr_remove(&allocated_ptys, idx);
1699 up(&allocated_ptys_lock);
1706 * tty_open and tty_release keep up the tty count that contains the
1707 * number of opens done on a tty. We cannot use the inode-count, as
1708 * different inodes might point to the same tty.
1710 * Open-counting is needed for pty masters, as well as for keeping
1711 * track of serial lines: DTR is dropped when the last close happens.
1712 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1714 * The termios state of a pty is reset on first open so that
1715 * settings don't persist across reuse.
1717 static int tty_open(struct inode * inode, struct file * filp)
1719 struct tty_struct *tty;
1721 struct tty_driver *driver;
1723 dev_t device = inode->i_rdev;
1724 unsigned short saved_flags = filp->f_flags;
1726 nonseekable_open(inode, filp);
1729 noctty = filp->f_flags & O_NOCTTY;
1733 if (device == MKDEV(TTYAUX_MAJOR,0)) {
1734 if (!current->signal->tty)
1736 driver = current->signal->tty->driver;
1737 index = current->signal->tty->index;
1738 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1743 if (device == MKDEV(TTY_MAJOR,0)) {
1744 extern int fg_console;
1745 extern struct tty_driver *console_driver;
1746 driver = console_driver;
1752 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1753 driver = console_device(&index);
1755 /* Don't let /dev/console block */
1756 filp->f_flags |= O_NONBLOCK;
1763 driver = get_tty_driver(device, &index);
1767 retval = init_dev(driver, index, &tty);
1771 filp->private_data = tty;
1772 file_move(filp, &tty->tty_files);
1773 check_tty_count(tty, "tty_open");
1774 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1775 tty->driver->subtype == PTY_TYPE_MASTER)
1777 #ifdef TTY_DEBUG_HANGUP
1778 printk(KERN_DEBUG "opening %s...", tty->name);
1781 if (tty->driver->open)
1782 retval = tty->driver->open(tty, filp);
1786 filp->f_flags = saved_flags;
1788 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1792 #ifdef TTY_DEBUG_HANGUP
1793 printk(KERN_DEBUG "error %d in opening %s...", retval,
1797 if (retval != -ERESTARTSYS)
1799 if (signal_pending(current))
1803 * Need to reset f_op in case a hangup happened.
1805 if (filp->f_op == &hung_up_tty_fops)
1806 filp->f_op = &tty_fops;
1810 current->signal->leader &&
1811 !current->signal->tty &&
1812 tty->session == 0) {
1814 current->signal->tty = tty;
1815 task_unlock(current);
1816 current->signal->tty_old_pgrp = 0;
1817 tty->session = current->signal->session;
1818 tty->pgrp = process_group(current);
1823 #ifdef CONFIG_UNIX98_PTYS
1824 static int ptmx_open(struct inode * inode, struct file * filp)
1826 struct tty_struct *tty;
1831 nonseekable_open(inode, filp);
1833 /* find a device that is not in use. */
1834 down(&allocated_ptys_lock);
1835 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1836 up(&allocated_ptys_lock);
1839 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1841 up(&allocated_ptys_lock);
1842 if (idr_ret == -EAGAIN)
1846 if (index >= pty_limit) {
1847 idr_remove(&allocated_ptys, index);
1848 up(&allocated_ptys_lock);
1851 up(&allocated_ptys_lock);
1853 retval = init_dev(ptm_driver, index, &tty);
1857 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1858 filp->private_data = tty;
1859 file_move(filp, &tty->tty_files);
1862 if (devpts_pty_new(tty->link))
1865 check_tty_count(tty, "tty_open");
1866 retval = ptm_driver->open(tty, filp);
1872 down(&allocated_ptys_lock);
1873 idr_remove(&allocated_ptys, index);
1874 up(&allocated_ptys_lock);
1879 static int tty_release(struct inode * inode, struct file * filp)
1887 /* No kernel lock held - fine */
1888 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1890 struct tty_struct * tty;
1891 struct tty_ldisc *ld;
1894 tty = (struct tty_struct *)filp->private_data;
1895 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1898 ld = tty_ldisc_ref_wait(tty);
1900 ret = (ld->poll)(tty, filp, wait);
1901 tty_ldisc_deref(ld);
1905 static int tty_fasync(int fd, struct file * filp, int on)
1907 struct tty_struct * tty;
1910 tty = (struct tty_struct *)filp->private_data;
1911 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1914 retval = fasync_helper(fd, filp, on, &tty->fasync);
1919 if (!waitqueue_active(&tty->read_wait))
1920 tty->minimum_to_wake = 1;
1921 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1925 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1926 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1931 static int tiocsti(struct tty_struct *tty, char __user *p)
1934 struct tty_ldisc *ld;
1936 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1938 if (get_user(ch, p))
1940 ld = tty_ldisc_ref_wait(tty);
1941 ld->receive_buf(tty, &ch, &mbz, 1);
1942 tty_ldisc_deref(ld);
1946 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
1948 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
1953 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
1954 struct winsize __user * arg)
1956 struct winsize tmp_ws;
1958 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
1960 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
1963 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
1964 unsigned int currcons = tty->index;
1967 acquire_console_sem();
1968 rc = vc_resize(currcons, tmp_ws.ws_col, tmp_ws.ws_row);
1969 release_console_sem();
1975 kill_pg(tty->pgrp, SIGWINCH, 1);
1976 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
1977 kill_pg(real_tty->pgrp, SIGWINCH, 1);
1978 tty->winsize = tmp_ws;
1979 real_tty->winsize = tmp_ws;
1983 static int tioccons(struct file *file)
1985 if (!capable(CAP_SYS_ADMIN))
1987 if (file->f_op->write == redirected_tty_write) {
1989 spin_lock(&redirect_lock);
1992 spin_unlock(&redirect_lock);
1997 spin_lock(&redirect_lock);
1999 spin_unlock(&redirect_lock);
2004 spin_unlock(&redirect_lock);
2009 static int fionbio(struct file *file, int __user *p)
2013 if (get_user(nonblock, p))
2017 file->f_flags |= O_NONBLOCK;
2019 file->f_flags &= ~O_NONBLOCK;
2023 static int tiocsctty(struct tty_struct *tty, int arg)
2027 if (current->signal->leader &&
2028 (current->signal->session == tty->session))
2031 * The process must be a session leader and
2032 * not have a controlling tty already.
2034 if (!current->signal->leader || current->signal->tty)
2036 if (tty->session > 0) {
2038 * This tty is already the controlling
2039 * tty for another session group!
2041 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2046 read_lock(&tasklist_lock);
2047 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2048 p->signal->tty = NULL;
2049 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2050 read_unlock(&tasklist_lock);
2055 current->signal->tty = tty;
2056 task_unlock(current);
2057 current->signal->tty_old_pgrp = 0;
2058 tty->session = current->signal->session;
2059 tty->pgrp = process_group(current);
2063 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2067 * (tty == real_tty) is a cheap way of
2068 * testing if the tty is NOT a master pty.
2070 if (tty == real_tty && current->signal->tty != real_tty)
2073 pgrp = vx_map_pid(real_tty->pgrp);
2074 return put_user(pgrp, p);
2077 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2080 int retval = tty_check_change(real_tty);
2086 if (!current->signal->tty ||
2087 (current->signal->tty != real_tty) ||
2088 (real_tty->session != current->signal->session))
2090 if (get_user(pgrp, p))
2093 pgrp = vx_rmap_pid(pgrp);
2096 if (session_of_pgrp(pgrp) != current->signal->session)
2098 real_tty->pgrp = pgrp;
2102 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2105 * (tty == real_tty) is a cheap way of
2106 * testing if the tty is NOT a master pty.
2108 if (tty == real_tty && current->signal->tty != real_tty)
2110 if (real_tty->session <= 0)
2112 return put_user(real_tty->session, p);
2115 static int tiocsetd(struct tty_struct *tty, int __user *p)
2119 if (get_user(ldisc, p))
2121 return tty_set_ldisc(tty, ldisc);
2124 static int send_break(struct tty_struct *tty, int duration)
2126 tty->driver->break_ctl(tty, -1);
2127 if (!signal_pending(current)) {
2128 set_current_state(TASK_INTERRUPTIBLE);
2129 schedule_timeout(duration);
2131 tty->driver->break_ctl(tty, 0);
2132 if (signal_pending(current))
2138 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2140 int retval = -EINVAL;
2142 if (tty->driver->tiocmget) {
2143 retval = tty->driver->tiocmget(tty, file);
2146 retval = put_user(retval, p);
2152 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2155 int retval = -EINVAL;
2157 if (tty->driver->tiocmset) {
2158 unsigned int set, clear, val;
2160 retval = get_user(val, p);
2178 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2179 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2181 retval = tty->driver->tiocmset(tty, file, set, clear);
2187 * Split this up, as gcc can choke on it otherwise..
2189 int tty_ioctl(struct inode * inode, struct file * file,
2190 unsigned int cmd, unsigned long arg)
2192 struct tty_struct *tty, *real_tty;
2193 void __user *p = (void __user *)arg;
2195 struct tty_ldisc *ld;
2197 tty = (struct tty_struct *)file->private_data;
2198 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2202 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2203 tty->driver->subtype == PTY_TYPE_MASTER)
2204 real_tty = tty->link;
2207 * Break handling by driver
2209 if (!tty->driver->break_ctl) {
2213 if (tty->driver->ioctl)
2214 return tty->driver->ioctl(tty, file, cmd, arg);
2217 /* These two ioctl's always return success; even if */
2218 /* the driver doesn't support them. */
2221 if (!tty->driver->ioctl)
2223 retval = tty->driver->ioctl(tty, file, cmd, arg);
2224 if (retval == -ENOIOCTLCMD)
2231 * Factor out some common prep work
2239 retval = tty_check_change(tty);
2242 if (cmd != TIOCCBRK) {
2243 tty_wait_until_sent(tty, 0);
2244 if (signal_pending(current))
2252 return tiocsti(tty, p);
2254 return tiocgwinsz(tty, p);
2256 return tiocswinsz(tty, real_tty, p);
2258 return real_tty!=tty ? -EINVAL : tioccons(file);
2260 return fionbio(file, p);
2262 set_bit(TTY_EXCLUSIVE, &tty->flags);
2265 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2268 if (current->signal->tty != tty)
2270 if (current->signal->leader)
2271 disassociate_ctty(0);
2273 current->signal->tty = NULL;
2274 task_unlock(current);
2277 return tiocsctty(tty, arg);
2279 return tiocgpgrp(tty, real_tty, p);
2281 return tiocspgrp(tty, real_tty, p);
2283 return tiocgsid(tty, real_tty, p);
2285 /* FIXME: check this is ok */
2286 return put_user(tty->ldisc.num, (int __user *)p);
2288 return tiocsetd(tty, p);
2291 return tioclinux(tty, arg);
2296 case TIOCSBRK: /* Turn break on, unconditionally */
2297 tty->driver->break_ctl(tty, -1);
2300 case TIOCCBRK: /* Turn break off, unconditionally */
2301 tty->driver->break_ctl(tty, 0);
2303 case TCSBRK: /* SVID version: non-zero arg --> no break */
2305 * XXX is the above comment correct, or the
2306 * code below correct? Is this ioctl used at
2310 return send_break(tty, HZ/4);
2312 case TCSBRKP: /* support for POSIX tcsendbreak() */
2313 return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
2316 return tty_tiocmget(tty, file, p);
2321 return tty_tiocmset(tty, file, cmd, p);
2323 if (tty->driver->ioctl) {
2324 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2325 if (retval != -ENOIOCTLCMD)
2328 ld = tty_ldisc_ref_wait(tty);
2331 retval = ld->ioctl(tty, file, cmd, arg);
2332 if (retval == -ENOIOCTLCMD)
2335 tty_ldisc_deref(ld);
2341 * This implements the "Secure Attention Key" --- the idea is to
2342 * prevent trojan horses by killing all processes associated with this
2343 * tty when the user hits the "Secure Attention Key". Required for
2344 * super-paranoid applications --- see the Orange Book for more details.
2346 * This code could be nicer; ideally it should send a HUP, wait a few
2347 * seconds, then send a INT, and then a KILL signal. But you then
2348 * have to coordinate with the init process, since all processes associated
2349 * with the current tty must be dead before the new getty is allowed
2352 * Now, if it would be correct ;-/ The current code has a nasty hole -
2353 * it doesn't catch files in flight. We may send the descriptor to ourselves
2354 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2356 * Nasty bug: do_SAK is being called in interrupt context. This can
2357 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2359 static void __do_SAK(void *arg)
2364 struct tty_struct *tty = arg;
2365 struct task_struct *p;
2369 struct tty_ldisc *disc;
2373 session = tty->session;
2375 /* We don't want an ldisc switch during this */
2376 disc = tty_ldisc_ref(tty);
2377 if (disc && disc->flush_buffer)
2378 disc->flush_buffer(tty);
2379 tty_ldisc_deref(disc);
2381 if (tty->driver->flush_buffer)
2382 tty->driver->flush_buffer(tty);
2384 read_lock(&tasklist_lock);
2385 do_each_task_pid(session, PIDTYPE_SID, p) {
2386 if (p->signal->tty == tty || session > 0) {
2387 printk(KERN_NOTICE "SAK: killed process %d"
2388 " (%s): p->signal->session==tty->session\n",
2390 send_sig(SIGKILL, p, 1);
2395 spin_lock(&p->files->file_lock);
2396 for (i=0; i < p->files->max_fds; i++) {
2397 filp = fcheck_files(p->files, i);
2400 if (filp->f_op->read == tty_read &&
2401 filp->private_data == tty) {
2402 printk(KERN_NOTICE "SAK: killed process %d"
2403 " (%s): fd#%d opened to the tty\n",
2404 p->pid, p->comm, i);
2405 send_sig(SIGKILL, p, 1);
2409 spin_unlock(&p->files->file_lock);
2412 } while_each_task_pid(session, PIDTYPE_SID, p);
2413 read_unlock(&tasklist_lock);
2418 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2419 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2420 * the values which we write to it will be identical to the values which it
2421 * already has. --akpm
2423 void do_SAK(struct tty_struct *tty)
2427 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2428 schedule_work(&tty->SAK_work);
2431 EXPORT_SYMBOL(do_SAK);
2434 * This routine is called out of the software interrupt to flush data
2435 * from the flip buffer to the line discipline.
2438 static void flush_to_ldisc(void *private_)
2440 struct tty_struct *tty = (struct tty_struct *) private_;
2444 unsigned long flags;
2445 struct tty_ldisc *disc;
2447 disc = tty_ldisc_ref(tty);
2448 if (disc == NULL) /* !TTY_LDISC */
2451 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2453 * Do it after the next timer tick:
2455 schedule_delayed_work(&tty->flip.work, 1);
2458 spin_lock_irqsave(&tty->read_lock, flags);
2459 if (tty->flip.buf_num) {
2460 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2461 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2462 tty->flip.buf_num = 0;
2463 tty->flip.char_buf_ptr = tty->flip.char_buf;
2464 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2466 cp = tty->flip.char_buf;
2467 fp = tty->flip.flag_buf;
2468 tty->flip.buf_num = 1;
2469 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2470 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2472 count = tty->flip.count;
2473 tty->flip.count = 0;
2474 spin_unlock_irqrestore(&tty->read_lock, flags);
2476 disc->receive_buf(tty, cp, fp, count);
2478 tty_ldisc_deref(disc);
2482 * Call the ldisc flush directly from a driver. This function may
2483 * return an error and need retrying by the user.
2486 int tty_push_data(struct tty_struct *tty, unsigned char *cp, unsigned char *fp, int count)
2489 struct tty_ldisc *disc;
2491 disc = tty_ldisc_ref(tty);
2492 if(test_bit(TTY_DONT_FLIP, &tty->flags))
2494 else if(disc == NULL)
2497 disc->receive_buf(tty, cp, fp, count);
2498 tty_ldisc_deref(disc);
2504 * Routine which returns the baud rate of the tty
2506 * Note that the baud_table needs to be kept in sync with the
2507 * include/asm/termbits.h file.
2509 static int baud_table[] = {
2510 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2511 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2513 76800, 153600, 307200, 614400, 921600
2515 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2516 2500000, 3000000, 3500000, 4000000
2520 static int n_baud_table = ARRAY_SIZE(baud_table);
2523 * tty_termios_baud_rate
2524 * @termios: termios structure
2526 * Convert termios baud rate data into a speed. This should be called
2527 * with the termios lock held if this termios is a terminal termios
2528 * structure. May change the termios data.
2531 int tty_termios_baud_rate(struct termios *termios)
2535 cbaud = termios->c_cflag & CBAUD;
2537 if (cbaud & CBAUDEX) {
2540 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2541 termios->c_cflag &= ~CBAUDEX;
2545 return baud_table[cbaud];
2548 EXPORT_SYMBOL(tty_termios_baud_rate);
2551 * tty_get_baud_rate - get tty bit rates
2552 * @tty: tty to query
2554 * Returns the baud rate as an integer for this terminal. The
2555 * termios lock must be held by the caller and the terminal bit
2556 * flags may be updated.
2559 int tty_get_baud_rate(struct tty_struct *tty)
2561 int baud = tty_termios_baud_rate(tty->termios);
2563 if (baud == 38400 && tty->alt_speed) {
2565 printk(KERN_WARNING "Use of setserial/setrocket to "
2566 "set SPD_* flags is deprecated\n");
2569 baud = tty->alt_speed;
2575 EXPORT_SYMBOL(tty_get_baud_rate);
2578 * tty_flip_buffer_push - terminal
2581 * Queue a push of the terminal flip buffers to the line discipline. This
2582 * function must not be called from IRQ context if tty->low_latency is set.
2584 * In the event of the queue being busy for flipping the work will be
2585 * held off and retried later.
2588 void tty_flip_buffer_push(struct tty_struct *tty)
2590 if (tty->low_latency)
2591 flush_to_ldisc((void *) tty);
2593 schedule_delayed_work(&tty->flip.work, 1);
2596 EXPORT_SYMBOL(tty_flip_buffer_push);
2599 * This subroutine initializes a tty structure.
2601 static void initialize_tty_struct(struct tty_struct *tty)
2603 memset(tty, 0, sizeof(struct tty_struct));
2604 tty->magic = TTY_MAGIC;
2605 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2607 tty->flip.char_buf_ptr = tty->flip.char_buf;
2608 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2609 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2610 init_MUTEX(&tty->flip.pty_sem);
2611 init_MUTEX(&tty->termios_sem);
2612 init_waitqueue_head(&tty->write_wait);
2613 init_waitqueue_head(&tty->read_wait);
2614 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2615 sema_init(&tty->atomic_read, 1);
2616 sema_init(&tty->atomic_write, 1);
2617 spin_lock_init(&tty->read_lock);
2618 INIT_LIST_HEAD(&tty->tty_files);
2619 INIT_WORK(&tty->SAK_work, NULL, NULL);
2623 * The default put_char routine if the driver did not define one.
2625 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2627 tty->driver->write(tty, 0, &ch, 1);
2630 static struct class_simple *tty_class;
2633 * tty_register_device - register a tty device
2634 * @driver: the tty driver that describes the tty device
2635 * @index: the index in the tty driver for this tty device
2636 * @device: a struct device that is associated with this tty device.
2637 * This field is optional, if there is no known struct device for this
2638 * tty device it can be set to NULL safely.
2640 * This call is required to be made to register an individual tty device if
2641 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2642 * bit is not set, this function should not be called.
2644 void tty_register_device(struct tty_driver *driver, unsigned index,
2645 struct device *device)
2648 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2650 if (index >= driver->num) {
2651 printk(KERN_ERR "Attempt to register invalid tty line number "
2656 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2657 "%s%d", driver->devfs_name, index + driver->name_base);
2659 if (driver->type == TTY_DRIVER_TYPE_PTY)
2660 pty_line_name(driver, index, name);
2662 tty_line_name(driver, index, name);
2663 class_simple_device_add(tty_class, dev, device, name);
2667 * tty_unregister_device - unregister a tty device
2668 * @driver: the tty driver that describes the tty device
2669 * @index: the index in the tty driver for this tty device
2671 * If a tty device is registered with a call to tty_register_device() then
2672 * this function must be made when the tty device is gone.
2674 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2676 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2677 class_simple_device_remove(MKDEV(driver->major, driver->minor_start) + index);
2680 EXPORT_SYMBOL(tty_register_device);
2681 EXPORT_SYMBOL(tty_unregister_device);
2683 struct tty_driver *alloc_tty_driver(int lines)
2685 struct tty_driver *driver;
2687 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2689 memset(driver, 0, sizeof(struct tty_driver));
2690 driver->magic = TTY_DRIVER_MAGIC;
2691 driver->num = lines;
2692 /* later we'll move allocation of tables here */
2697 void put_tty_driver(struct tty_driver *driver)
2702 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2704 driver->open = op->open;
2705 driver->close = op->close;
2706 driver->write = op->write;
2707 driver->put_char = op->put_char;
2708 driver->flush_chars = op->flush_chars;
2709 driver->write_room = op->write_room;
2710 driver->chars_in_buffer = op->chars_in_buffer;
2711 driver->ioctl = op->ioctl;
2712 driver->set_termios = op->set_termios;
2713 driver->throttle = op->throttle;
2714 driver->unthrottle = op->unthrottle;
2715 driver->stop = op->stop;
2716 driver->start = op->start;
2717 driver->hangup = op->hangup;
2718 driver->break_ctl = op->break_ctl;
2719 driver->flush_buffer = op->flush_buffer;
2720 driver->set_ldisc = op->set_ldisc;
2721 driver->wait_until_sent = op->wait_until_sent;
2722 driver->send_xchar = op->send_xchar;
2723 driver->read_proc = op->read_proc;
2724 driver->write_proc = op->write_proc;
2725 driver->tiocmget = op->tiocmget;
2726 driver->tiocmset = op->tiocmset;
2730 EXPORT_SYMBOL(alloc_tty_driver);
2731 EXPORT_SYMBOL(put_tty_driver);
2732 EXPORT_SYMBOL(tty_set_operations);
2735 * Called by a tty driver to register itself.
2737 int tty_register_driver(struct tty_driver *driver)
2744 if (driver->flags & TTY_DRIVER_INSTALLED)
2747 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2748 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2751 memset(p, 0, driver->num * 3 * sizeof(void *));
2754 if (!driver->major) {
2755 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2756 (char*)driver->name);
2758 driver->major = MAJOR(dev);
2759 driver->minor_start = MINOR(dev);
2762 dev = MKDEV(driver->major, driver->minor_start);
2763 error = register_chrdev_region(dev, driver->num,
2764 (char*)driver->name);
2772 driver->ttys = (struct tty_struct **)p;
2773 driver->termios = (struct termios **)(p + driver->num);
2774 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2776 driver->ttys = NULL;
2777 driver->termios = NULL;
2778 driver->termios_locked = NULL;
2781 cdev_init(&driver->cdev, &tty_fops);
2782 driver->cdev.owner = driver->owner;
2783 error = cdev_add(&driver->cdev, dev, driver->num);
2785 cdev_del(&driver->cdev);
2786 unregister_chrdev_region(dev, driver->num);
2787 driver->ttys = NULL;
2788 driver->termios = driver->termios_locked = NULL;
2793 if (!driver->put_char)
2794 driver->put_char = tty_default_put_char;
2796 list_add(&driver->tty_drivers, &tty_drivers);
2798 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2799 for(i = 0; i < driver->num; i++)
2800 tty_register_device(driver, i, NULL);
2802 proc_tty_register_driver(driver);
2806 EXPORT_SYMBOL(tty_register_driver);
2809 * Called by a tty driver to unregister itself.
2811 int tty_unregister_driver(struct tty_driver *driver)
2817 if (driver->refcount)
2820 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2823 list_del(&driver->tty_drivers);
2826 * Free the termios and termios_locked structures because
2827 * we don't want to get memory leaks when modular tty
2828 * drivers are removed from the kernel.
2830 for (i = 0; i < driver->num; i++) {
2831 tp = driver->termios[i];
2833 driver->termios[i] = NULL;
2836 tp = driver->termios_locked[i];
2838 driver->termios_locked[i] = NULL;
2841 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2842 tty_unregister_device(driver, i);
2845 proc_tty_unregister_driver(driver);
2846 driver->ttys = NULL;
2847 driver->termios = driver->termios_locked = NULL;
2849 cdev_del(&driver->cdev);
2853 EXPORT_SYMBOL(tty_unregister_driver);
2857 * Initialize the console device. This is called *early*, so
2858 * we can't necessarily depend on lots of kernel help here.
2859 * Just do some early initializations, and do the complex setup
2862 void __init console_init(void)
2866 /* Setup the default TTY line discipline. */
2867 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2870 * set up the console device so that later boot sequences can
2871 * inform about problems etc..
2873 #ifdef CONFIG_EARLY_PRINTK
2874 disable_early_printk();
2876 #ifdef CONFIG_SERIAL_68360
2877 /* This is not a console initcall. I know not what it's doing here.
2878 So I haven't moved it. dwmw2 */
2881 call = &__con_initcall_start;
2882 while (call < &__con_initcall_end) {
2889 extern int vty_init(void);
2892 static int __init tty_class_init(void)
2894 tty_class = class_simple_create(THIS_MODULE, "tty");
2895 if (IS_ERR(tty_class))
2896 return PTR_ERR(tty_class);
2900 postcore_initcall(tty_class_init);
2902 /* 3/2004 jmc: why do these devices exist? */
2904 static struct cdev tty_cdev, console_cdev;
2905 #ifdef CONFIG_UNIX98_PTYS
2906 static struct cdev ptmx_cdev;
2909 static struct cdev vc0_cdev;
2913 * Ok, now we can initialize the rest of the tty devices and can count
2914 * on memory allocations, interrupts etc..
2916 static int __init tty_init(void)
2918 cdev_init(&tty_cdev, &tty_fops);
2919 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2920 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2921 panic("Couldn't register /dev/tty driver\n");
2922 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2923 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2925 cdev_init(&console_cdev, &console_fops);
2926 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2927 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2928 panic("Couldn't register /dev/console driver\n");
2929 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2930 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2932 #ifdef CONFIG_UNIX98_PTYS
2933 cdev_init(&ptmx_cdev, &ptmx_fops);
2934 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2935 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2936 panic("Couldn't register /dev/ptmx driver\n");
2937 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2938 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2942 cdev_init(&vc0_cdev, &console_fops);
2943 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2944 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2945 panic("Couldn't register /dev/tty0 driver\n");
2946 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
2947 class_simple_device_add(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
2953 module_init(tty_init);