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>
97 #include <linux/delay.h>
99 #include <asm/uaccess.h>
100 #include <asm/system.h>
102 #include <linux/kbd_kern.h>
103 #include <linux/vt_kern.h>
104 #include <linux/selection.h>
105 #include <linux/devfs_fs_kernel.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 static void release_mem(struct tty_struct *tty, int idx);
159 static struct tty_struct *alloc_tty_struct(void)
161 struct tty_struct *tty;
163 tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
165 memset(tty, 0, sizeof(struct tty_struct));
169 static void tty_buffer_free_all(struct tty_struct *);
171 static inline void free_tty_struct(struct tty_struct *tty)
173 kfree(tty->write_buf);
174 tty_buffer_free_all(tty);
178 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
180 char *tty_name(struct tty_struct *tty, char *buf)
182 if (!tty) /* Hmm. NULL pointer. That's fun. */
183 strcpy(buf, "NULL tty");
185 strcpy(buf, tty->name);
189 EXPORT_SYMBOL(tty_name);
191 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
194 #ifdef TTY_PARANOIA_CHECK
197 "null TTY for (%d:%d) in %s\n",
198 imajor(inode), iminor(inode), routine);
201 if (tty->magic != TTY_MAGIC) {
203 "bad magic number for tty struct (%d:%d) in %s\n",
204 imajor(inode), iminor(inode), routine);
211 static int check_tty_count(struct tty_struct *tty, const char *routine)
213 #ifdef CHECK_TTY_COUNT
218 list_for_each(p, &tty->tty_files) {
222 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
223 tty->driver->subtype == PTY_TYPE_SLAVE &&
224 tty->link && tty->link->count)
226 if (tty->count != count) {
227 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
228 "!= #fd's(%d) in %s\n",
229 tty->name, tty->count, count, routine);
237 * Tty buffer allocation management
240 static void tty_buffer_free_all(struct tty_struct *tty)
242 struct tty_buffer *thead;
243 while((thead = tty->buf.head) != NULL) {
244 tty->buf.head = thead->next;
247 while((thead = tty->buf.free) != NULL) {
248 tty->buf.free = thead->next;
251 tty->buf.tail = NULL;
254 static void tty_buffer_init(struct tty_struct *tty)
256 tty->buf.head = NULL;
257 tty->buf.tail = NULL;
258 tty->buf.free = NULL;
261 static struct tty_buffer *tty_buffer_alloc(size_t size)
263 struct tty_buffer *p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
269 p->char_buf_ptr = (char *)(p->data);
270 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
271 /* printk("Flip create %p\n", p); */
275 /* Must be called with the tty_read lock held. This needs to acquire strategy
276 code to decide if we should kfree or relink a given expired buffer */
278 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
280 /* Dumb strategy for now - should keep some stats */
281 /* printk("Flip dispose %p\n", b); */
285 b->next = tty->buf.free;
290 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
292 struct tty_buffer **tbh = &tty->buf.free;
293 while((*tbh) != NULL) {
294 struct tty_buffer *t = *tbh;
295 if(t->size >= size) {
300 memset(t->data, '*', size);
301 /* printk("Flip recycle %p\n", t); */
304 tbh = &((*tbh)->next);
306 /* Round the buffer size out */
307 size = (size + 0xFF) & ~ 0xFF;
308 return tty_buffer_alloc(size);
309 /* Should possibly check if this fails for the largest buffer we
310 have queued and recycle that ? */
313 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
315 struct tty_buffer *b = tty->buf.head, *n;
318 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
319 remove this conditional if its worth it. This would be invisible
322 left = b->size - b->used;
325 /* This is the slow path - looking for new buffers to use */
326 n = tty_buffer_find(tty, size);
338 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
340 int tty_insert_flip_string(struct tty_struct *tty, unsigned char *chars, size_t size)
344 int space = tty_buffer_request_room(tty, size - copied);
345 struct tty_buffer *tb = tty->buf.tail;
346 /* If there is no space then tb may be NULL */
347 if(unlikely(space == 0))
349 memcpy(tb->char_buf_ptr + tb->used, chars, space);
350 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
354 /* printk("Flip insert %d.\n", space); */
356 /* There is a small chance that we need to split the data over
357 several buffers. If this is the case we must loop */
358 while (unlikely(size > copied));
362 EXPORT_SYMBOL_GPL(tty_insert_flip_string);
364 int tty_insert_flip_string_flags(struct tty_struct *tty, unsigned char *chars, char *flags, size_t size)
368 int space = tty_buffer_request_room(tty, size - copied);
369 struct tty_buffer *tb = tty->buf.tail;
370 /* If there is no space then tb may be NULL */
371 if(unlikely(space == 0))
373 memcpy(tb->char_buf_ptr + tb->used, chars, space);
374 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
380 /* There is a small chance that we need to split the data over
381 several buffers. If this is the case we must loop */
382 while (unlikely(size > copied));
386 EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags);
390 * Prepare a block of space in the buffer for data. Returns the length
391 * available and buffer pointer to the space which is now allocated and
392 * accounted for as ready for normal characters. This is used for drivers
393 * that need their own block copy routines into the buffer. There is no
394 * guarantee the buffer is a DMA target!
397 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
399 int space = tty_buffer_request_room(tty, size);
400 struct tty_buffer *tb = tty->buf.tail;
401 *chars = tb->char_buf_ptr + tb->used;
402 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
407 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
410 * Prepare a block of space in the buffer for data. Returns the length
411 * available and buffer pointer to the space which is now allocated and
412 * accounted for as ready for characters. This is used for drivers
413 * that need their own block copy routines into the buffer. There is no
414 * guarantee the buffer is a DMA target!
417 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
419 int space = tty_buffer_request_room(tty, size);
420 struct tty_buffer *tb = tty->buf.tail;
421 *chars = tb->char_buf_ptr + tb->used;
422 *flags = tb->flag_buf_ptr + tb->used;
427 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
432 * This is probably overkill for real world processors but
433 * they are not on hot paths so a little discipline won't do
437 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
439 down(&tty->termios_sem);
440 tty->termios->c_line = num;
441 up(&tty->termios_sem);
445 * This guards the refcounted line discipline lists. The lock
446 * must be taken with irqs off because there are hangup path
447 * callers who will do ldisc lookups and cannot sleep.
450 static DEFINE_SPINLOCK(tty_ldisc_lock);
451 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
452 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
454 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
459 if (disc < N_TTY || disc >= NR_LDISCS)
462 spin_lock_irqsave(&tty_ldisc_lock, flags);
463 tty_ldiscs[disc] = *new_ldisc;
464 tty_ldiscs[disc].num = disc;
465 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
466 tty_ldiscs[disc].refcount = 0;
467 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
471 EXPORT_SYMBOL(tty_register_ldisc);
473 int tty_unregister_ldisc(int disc)
478 if (disc < N_TTY || disc >= NR_LDISCS)
481 spin_lock_irqsave(&tty_ldisc_lock, flags);
482 if (tty_ldiscs[disc].refcount)
485 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
486 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
490 EXPORT_SYMBOL(tty_unregister_ldisc);
492 struct tty_ldisc *tty_ldisc_get(int disc)
495 struct tty_ldisc *ld;
497 if (disc < N_TTY || disc >= NR_LDISCS)
500 spin_lock_irqsave(&tty_ldisc_lock, flags);
502 ld = &tty_ldiscs[disc];
503 /* Check the entry is defined */
504 if(ld->flags & LDISC_FLAG_DEFINED)
506 /* If the module is being unloaded we can't use it */
507 if (!try_module_get(ld->owner))
514 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
518 EXPORT_SYMBOL_GPL(tty_ldisc_get);
520 void tty_ldisc_put(int disc)
522 struct tty_ldisc *ld;
525 if (disc < N_TTY || disc >= NR_LDISCS)
528 spin_lock_irqsave(&tty_ldisc_lock, flags);
529 ld = &tty_ldiscs[disc];
530 if(ld->refcount == 0)
533 module_put(ld->owner);
534 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
537 EXPORT_SYMBOL_GPL(tty_ldisc_put);
539 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
542 tty->ldisc.refcount = 0;
546 * tty_ldisc_try - internal helper
549 * Make a single attempt to grab and bump the refcount on
550 * the tty ldisc. Return 0 on failure or 1 on success. This is
551 * used to implement both the waiting and non waiting versions
555 static int tty_ldisc_try(struct tty_struct *tty)
558 struct tty_ldisc *ld;
561 spin_lock_irqsave(&tty_ldisc_lock, flags);
563 if(test_bit(TTY_LDISC, &tty->flags))
568 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
573 * tty_ldisc_ref_wait - wait for the tty ldisc
576 * Dereference the line discipline for the terminal and take a
577 * reference to it. If the line discipline is in flux then
578 * wait patiently until it changes.
580 * Note: Must not be called from an IRQ/timer context. The caller
581 * must also be careful not to hold other locks that will deadlock
582 * against a discipline change, such as an existing ldisc reference
583 * (which we check for)
586 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
588 /* wait_event is a macro */
589 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
590 if(tty->ldisc.refcount == 0)
591 printk(KERN_ERR "tty_ldisc_ref_wait\n");
595 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
598 * tty_ldisc_ref - get the tty ldisc
601 * Dereference the line discipline for the terminal and take a
602 * reference to it. If the line discipline is in flux then
603 * return NULL. Can be called from IRQ and timer functions.
606 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
608 if(tty_ldisc_try(tty))
613 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
616 * tty_ldisc_deref - free a tty ldisc reference
617 * @ld: reference to free up
619 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
620 * be called in IRQ context.
623 void tty_ldisc_deref(struct tty_ldisc *ld)
630 spin_lock_irqsave(&tty_ldisc_lock, flags);
631 if(ld->refcount == 0)
632 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
635 if(ld->refcount == 0)
636 wake_up(&tty_ldisc_wait);
637 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
640 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
643 * tty_ldisc_enable - allow ldisc use
644 * @tty: terminal to activate ldisc on
646 * Set the TTY_LDISC flag when the line discipline can be called
647 * again. Do neccessary wakeups for existing sleepers.
649 * Note: nobody should set this bit except via this function. Clearing
650 * directly is allowed.
653 static void tty_ldisc_enable(struct tty_struct *tty)
655 set_bit(TTY_LDISC, &tty->flags);
656 wake_up(&tty_ldisc_wait);
660 * tty_set_ldisc - set line discipline
661 * @tty: the terminal to set
662 * @ldisc: the line discipline
664 * Set the discipline of a tty line. Must be called from a process
668 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
671 struct tty_ldisc o_ldisc;
675 struct tty_ldisc *ld;
676 struct tty_struct *o_tty;
678 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
683 ld = tty_ldisc_get(ldisc);
684 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
685 /* Cyrus Durgin <cider@speakeasy.org> */
687 request_module("tty-ldisc-%d", ldisc);
688 ld = tty_ldisc_get(ldisc);
694 * No more input please, we are switching. The new ldisc
695 * will update this value in the ldisc open function
698 tty->receive_room = 0;
701 * Problem: What do we do if this blocks ?
704 tty_wait_until_sent(tty, 0);
706 if (tty->ldisc.num == ldisc) {
707 tty_ldisc_put(ldisc);
711 o_ldisc = tty->ldisc;
715 * Make sure we don't change while someone holds a
716 * reference to the line discipline. The TTY_LDISC bit
717 * prevents anyone taking a reference once it is clear.
718 * We need the lock to avoid racing reference takers.
721 spin_lock_irqsave(&tty_ldisc_lock, flags);
722 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
723 if(tty->ldisc.refcount) {
724 /* Free the new ldisc we grabbed. Must drop the lock
726 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
727 tty_ldisc_put(ldisc);
729 * There are several reasons we may be busy, including
730 * random momentary I/O traffic. We must therefore
731 * retry. We could distinguish between blocking ops
732 * and retries if we made tty_ldisc_wait() smarter. That
733 * is up for discussion.
735 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
739 if(o_tty && o_tty->ldisc.refcount) {
740 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
741 tty_ldisc_put(ldisc);
742 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
748 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
750 if (!test_bit(TTY_LDISC, &tty->flags)) {
751 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
752 tty_ldisc_put(ldisc);
753 ld = tty_ldisc_ref_wait(tty);
758 clear_bit(TTY_LDISC, &tty->flags);
759 clear_bit(TTY_DONT_FLIP, &tty->flags);
761 clear_bit(TTY_LDISC, &o_tty->flags);
762 clear_bit(TTY_DONT_FLIP, &o_tty->flags);
764 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
767 * From this point on we know nobody has an ldisc
768 * usage reference, nor can they obtain one until
769 * we say so later on.
772 work = cancel_delayed_work(&tty->buf.work);
774 * Wait for ->hangup_work and ->buf.work handlers to terminate
777 flush_scheduled_work();
778 /* Shutdown the current discipline. */
779 if (tty->ldisc.close)
780 (tty->ldisc.close)(tty);
782 /* Now set up the new line discipline. */
783 tty_ldisc_assign(tty, ld);
784 tty_set_termios_ldisc(tty, ldisc);
786 retval = (tty->ldisc.open)(tty);
788 tty_ldisc_put(ldisc);
789 /* There is an outstanding reference here so this is safe */
790 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
791 tty_set_termios_ldisc(tty, tty->ldisc.num);
792 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
793 tty_ldisc_put(o_ldisc.num);
794 /* This driver is always present */
795 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
796 tty_set_termios_ldisc(tty, N_TTY);
797 if (tty->ldisc.open) {
798 int r = tty->ldisc.open(tty);
801 panic("Couldn't open N_TTY ldisc for "
803 tty_name(tty, buf), r);
807 /* At this point we hold a reference to the new ldisc and a
808 a reference to the old ldisc. If we ended up flipping back
809 to the existing ldisc we have two references to it */
811 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
812 tty->driver->set_ldisc(tty);
814 tty_ldisc_put(o_ldisc.num);
817 * Allow ldisc referencing to occur as soon as the driver
818 * ldisc callback completes.
821 tty_ldisc_enable(tty);
823 tty_ldisc_enable(o_tty);
825 /* Restart it in case no characters kick it off. Safe if
828 schedule_delayed_work(&tty->buf.work, 1);
833 * This routine returns a tty driver structure, given a device number
835 static struct tty_driver *get_tty_driver(dev_t device, int *index)
837 struct tty_driver *p;
839 list_for_each_entry(p, &tty_drivers, tty_drivers) {
840 dev_t base = MKDEV(p->major, p->minor_start);
841 if (device < base || device >= base + p->num)
843 *index = device - base;
850 * If we try to write to, or set the state of, a terminal and we're
851 * not in the foreground, send a SIGTTOU. If the signal is blocked or
852 * ignored, go ahead and perform the operation. (POSIX 7.2)
854 int tty_check_change(struct tty_struct * tty)
856 if (current->signal->tty != tty)
858 if (tty->pgrp <= 0) {
859 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
862 if (process_group(current) == tty->pgrp)
864 if (is_ignored(SIGTTOU))
866 if (is_orphaned_pgrp(process_group(current)))
868 (void) kill_pg(process_group(current), SIGTTOU, 1);
872 EXPORT_SYMBOL(tty_check_change);
874 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
875 size_t count, loff_t *ppos)
880 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
881 size_t count, loff_t *ppos)
886 /* No kernel lock held - none needed ;) */
887 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
889 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
892 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
893 unsigned int cmd, unsigned long arg)
895 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
898 static struct file_operations tty_fops = {
905 .release = tty_release,
906 .fasync = tty_fasync,
909 #ifdef CONFIG_UNIX98_PTYS
910 static struct file_operations ptmx_fops = {
917 .release = tty_release,
918 .fasync = tty_fasync,
922 static struct file_operations console_fops = {
925 .write = redirected_tty_write,
929 .release = tty_release,
930 .fasync = tty_fasync,
933 static struct file_operations hung_up_tty_fops = {
935 .read = hung_up_tty_read,
936 .write = hung_up_tty_write,
937 .poll = hung_up_tty_poll,
938 .ioctl = hung_up_tty_ioctl,
939 .release = tty_release,
942 static DEFINE_SPINLOCK(redirect_lock);
943 static struct file *redirect;
946 * tty_wakeup - request more data
949 * Internal and external helper for wakeups of tty. This function
950 * informs the line discipline if present that the driver is ready
951 * to receive more output data.
954 void tty_wakeup(struct tty_struct *tty)
956 struct tty_ldisc *ld;
958 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
959 ld = tty_ldisc_ref(tty);
962 ld->write_wakeup(tty);
966 wake_up_interruptible(&tty->write_wait);
969 EXPORT_SYMBOL_GPL(tty_wakeup);
972 * tty_ldisc_flush - flush line discipline queue
975 * Flush the line discipline queue (if any) for this tty. If there
976 * is no line discipline active this is a no-op.
979 void tty_ldisc_flush(struct tty_struct *tty)
981 struct tty_ldisc *ld = tty_ldisc_ref(tty);
984 ld->flush_buffer(tty);
989 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
992 * This can be called by the "eventd" kernel thread. That is process synchronous,
993 * but doesn't hold any locks, so we need to make sure we have the appropriate
994 * locks for what we're doing..
996 static void do_tty_hangup(void *data)
998 struct tty_struct *tty = (struct tty_struct *) data;
999 struct file * cons_filp = NULL;
1000 struct file *filp, *f = NULL;
1001 struct task_struct *p;
1002 struct tty_ldisc *ld;
1003 int closecount = 0, n;
1008 /* inuse_filps is protected by the single kernel lock */
1011 spin_lock(&redirect_lock);
1012 if (redirect && redirect->private_data == tty) {
1016 spin_unlock(&redirect_lock);
1018 check_tty_count(tty, "do_tty_hangup");
1020 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1021 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1022 if (filp->f_op->write == redirected_tty_write)
1024 if (filp->f_op->write != tty_write)
1027 tty_fasync(-1, filp, 0); /* can't block */
1028 filp->f_op = &hung_up_tty_fops;
1032 /* FIXME! What are the locking issues here? This may me overdoing things..
1033 * this question is especially important now that we've removed the irqlock. */
1035 ld = tty_ldisc_ref(tty);
1036 if(ld != NULL) /* We may have no line discipline at this point */
1038 if (ld->flush_buffer)
1039 ld->flush_buffer(tty);
1040 if (tty->driver->flush_buffer)
1041 tty->driver->flush_buffer(tty);
1042 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1044 ld->write_wakeup(tty);
1049 /* FIXME: Once we trust the LDISC code better we can wait here for
1050 ldisc completion and fix the driver call race */
1052 wake_up_interruptible(&tty->write_wait);
1053 wake_up_interruptible(&tty->read_wait);
1056 * Shutdown the current line discipline, and reset it to
1059 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1061 down(&tty->termios_sem);
1062 *tty->termios = tty->driver->init_termios;
1063 up(&tty->termios_sem);
1066 /* Defer ldisc switch */
1067 /* tty_deferred_ldisc_switch(N_TTY);
1069 This should get done automatically when the port closes and
1070 tty_release is called */
1072 read_lock(&tasklist_lock);
1073 if (tty->session > 0) {
1074 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1075 if (p->signal->tty == tty)
1076 p->signal->tty = NULL;
1077 if (!p->signal->leader)
1079 send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1080 send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1082 p->signal->tty_old_pgrp = tty->pgrp;
1083 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1085 read_unlock(&tasklist_lock);
1090 tty->ctrl_status = 0;
1092 * If one of the devices matches a console pointer, we
1093 * cannot just call hangup() because that will cause
1094 * tty->count and state->count to go out of sync.
1095 * So we just call close() the right number of times.
1098 if (tty->driver->close)
1099 for (n = 0; n < closecount; n++)
1100 tty->driver->close(tty, cons_filp);
1101 } else if (tty->driver->hangup)
1102 (tty->driver->hangup)(tty);
1104 /* We don't want to have driver/ldisc interactions beyond
1105 the ones we did here. The driver layer expects no
1106 calls after ->hangup() from the ldisc side. However we
1107 can't yet guarantee all that */
1109 set_bit(TTY_HUPPED, &tty->flags);
1111 tty_ldisc_enable(tty);
1112 tty_ldisc_deref(ld);
1119 void tty_hangup(struct tty_struct * tty)
1121 #ifdef TTY_DEBUG_HANGUP
1124 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1126 schedule_work(&tty->hangup_work);
1129 EXPORT_SYMBOL(tty_hangup);
1131 void tty_vhangup(struct tty_struct * tty)
1133 #ifdef TTY_DEBUG_HANGUP
1136 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1138 do_tty_hangup((void *) tty);
1140 EXPORT_SYMBOL(tty_vhangup);
1142 int tty_hung_up_p(struct file * filp)
1144 return (filp->f_op == &hung_up_tty_fops);
1147 EXPORT_SYMBOL(tty_hung_up_p);
1150 * This function is typically called only by the session leader, when
1151 * it wants to disassociate itself from its controlling tty.
1153 * It performs the following functions:
1154 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1155 * (2) Clears the tty from being controlling the session
1156 * (3) Clears the controlling tty for all processes in the
1159 * The argument on_exit is set to 1 if called when a process is
1160 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1162 void disassociate_ctty(int on_exit)
1164 struct tty_struct *tty;
1165 struct task_struct *p;
1171 tty = current->signal->tty;
1173 tty_pgrp = tty->pgrp;
1175 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1178 if (current->signal->tty_old_pgrp) {
1179 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1180 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1187 kill_pg(tty_pgrp, SIGHUP, on_exit);
1189 kill_pg(tty_pgrp, SIGCONT, on_exit);
1192 /* Must lock changes to tty_old_pgrp */
1194 current->signal->tty_old_pgrp = 0;
1198 /* Now clear signal->tty under the lock */
1199 read_lock(&tasklist_lock);
1200 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1201 p->signal->tty = NULL;
1202 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1203 read_unlock(&tasklist_lock);
1208 void stop_tty(struct tty_struct *tty)
1213 if (tty->link && tty->link->packet) {
1214 tty->ctrl_status &= ~TIOCPKT_START;
1215 tty->ctrl_status |= TIOCPKT_STOP;
1216 wake_up_interruptible(&tty->link->read_wait);
1218 if (tty->driver->stop)
1219 (tty->driver->stop)(tty);
1222 EXPORT_SYMBOL(stop_tty);
1224 void start_tty(struct tty_struct *tty)
1226 if (!tty->stopped || tty->flow_stopped)
1229 if (tty->link && tty->link->packet) {
1230 tty->ctrl_status &= ~TIOCPKT_STOP;
1231 tty->ctrl_status |= TIOCPKT_START;
1232 wake_up_interruptible(&tty->link->read_wait);
1234 if (tty->driver->start)
1235 (tty->driver->start)(tty);
1237 /* If we have a running line discipline it may need kicking */
1239 wake_up_interruptible(&tty->write_wait);
1242 EXPORT_SYMBOL(start_tty);
1244 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1248 struct tty_struct * tty;
1249 struct inode *inode;
1250 struct tty_ldisc *ld;
1252 tty = (struct tty_struct *)file->private_data;
1253 inode = file->f_dentry->d_inode;
1254 if (tty_paranoia_check(tty, inode, "tty_read"))
1256 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1259 /* We want to wait for the line discipline to sort out in this
1261 ld = tty_ldisc_ref_wait(tty);
1264 i = (ld->read)(tty,file,buf,count);
1267 tty_ldisc_deref(ld);
1270 inode->i_atime = current_fs_time(inode->i_sb);
1275 * Split writes up in sane blocksizes to avoid
1276 * denial-of-service type attacks
1278 static inline ssize_t do_tty_write(
1279 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1280 struct tty_struct *tty,
1282 const char __user *buf,
1285 ssize_t ret = 0, written = 0;
1288 if (down_interruptible(&tty->atomic_write)) {
1289 return -ERESTARTSYS;
1293 * We chunk up writes into a temporary buffer. This
1294 * simplifies low-level drivers immensely, since they
1295 * don't have locking issues and user mode accesses.
1297 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1300 * The default chunk-size is 2kB, because the NTTY
1301 * layer has problems with bigger chunks. It will
1302 * claim to be able to handle more characters than
1306 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1311 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1312 if (tty->write_cnt < chunk) {
1318 buf = kmalloc(chunk, GFP_KERNEL);
1320 up(&tty->atomic_write);
1323 kfree(tty->write_buf);
1324 tty->write_cnt = chunk;
1325 tty->write_buf = buf;
1328 /* Do the write .. */
1330 size_t size = count;
1334 if (copy_from_user(tty->write_buf, buf, size))
1337 ret = write(tty, file, tty->write_buf, size);
1347 if (signal_pending(current))
1352 struct inode *inode = file->f_dentry->d_inode;
1353 inode->i_mtime = current_fs_time(inode->i_sb);
1356 up(&tty->atomic_write);
1361 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1364 struct tty_struct * tty;
1365 struct inode *inode = file->f_dentry->d_inode;
1367 struct tty_ldisc *ld;
1369 tty = (struct tty_struct *)file->private_data;
1370 if (tty_paranoia_check(tty, inode, "tty_write"))
1372 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1375 ld = tty_ldisc_ref_wait(tty);
1379 ret = do_tty_write(ld->write, tty, file, buf, count);
1380 tty_ldisc_deref(ld);
1384 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1387 struct file *p = NULL;
1389 spin_lock(&redirect_lock);
1394 spin_unlock(&redirect_lock);
1398 res = vfs_write(p, buf, count, &p->f_pos);
1403 return tty_write(file, buf, count, ppos);
1406 static char ptychar[] = "pqrstuvwxyzabcde";
1408 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1410 int i = index + driver->name_base;
1411 /* ->name is initialized to "ttyp", but "tty" is expected */
1412 sprintf(p, "%s%c%x",
1413 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1414 ptychar[i >> 4 & 0xf], i & 0xf);
1417 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1419 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1423 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1424 * failed open. The new code protects the open with a semaphore, so it's
1425 * really quite straightforward. The semaphore locking can probably be
1426 * relaxed for the (most common) case of reopening a tty.
1428 static int init_dev(struct tty_driver *driver, int idx,
1429 struct tty_struct **ret_tty)
1431 struct tty_struct *tty, *o_tty;
1432 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1433 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1436 /* check whether we're reopening an existing tty */
1437 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1438 tty = devpts_get_tty(idx);
1439 if (tty && driver->subtype == PTY_TYPE_MASTER)
1442 tty = driver->ttys[idx];
1444 if (tty) goto fast_track;
1447 * First time open is complex, especially for PTY devices.
1448 * This code guarantees that either everything succeeds and the
1449 * TTY is ready for operation, or else the table slots are vacated
1450 * and the allocated memory released. (Except that the termios
1451 * and locked termios may be retained.)
1454 if (!try_module_get(driver->owner)) {
1463 tty = alloc_tty_struct();
1466 initialize_tty_struct(tty);
1467 tty->driver = driver;
1469 tty_line_name(driver, idx, tty->name);
1471 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1472 tp_loc = &tty->termios;
1473 ltp_loc = &tty->termios_locked;
1475 tp_loc = &driver->termios[idx];
1476 ltp_loc = &driver->termios_locked[idx];
1480 tp = (struct termios *) kmalloc(sizeof(struct termios),
1484 *tp = driver->init_termios;
1488 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1492 memset(ltp, 0, sizeof(struct termios));
1495 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1496 o_tty = alloc_tty_struct();
1499 initialize_tty_struct(o_tty);
1500 o_tty->driver = driver->other;
1502 tty_line_name(driver->other, idx, o_tty->name);
1504 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1505 o_tp_loc = &o_tty->termios;
1506 o_ltp_loc = &o_tty->termios_locked;
1508 o_tp_loc = &driver->other->termios[idx];
1509 o_ltp_loc = &driver->other->termios_locked[idx];
1513 o_tp = (struct termios *)
1514 kmalloc(sizeof(struct termios), GFP_KERNEL);
1517 *o_tp = driver->other->init_termios;
1521 o_ltp = (struct termios *)
1522 kmalloc(sizeof(struct termios), GFP_KERNEL);
1525 memset(o_ltp, 0, sizeof(struct termios));
1529 * Everything allocated ... set up the o_tty structure.
1531 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1532 driver->other->ttys[idx] = o_tty;
1538 o_tty->termios = *o_tp_loc;
1539 o_tty->termios_locked = *o_ltp_loc;
1540 driver->other->refcount++;
1541 if (driver->subtype == PTY_TYPE_MASTER)
1544 /* Establish the links in both directions */
1550 * All structures have been allocated, so now we install them.
1551 * Failures after this point use release_mem to clean up, so
1552 * there's no need to null out the local pointers.
1554 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1555 driver->ttys[idx] = tty;
1562 tty->termios = *tp_loc;
1563 tty->termios_locked = *ltp_loc;
1568 * Structures all installed ... call the ldisc open routines.
1569 * If we fail here just call release_mem to clean up. No need
1570 * to decrement the use counts, as release_mem doesn't care.
1573 if (tty->ldisc.open) {
1574 retval = (tty->ldisc.open)(tty);
1576 goto release_mem_out;
1578 if (o_tty && o_tty->ldisc.open) {
1579 retval = (o_tty->ldisc.open)(o_tty);
1581 if (tty->ldisc.close)
1582 (tty->ldisc.close)(tty);
1583 goto release_mem_out;
1585 tty_ldisc_enable(o_tty);
1587 tty_ldisc_enable(tty);
1591 * This fast open can be used if the tty is already open.
1592 * No memory is allocated, and the only failures are from
1593 * attempting to open a closing tty or attempting multiple
1594 * opens on a pty master.
1597 if (test_bit(TTY_CLOSING, &tty->flags)) {
1601 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1602 driver->subtype == PTY_TYPE_MASTER) {
1604 * special case for PTY masters: only one open permitted,
1605 * and the slave side open count is incremented as well.
1614 tty->driver = driver; /* N.B. why do this every time?? */
1617 if(!test_bit(TTY_LDISC, &tty->flags))
1618 printk(KERN_ERR "init_dev but no ldisc\n");
1622 /* All paths come through here to release the semaphore */
1626 /* Release locally allocated memory ... nothing placed in slots */
1630 free_tty_struct(o_tty);
1633 free_tty_struct(tty);
1636 module_put(driver->owner);
1640 /* call the tty release_mem routine to clean out this slot */
1642 printk(KERN_INFO "init_dev: ldisc open failed, "
1643 "clearing slot %d\n", idx);
1644 release_mem(tty, idx);
1649 * Releases memory associated with a tty structure, and clears out the
1650 * driver table slots.
1652 static void release_mem(struct tty_struct *tty, int idx)
1654 struct tty_struct *o_tty;
1656 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1658 if ((o_tty = tty->link) != NULL) {
1660 o_tty->driver->ttys[idx] = NULL;
1661 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1662 tp = o_tty->termios;
1664 o_tty->driver->termios[idx] = NULL;
1667 tp = o_tty->termios_locked;
1669 o_tty->driver->termios_locked[idx] = NULL;
1673 o_tty->driver->refcount--;
1675 list_del_init(&o_tty->tty_files);
1677 free_tty_struct(o_tty);
1681 tty->driver->ttys[idx] = NULL;
1682 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1685 tty->driver->termios[idx] = NULL;
1688 tp = tty->termios_locked;
1690 tty->driver->termios_locked[idx] = NULL;
1695 tty->driver->refcount--;
1697 list_del_init(&tty->tty_files);
1699 module_put(tty->driver->owner);
1700 free_tty_struct(tty);
1704 * Even releasing the tty structures is a tricky business.. We have
1705 * to be very careful that the structures are all released at the
1706 * same time, as interrupts might otherwise get the wrong pointers.
1708 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1709 * lead to double frees or releasing memory still in use.
1711 static void release_dev(struct file * filp)
1713 struct tty_struct *tty, *o_tty;
1714 int pty_master, tty_closing, o_tty_closing, do_sleep;
1715 int devpts_master, devpts;
1718 unsigned long flags;
1720 tty = (struct tty_struct *)filp->private_data;
1721 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1724 check_tty_count(tty, "release_dev");
1726 tty_fasync(-1, filp, 0);
1729 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1730 tty->driver->subtype == PTY_TYPE_MASTER);
1731 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1732 devpts_master = pty_master && devpts;
1735 #ifdef TTY_PARANOIA_CHECK
1736 if (idx < 0 || idx >= tty->driver->num) {
1737 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1738 "free (%s)\n", tty->name);
1741 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1742 if (tty != tty->driver->ttys[idx]) {
1743 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1744 "for (%s)\n", idx, tty->name);
1747 if (tty->termios != tty->driver->termios[idx]) {
1748 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1753 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1754 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1755 "termios_locked for (%s)\n",
1762 #ifdef TTY_DEBUG_HANGUP
1763 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1764 tty_name(tty, buf), tty->count);
1767 #ifdef TTY_PARANOIA_CHECK
1768 if (tty->driver->other &&
1769 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1770 if (o_tty != tty->driver->other->ttys[idx]) {
1771 printk(KERN_DEBUG "release_dev: other->table[%d] "
1772 "not o_tty for (%s)\n",
1776 if (o_tty->termios != tty->driver->other->termios[idx]) {
1777 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1778 "not o_termios for (%s)\n",
1782 if (o_tty->termios_locked !=
1783 tty->driver->other->termios_locked[idx]) {
1784 printk(KERN_DEBUG "release_dev: other->termios_locked["
1785 "%d] not o_termios_locked for (%s)\n",
1789 if (o_tty->link != tty) {
1790 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1795 if (tty->driver->close)
1796 tty->driver->close(tty, filp);
1799 * Sanity check: if tty->count is going to zero, there shouldn't be
1800 * any waiters on tty->read_wait or tty->write_wait. We test the
1801 * wait queues and kick everyone out _before_ actually starting to
1802 * close. This ensures that we won't block while releasing the tty
1805 * The test for the o_tty closing is necessary, since the master and
1806 * slave sides may close in any order. If the slave side closes out
1807 * first, its count will be one, since the master side holds an open.
1808 * Thus this test wouldn't be triggered at the time the slave closes,
1811 * Note that it's possible for the tty to be opened again while we're
1812 * flushing out waiters. By recalculating the closing flags before
1813 * each iteration we avoid any problems.
1816 /* Guard against races with tty->count changes elsewhere and
1817 opens on /dev/tty */
1820 tty_closing = tty->count <= 1;
1821 o_tty_closing = o_tty &&
1822 (o_tty->count <= (pty_master ? 1 : 0));
1827 if (waitqueue_active(&tty->read_wait)) {
1828 wake_up(&tty->read_wait);
1831 if (waitqueue_active(&tty->write_wait)) {
1832 wake_up(&tty->write_wait);
1836 if (o_tty_closing) {
1837 if (waitqueue_active(&o_tty->read_wait)) {
1838 wake_up(&o_tty->read_wait);
1841 if (waitqueue_active(&o_tty->write_wait)) {
1842 wake_up(&o_tty->write_wait);
1849 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1850 "active!\n", tty_name(tty, buf));
1855 * The closing flags are now consistent with the open counts on
1856 * both sides, and we've completed the last operation that could
1857 * block, so it's safe to proceed with closing.
1862 if (--o_tty->count < 0) {
1863 printk(KERN_WARNING "release_dev: bad pty slave count "
1865 o_tty->count, tty_name(o_tty, buf));
1869 if (--tty->count < 0) {
1870 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1871 tty->count, tty_name(tty, buf));
1877 * We've decremented tty->count, so we need to remove this file
1878 * descriptor off the tty->tty_files list; this serves two
1880 * - check_tty_count sees the correct number of file descriptors
1881 * associated with this tty.
1882 * - do_tty_hangup no longer sees this file descriptor as
1883 * something that needs to be handled for hangups.
1886 filp->private_data = NULL;
1889 * Perform some housekeeping before deciding whether to return.
1891 * Set the TTY_CLOSING flag if this was the last open. In the
1892 * case of a pty we may have to wait around for the other side
1893 * to close, and TTY_CLOSING makes sure we can't be reopened.
1896 set_bit(TTY_CLOSING, &tty->flags);
1898 set_bit(TTY_CLOSING, &o_tty->flags);
1901 * If _either_ side is closing, make sure there aren't any
1902 * processes that still think tty or o_tty is their controlling
1905 if (tty_closing || o_tty_closing) {
1906 struct task_struct *p;
1908 read_lock(&tasklist_lock);
1909 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1910 p->signal->tty = NULL;
1911 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1913 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1914 p->signal->tty = NULL;
1915 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1916 read_unlock(&tasklist_lock);
1919 /* check whether both sides are closing ... */
1920 if (!tty_closing || (o_tty && !o_tty_closing))
1923 #ifdef TTY_DEBUG_HANGUP
1924 printk(KERN_DEBUG "freeing tty structure...");
1927 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1928 * kill any delayed work. As this is the final close it does not
1929 * race with the set_ldisc code path.
1931 clear_bit(TTY_LDISC, &tty->flags);
1932 clear_bit(TTY_DONT_FLIP, &tty->flags);
1933 cancel_delayed_work(&tty->buf.work);
1936 * Wait for ->hangup_work and ->buf.work handlers to terminate
1939 flush_scheduled_work();
1942 * Wait for any short term users (we know they are just driver
1943 * side waiters as the file is closing so user count on the file
1946 spin_lock_irqsave(&tty_ldisc_lock, flags);
1947 while(tty->ldisc.refcount)
1949 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1950 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1951 spin_lock_irqsave(&tty_ldisc_lock, flags);
1953 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1955 * Shutdown the current line discipline, and reset it to N_TTY.
1956 * N.B. why reset ldisc when we're releasing the memory??
1958 * FIXME: this MUST get fixed for the new reflocking
1960 if (tty->ldisc.close)
1961 (tty->ldisc.close)(tty);
1962 tty_ldisc_put(tty->ldisc.num);
1965 * Switch the line discipline back
1967 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1968 tty_set_termios_ldisc(tty,N_TTY);
1970 /* FIXME: could o_tty be in setldisc here ? */
1971 clear_bit(TTY_LDISC, &o_tty->flags);
1972 if (o_tty->ldisc.close)
1973 (o_tty->ldisc.close)(o_tty);
1974 tty_ldisc_put(o_tty->ldisc.num);
1975 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1976 tty_set_termios_ldisc(o_tty,N_TTY);
1979 * The release_mem function takes care of the details of clearing
1980 * the slots and preserving the termios structure.
1982 release_mem(tty, idx);
1984 #ifdef CONFIG_UNIX98_PTYS
1985 /* Make this pty number available for reallocation */
1987 down(&allocated_ptys_lock);
1988 idr_remove(&allocated_ptys, idx);
1989 up(&allocated_ptys_lock);
1996 * tty_open and tty_release keep up the tty count that contains the
1997 * number of opens done on a tty. We cannot use the inode-count, as
1998 * different inodes might point to the same tty.
2000 * Open-counting is needed for pty masters, as well as for keeping
2001 * track of serial lines: DTR is dropped when the last close happens.
2002 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2004 * The termios state of a pty is reset on first open so that
2005 * settings don't persist across reuse.
2007 static int tty_open(struct inode * inode, struct file * filp)
2009 struct tty_struct *tty;
2011 struct tty_driver *driver;
2013 dev_t device = inode->i_rdev;
2014 unsigned short saved_flags = filp->f_flags;
2016 nonseekable_open(inode, filp);
2019 noctty = filp->f_flags & O_NOCTTY;
2025 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2026 if (!current->signal->tty) {
2030 driver = current->signal->tty->driver;
2031 index = current->signal->tty->index;
2032 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2037 if (device == MKDEV(TTY_MAJOR,0)) {
2038 extern struct tty_driver *console_driver;
2039 driver = console_driver;
2045 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2046 driver = console_device(&index);
2048 /* Don't let /dev/console block */
2049 filp->f_flags |= O_NONBLOCK;
2057 driver = get_tty_driver(device, &index);
2063 retval = init_dev(driver, index, &tty);
2068 filp->private_data = tty;
2069 file_move(filp, &tty->tty_files);
2070 check_tty_count(tty, "tty_open");
2071 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2072 tty->driver->subtype == PTY_TYPE_MASTER)
2074 #ifdef TTY_DEBUG_HANGUP
2075 printk(KERN_DEBUG "opening %s...", tty->name);
2078 if (tty->driver->open)
2079 retval = tty->driver->open(tty, filp);
2083 filp->f_flags = saved_flags;
2085 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2089 #ifdef TTY_DEBUG_HANGUP
2090 printk(KERN_DEBUG "error %d in opening %s...", retval,
2094 if (retval != -ERESTARTSYS)
2096 if (signal_pending(current))
2100 * Need to reset f_op in case a hangup happened.
2102 if (filp->f_op == &hung_up_tty_fops)
2103 filp->f_op = &tty_fops;
2107 current->signal->leader &&
2108 !current->signal->tty &&
2109 tty->session == 0) {
2111 current->signal->tty = tty;
2112 task_unlock(current);
2113 current->signal->tty_old_pgrp = 0;
2114 tty->session = current->signal->session;
2115 tty->pgrp = process_group(current);
2120 #ifdef CONFIG_UNIX98_PTYS
2121 static int ptmx_open(struct inode * inode, struct file * filp)
2123 struct tty_struct *tty;
2128 nonseekable_open(inode, filp);
2130 /* find a device that is not in use. */
2131 down(&allocated_ptys_lock);
2132 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2133 up(&allocated_ptys_lock);
2136 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2138 up(&allocated_ptys_lock);
2139 if (idr_ret == -EAGAIN)
2143 if (index >= pty_limit) {
2144 idr_remove(&allocated_ptys, index);
2145 up(&allocated_ptys_lock);
2148 up(&allocated_ptys_lock);
2151 retval = init_dev(ptm_driver, index, &tty);
2157 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2158 filp->private_data = tty;
2159 file_move(filp, &tty->tty_files);
2162 if (devpts_pty_new(tty->link))
2165 check_tty_count(tty, "tty_open");
2166 retval = ptm_driver->open(tty, filp);
2172 down(&allocated_ptys_lock);
2173 idr_remove(&allocated_ptys, index);
2174 up(&allocated_ptys_lock);
2179 static int tty_release(struct inode * inode, struct file * filp)
2187 /* No kernel lock held - fine */
2188 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2190 struct tty_struct * tty;
2191 struct tty_ldisc *ld;
2194 tty = (struct tty_struct *)filp->private_data;
2195 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2198 ld = tty_ldisc_ref_wait(tty);
2200 ret = (ld->poll)(tty, filp, wait);
2201 tty_ldisc_deref(ld);
2205 static int tty_fasync(int fd, struct file * filp, int on)
2207 struct tty_struct * tty;
2210 tty = (struct tty_struct *)filp->private_data;
2211 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2214 retval = fasync_helper(fd, filp, on, &tty->fasync);
2219 if (!waitqueue_active(&tty->read_wait))
2220 tty->minimum_to_wake = 1;
2221 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2225 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2226 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2231 static int tiocsti(struct tty_struct *tty, char __user *p)
2234 struct tty_ldisc *ld;
2236 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2238 if (get_user(ch, p))
2240 ld = tty_ldisc_ref_wait(tty);
2241 ld->receive_buf(tty, &ch, &mbz, 1);
2242 tty_ldisc_deref(ld);
2246 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2248 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2253 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2254 struct winsize __user * arg)
2256 struct winsize tmp_ws;
2258 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2260 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2263 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2266 acquire_console_sem();
2267 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2268 release_console_sem();
2274 kill_pg(tty->pgrp, SIGWINCH, 1);
2275 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2276 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2277 tty->winsize = tmp_ws;
2278 real_tty->winsize = tmp_ws;
2282 static int tioccons(struct file *file)
2284 if (!capable(CAP_SYS_ADMIN))
2286 if (file->f_op->write == redirected_tty_write) {
2288 spin_lock(&redirect_lock);
2291 spin_unlock(&redirect_lock);
2296 spin_lock(&redirect_lock);
2298 spin_unlock(&redirect_lock);
2303 spin_unlock(&redirect_lock);
2308 static int fionbio(struct file *file, int __user *p)
2312 if (get_user(nonblock, p))
2316 file->f_flags |= O_NONBLOCK;
2318 file->f_flags &= ~O_NONBLOCK;
2322 static int tiocsctty(struct tty_struct *tty, int arg)
2326 if (current->signal->leader &&
2327 (current->signal->session == tty->session))
2330 * The process must be a session leader and
2331 * not have a controlling tty already.
2333 if (!current->signal->leader || current->signal->tty)
2335 if (tty->session > 0) {
2337 * This tty is already the controlling
2338 * tty for another session group!
2340 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2345 read_lock(&tasklist_lock);
2346 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2347 p->signal->tty = NULL;
2348 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2349 read_unlock(&tasklist_lock);
2354 current->signal->tty = tty;
2355 task_unlock(current);
2356 current->signal->tty_old_pgrp = 0;
2357 tty->session = current->signal->session;
2358 tty->pgrp = process_group(current);
2362 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2365 * (tty == real_tty) is a cheap way of
2366 * testing if the tty is NOT a master pty.
2368 if (tty == real_tty && current->signal->tty != real_tty)
2370 return put_user(real_tty->pgrp, p);
2373 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2376 int retval = tty_check_change(real_tty);
2382 if (!current->signal->tty ||
2383 (current->signal->tty != real_tty) ||
2384 (real_tty->session != current->signal->session))
2386 if (get_user(pgrp, p))
2390 if (session_of_pgrp(pgrp) != current->signal->session)
2392 real_tty->pgrp = pgrp;
2396 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2399 * (tty == real_tty) is a cheap way of
2400 * testing if the tty is NOT a master pty.
2402 if (tty == real_tty && current->signal->tty != real_tty)
2404 if (real_tty->session <= 0)
2406 return put_user(real_tty->session, p);
2409 static int tiocsetd(struct tty_struct *tty, int __user *p)
2413 if (get_user(ldisc, p))
2415 return tty_set_ldisc(tty, ldisc);
2418 static int send_break(struct tty_struct *tty, unsigned int duration)
2420 tty->driver->break_ctl(tty, -1);
2421 if (!signal_pending(current)) {
2422 msleep_interruptible(duration);
2424 tty->driver->break_ctl(tty, 0);
2425 if (signal_pending(current))
2431 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2433 int retval = -EINVAL;
2435 if (tty->driver->tiocmget) {
2436 retval = tty->driver->tiocmget(tty, file);
2439 retval = put_user(retval, p);
2445 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2448 int retval = -EINVAL;
2450 if (tty->driver->tiocmset) {
2451 unsigned int set, clear, val;
2453 retval = get_user(val, p);
2471 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2472 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2474 retval = tty->driver->tiocmset(tty, file, set, clear);
2480 * Split this up, as gcc can choke on it otherwise..
2482 int tty_ioctl(struct inode * inode, struct file * file,
2483 unsigned int cmd, unsigned long arg)
2485 struct tty_struct *tty, *real_tty;
2486 void __user *p = (void __user *)arg;
2488 struct tty_ldisc *ld;
2490 tty = (struct tty_struct *)file->private_data;
2491 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2495 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2496 tty->driver->subtype == PTY_TYPE_MASTER)
2497 real_tty = tty->link;
2500 * Break handling by driver
2502 if (!tty->driver->break_ctl) {
2506 if (tty->driver->ioctl)
2507 return tty->driver->ioctl(tty, file, cmd, arg);
2510 /* These two ioctl's always return success; even if */
2511 /* the driver doesn't support them. */
2514 if (!tty->driver->ioctl)
2516 retval = tty->driver->ioctl(tty, file, cmd, arg);
2517 if (retval == -ENOIOCTLCMD)
2524 * Factor out some common prep work
2532 retval = tty_check_change(tty);
2535 if (cmd != TIOCCBRK) {
2536 tty_wait_until_sent(tty, 0);
2537 if (signal_pending(current))
2545 return tiocsti(tty, p);
2547 return tiocgwinsz(tty, p);
2549 return tiocswinsz(tty, real_tty, p);
2551 return real_tty!=tty ? -EINVAL : tioccons(file);
2553 return fionbio(file, p);
2555 set_bit(TTY_EXCLUSIVE, &tty->flags);
2558 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2561 if (current->signal->tty != tty)
2563 if (current->signal->leader)
2564 disassociate_ctty(0);
2566 current->signal->tty = NULL;
2567 task_unlock(current);
2570 return tiocsctty(tty, arg);
2572 return tiocgpgrp(tty, real_tty, p);
2574 return tiocspgrp(tty, real_tty, p);
2576 return tiocgsid(tty, real_tty, p);
2578 /* FIXME: check this is ok */
2579 return put_user(tty->ldisc.num, (int __user *)p);
2581 return tiocsetd(tty, p);
2584 return tioclinux(tty, arg);
2589 case TIOCSBRK: /* Turn break on, unconditionally */
2590 tty->driver->break_ctl(tty, -1);
2593 case TIOCCBRK: /* Turn break off, unconditionally */
2594 tty->driver->break_ctl(tty, 0);
2596 case TCSBRK: /* SVID version: non-zero arg --> no break */
2598 * XXX is the above comment correct, or the
2599 * code below correct? Is this ioctl used at
2603 return send_break(tty, 250);
2605 case TCSBRKP: /* support for POSIX tcsendbreak() */
2606 return send_break(tty, arg ? arg*100 : 250);
2609 return tty_tiocmget(tty, file, p);
2614 return tty_tiocmset(tty, file, cmd, p);
2616 if (tty->driver->ioctl) {
2617 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2618 if (retval != -ENOIOCTLCMD)
2621 ld = tty_ldisc_ref_wait(tty);
2624 retval = ld->ioctl(tty, file, cmd, arg);
2625 if (retval == -ENOIOCTLCMD)
2628 tty_ldisc_deref(ld);
2634 * This implements the "Secure Attention Key" --- the idea is to
2635 * prevent trojan horses by killing all processes associated with this
2636 * tty when the user hits the "Secure Attention Key". Required for
2637 * super-paranoid applications --- see the Orange Book for more details.
2639 * This code could be nicer; ideally it should send a HUP, wait a few
2640 * seconds, then send a INT, and then a KILL signal. But you then
2641 * have to coordinate with the init process, since all processes associated
2642 * with the current tty must be dead before the new getty is allowed
2645 * Now, if it would be correct ;-/ The current code has a nasty hole -
2646 * it doesn't catch files in flight. We may send the descriptor to ourselves
2647 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2649 * Nasty bug: do_SAK is being called in interrupt context. This can
2650 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2652 static void __do_SAK(void *arg)
2657 struct tty_struct *tty = arg;
2658 struct task_struct *p;
2662 struct tty_ldisc *disc;
2663 struct fdtable *fdt;
2667 session = tty->session;
2669 /* We don't want an ldisc switch during this */
2670 disc = tty_ldisc_ref(tty);
2671 if (disc && disc->flush_buffer)
2672 disc->flush_buffer(tty);
2673 tty_ldisc_deref(disc);
2675 if (tty->driver->flush_buffer)
2676 tty->driver->flush_buffer(tty);
2678 read_lock(&tasklist_lock);
2679 do_each_task_pid(session, PIDTYPE_SID, p) {
2680 if (p->signal->tty == tty || session > 0) {
2681 printk(KERN_NOTICE "SAK: killed process %d"
2682 " (%s): p->signal->session==tty->session\n",
2684 send_sig(SIGKILL, p, 1);
2690 fdt = files_fdtable(p->files);
2691 for (i=0; i < fdt->max_fds; i++) {
2692 filp = fcheck_files(p->files, i);
2695 if (filp->f_op->read == tty_read &&
2696 filp->private_data == tty) {
2697 printk(KERN_NOTICE "SAK: killed process %d"
2698 " (%s): fd#%d opened to the tty\n",
2699 p->pid, p->comm, i);
2700 send_sig(SIGKILL, p, 1);
2707 } while_each_task_pid(session, PIDTYPE_SID, p);
2708 read_unlock(&tasklist_lock);
2713 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2714 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2715 * the values which we write to it will be identical to the values which it
2716 * already has. --akpm
2718 void do_SAK(struct tty_struct *tty)
2722 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2723 schedule_work(&tty->SAK_work);
2726 EXPORT_SYMBOL(do_SAK);
2729 * This routine is called out of the software interrupt to flush data
2730 * from the buffer chain to the line discipline.
2733 static void flush_to_ldisc(void *private_)
2735 struct tty_struct *tty = (struct tty_struct *) private_;
2736 unsigned long flags;
2737 struct tty_ldisc *disc;
2738 struct tty_buffer *tbuf;
2740 disc = tty_ldisc_ref(tty);
2741 if (disc == NULL) /* !TTY_LDISC */
2744 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2746 * Do it after the next timer tick:
2748 schedule_delayed_work(&tty->buf.work, 1);
2751 spin_lock_irqsave(&tty->read_lock, flags);
2752 while((tbuf = tty->buf.head) != NULL) {
2753 tty->buf.head = tbuf->next;
2754 spin_unlock_irqrestore(&tty->read_lock, flags);
2755 /* printk("Process buffer %p for %d\n", tbuf, tbuf->used); */
2756 disc->receive_buf(tty, tbuf->char_buf_ptr,
2759 spin_lock_irqsave(&tty->read_lock, flags);
2760 tty_buffer_free(tty, tbuf);
2762 tty->buf.tail = NULL;
2763 spin_unlock_irqrestore(&tty->read_lock, flags);
2765 tty_ldisc_deref(disc);
2769 * Routine which returns the baud rate of the tty
2771 * Note that the baud_table needs to be kept in sync with the
2772 * include/asm/termbits.h file.
2774 static int baud_table[] = {
2775 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2776 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2778 76800, 153600, 307200, 614400, 921600
2780 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2781 2500000, 3000000, 3500000, 4000000
2785 static int n_baud_table = ARRAY_SIZE(baud_table);
2788 * tty_termios_baud_rate
2789 * @termios: termios structure
2791 * Convert termios baud rate data into a speed. This should be called
2792 * with the termios lock held if this termios is a terminal termios
2793 * structure. May change the termios data.
2796 int tty_termios_baud_rate(struct termios *termios)
2800 cbaud = termios->c_cflag & CBAUD;
2802 if (cbaud & CBAUDEX) {
2805 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2806 termios->c_cflag &= ~CBAUDEX;
2810 return baud_table[cbaud];
2813 EXPORT_SYMBOL(tty_termios_baud_rate);
2816 * tty_get_baud_rate - get tty bit rates
2817 * @tty: tty to query
2819 * Returns the baud rate as an integer for this terminal. The
2820 * termios lock must be held by the caller and the terminal bit
2821 * flags may be updated.
2824 int tty_get_baud_rate(struct tty_struct *tty)
2826 int baud = tty_termios_baud_rate(tty->termios);
2828 if (baud == 38400 && tty->alt_speed) {
2830 printk(KERN_WARNING "Use of setserial/setrocket to "
2831 "set SPD_* flags is deprecated\n");
2834 baud = tty->alt_speed;
2840 EXPORT_SYMBOL(tty_get_baud_rate);
2843 * tty_flip_buffer_push - terminal
2846 * Queue a push of the terminal flip buffers to the line discipline. This
2847 * function must not be called from IRQ context if tty->low_latency is set.
2849 * In the event of the queue being busy for flipping the work will be
2850 * held off and retried later.
2853 void tty_flip_buffer_push(struct tty_struct *tty)
2855 if (tty->low_latency)
2856 flush_to_ldisc((void *) tty);
2858 schedule_delayed_work(&tty->buf.work, 1);
2861 EXPORT_SYMBOL(tty_flip_buffer_push);
2865 * This subroutine initializes a tty structure.
2867 static void initialize_tty_struct(struct tty_struct *tty)
2869 memset(tty, 0, sizeof(struct tty_struct));
2870 tty->magic = TTY_MAGIC;
2871 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2873 tty->overrun_time = jiffies;
2874 tty->buf.head = tty->buf.tail = NULL;
2875 tty_buffer_init(tty);
2876 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
2877 init_MUTEX(&tty->buf.pty_sem);
2878 init_MUTEX(&tty->termios_sem);
2879 init_waitqueue_head(&tty->write_wait);
2880 init_waitqueue_head(&tty->read_wait);
2881 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2882 sema_init(&tty->atomic_read, 1);
2883 sema_init(&tty->atomic_write, 1);
2884 spin_lock_init(&tty->read_lock);
2885 INIT_LIST_HEAD(&tty->tty_files);
2886 INIT_WORK(&tty->SAK_work, NULL, NULL);
2890 * The default put_char routine if the driver did not define one.
2892 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2894 tty->driver->write(tty, &ch, 1);
2897 static struct class *tty_class;
2900 * tty_register_device - register a tty device
2901 * @driver: the tty driver that describes the tty device
2902 * @index: the index in the tty driver for this tty device
2903 * @device: a struct device that is associated with this tty device.
2904 * This field is optional, if there is no known struct device for this
2905 * tty device it can be set to NULL safely.
2907 * This call is required to be made to register an individual tty device if
2908 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2909 * bit is not set, this function should not be called.
2911 void tty_register_device(struct tty_driver *driver, unsigned index,
2912 struct device *device)
2915 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2917 if (index >= driver->num) {
2918 printk(KERN_ERR "Attempt to register invalid tty line number "
2923 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2924 "%s%d", driver->devfs_name, index + driver->name_base);
2926 if (driver->type == TTY_DRIVER_TYPE_PTY)
2927 pty_line_name(driver, index, name);
2929 tty_line_name(driver, index, name);
2930 class_device_create(tty_class, NULL, dev, device, "%s", name);
2934 * tty_unregister_device - unregister a tty device
2935 * @driver: the tty driver that describes the tty device
2936 * @index: the index in the tty driver for this tty device
2938 * If a tty device is registered with a call to tty_register_device() then
2939 * this function must be made when the tty device is gone.
2941 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2943 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2944 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
2947 EXPORT_SYMBOL(tty_register_device);
2948 EXPORT_SYMBOL(tty_unregister_device);
2950 struct tty_driver *alloc_tty_driver(int lines)
2952 struct tty_driver *driver;
2954 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2956 memset(driver, 0, sizeof(struct tty_driver));
2957 driver->magic = TTY_DRIVER_MAGIC;
2958 driver->num = lines;
2959 /* later we'll move allocation of tables here */
2964 void put_tty_driver(struct tty_driver *driver)
2969 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2971 driver->open = op->open;
2972 driver->close = op->close;
2973 driver->write = op->write;
2974 driver->put_char = op->put_char;
2975 driver->flush_chars = op->flush_chars;
2976 driver->write_room = op->write_room;
2977 driver->chars_in_buffer = op->chars_in_buffer;
2978 driver->ioctl = op->ioctl;
2979 driver->set_termios = op->set_termios;
2980 driver->throttle = op->throttle;
2981 driver->unthrottle = op->unthrottle;
2982 driver->stop = op->stop;
2983 driver->start = op->start;
2984 driver->hangup = op->hangup;
2985 driver->break_ctl = op->break_ctl;
2986 driver->flush_buffer = op->flush_buffer;
2987 driver->set_ldisc = op->set_ldisc;
2988 driver->wait_until_sent = op->wait_until_sent;
2989 driver->send_xchar = op->send_xchar;
2990 driver->read_proc = op->read_proc;
2991 driver->write_proc = op->write_proc;
2992 driver->tiocmget = op->tiocmget;
2993 driver->tiocmset = op->tiocmset;
2997 EXPORT_SYMBOL(alloc_tty_driver);
2998 EXPORT_SYMBOL(put_tty_driver);
2999 EXPORT_SYMBOL(tty_set_operations);
3002 * Called by a tty driver to register itself.
3004 int tty_register_driver(struct tty_driver *driver)
3011 if (driver->flags & TTY_DRIVER_INSTALLED)
3014 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3015 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3018 memset(p, 0, driver->num * 3 * sizeof(void *));
3021 if (!driver->major) {
3022 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3023 (char*)driver->name);
3025 driver->major = MAJOR(dev);
3026 driver->minor_start = MINOR(dev);
3029 dev = MKDEV(driver->major, driver->minor_start);
3030 error = register_chrdev_region(dev, driver->num,
3031 (char*)driver->name);
3039 driver->ttys = (struct tty_struct **)p;
3040 driver->termios = (struct termios **)(p + driver->num);
3041 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3043 driver->ttys = NULL;
3044 driver->termios = NULL;
3045 driver->termios_locked = NULL;
3048 cdev_init(&driver->cdev, &tty_fops);
3049 driver->cdev.owner = driver->owner;
3050 error = cdev_add(&driver->cdev, dev, driver->num);
3052 cdev_del(&driver->cdev);
3053 unregister_chrdev_region(dev, driver->num);
3054 driver->ttys = NULL;
3055 driver->termios = driver->termios_locked = NULL;
3060 if (!driver->put_char)
3061 driver->put_char = tty_default_put_char;
3063 list_add(&driver->tty_drivers, &tty_drivers);
3065 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
3066 for(i = 0; i < driver->num; i++)
3067 tty_register_device(driver, i, NULL);
3069 proc_tty_register_driver(driver);
3073 EXPORT_SYMBOL(tty_register_driver);
3076 * Called by a tty driver to unregister itself.
3078 int tty_unregister_driver(struct tty_driver *driver)
3084 if (driver->refcount)
3087 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3090 list_del(&driver->tty_drivers);
3093 * Free the termios and termios_locked structures because
3094 * we don't want to get memory leaks when modular tty
3095 * drivers are removed from the kernel.
3097 for (i = 0; i < driver->num; i++) {
3098 tp = driver->termios[i];
3100 driver->termios[i] = NULL;
3103 tp = driver->termios_locked[i];
3105 driver->termios_locked[i] = NULL;
3108 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
3109 tty_unregister_device(driver, i);
3112 proc_tty_unregister_driver(driver);
3113 driver->ttys = NULL;
3114 driver->termios = driver->termios_locked = NULL;
3116 cdev_del(&driver->cdev);
3120 EXPORT_SYMBOL(tty_unregister_driver);
3124 * Initialize the console device. This is called *early*, so
3125 * we can't necessarily depend on lots of kernel help here.
3126 * Just do some early initializations, and do the complex setup
3129 void __init console_init(void)
3133 /* Setup the default TTY line discipline. */
3134 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3137 * set up the console device so that later boot sequences can
3138 * inform about problems etc..
3140 #ifdef CONFIG_EARLY_PRINTK
3141 disable_early_printk();
3143 call = __con_initcall_start;
3144 while (call < __con_initcall_end) {
3151 extern int vty_init(void);
3154 static int __init tty_class_init(void)
3156 tty_class = class_create(THIS_MODULE, "tty");
3157 if (IS_ERR(tty_class))
3158 return PTR_ERR(tty_class);
3162 postcore_initcall(tty_class_init);
3164 /* 3/2004 jmc: why do these devices exist? */
3166 static struct cdev tty_cdev, console_cdev;
3167 #ifdef CONFIG_UNIX98_PTYS
3168 static struct cdev ptmx_cdev;
3171 static struct cdev vc0_cdev;
3175 * Ok, now we can initialize the rest of the tty devices and can count
3176 * on memory allocations, interrupts etc..
3178 static int __init tty_init(void)
3180 cdev_init(&tty_cdev, &tty_fops);
3181 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3182 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3183 panic("Couldn't register /dev/tty driver\n");
3184 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
3185 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3187 cdev_init(&console_cdev, &console_fops);
3188 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3189 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3190 panic("Couldn't register /dev/console driver\n");
3191 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
3192 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3194 #ifdef CONFIG_UNIX98_PTYS
3195 cdev_init(&ptmx_cdev, &ptmx_fops);
3196 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3197 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3198 panic("Couldn't register /dev/ptmx driver\n");
3199 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
3200 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3204 cdev_init(&vc0_cdev, &console_fops);
3205 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3206 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3207 panic("Couldn't register /dev/tty0 driver\n");
3208 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3209 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3215 module_init(tty_init);