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 DEFINE_MUTEX(tty_mutex);
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 spin_lock_init(&tty->buf.lock);
257 tty->buf.head = NULL;
258 tty->buf.tail = NULL;
259 tty->buf.free = NULL;
262 static struct tty_buffer *tty_buffer_alloc(size_t size)
264 struct tty_buffer *p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
273 p->char_buf_ptr = (char *)(p->data);
274 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
275 /* printk("Flip create %p\n", p); */
279 /* Must be called with the tty_read lock held. This needs to acquire strategy
280 code to decide if we should kfree or relink a given expired buffer */
282 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
284 /* Dumb strategy for now - should keep some stats */
285 /* printk("Flip dispose %p\n", b); */
289 b->next = tty->buf.free;
294 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
296 struct tty_buffer **tbh = &tty->buf.free;
297 while((*tbh) != NULL) {
298 struct tty_buffer *t = *tbh;
299 if(t->size >= size) {
306 /* memset(t->data, '*', size); */
307 /* printk("Flip recycle %p\n", t); */
310 tbh = &((*tbh)->next);
312 /* Round the buffer size out */
313 size = (size + 0xFF) & ~ 0xFF;
314 return tty_buffer_alloc(size);
315 /* Should possibly check if this fails for the largest buffer we
316 have queued and recycle that ? */
319 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
321 struct tty_buffer *b, *n;
325 spin_lock_irqsave(&tty->buf.lock, flags);
327 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
328 remove this conditional if its worth it. This would be invisible
330 if ((b = tty->buf.tail) != NULL) {
331 left = b->size - b->used;
337 /* This is the slow path - looking for new buffers to use */
338 if ((n = tty_buffer_find(tty, size)) != NULL) {
351 spin_unlock_irqrestore(&tty->buf.lock, flags);
354 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
356 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
361 int space = tty_buffer_request_room(tty, size - copied);
362 struct tty_buffer *tb = tty->buf.tail;
363 /* If there is no space then tb may be NULL */
364 if(unlikely(space == 0))
366 memcpy(tb->char_buf_ptr + tb->used, chars, space);
367 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
372 /* There is a small chance that we need to split the data over
373 several buffers. If this is the case we must loop */
374 while (unlikely(size > copied));
377 EXPORT_SYMBOL(tty_insert_flip_string);
379 int tty_insert_flip_string_flags(struct tty_struct *tty,
380 const unsigned char *chars, const char *flags, size_t size)
384 int space = tty_buffer_request_room(tty, size - copied);
385 struct tty_buffer *tb = tty->buf.tail;
386 /* If there is no space then tb may be NULL */
387 if(unlikely(space == 0))
389 memcpy(tb->char_buf_ptr + tb->used, chars, space);
390 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
396 /* There is a small chance that we need to split the data over
397 several buffers. If this is the case we must loop */
398 while (unlikely(size > copied));
401 EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags);
403 void tty_schedule_flip(struct tty_struct *tty)
406 spin_lock_irqsave(&tty->buf.lock, flags);
407 if (tty->buf.tail != NULL) {
408 tty->buf.tail->active = 0;
409 tty->buf.tail->commit = tty->buf.tail->used;
411 spin_unlock_irqrestore(&tty->buf.lock, flags);
412 schedule_delayed_work(&tty->buf.work, 1);
414 EXPORT_SYMBOL(tty_schedule_flip);
417 * Prepare a block of space in the buffer for data. Returns the length
418 * available and buffer pointer to the space which is now allocated and
419 * accounted for as ready for normal characters. This is used for drivers
420 * that need their own block copy routines into the buffer. There is no
421 * guarantee the buffer is a DMA target!
424 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
426 int space = tty_buffer_request_room(tty, size);
428 struct tty_buffer *tb = tty->buf.tail;
429 *chars = tb->char_buf_ptr + tb->used;
430 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
436 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
439 * Prepare a block of space in the buffer for data. Returns the length
440 * available and buffer pointer to the space which is now allocated and
441 * accounted for as ready for characters. This is used for drivers
442 * that need their own block copy routines into the buffer. There is no
443 * guarantee the buffer is a DMA target!
446 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
448 int space = tty_buffer_request_room(tty, size);
450 struct tty_buffer *tb = tty->buf.tail;
451 *chars = tb->char_buf_ptr + tb->used;
452 *flags = tb->flag_buf_ptr + tb->used;
458 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
463 * This is probably overkill for real world processors but
464 * they are not on hot paths so a little discipline won't do
468 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
470 down(&tty->termios_sem);
471 tty->termios->c_line = num;
472 up(&tty->termios_sem);
476 * This guards the refcounted line discipline lists. The lock
477 * must be taken with irqs off because there are hangup path
478 * callers who will do ldisc lookups and cannot sleep.
481 static DEFINE_SPINLOCK(tty_ldisc_lock);
482 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
483 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
485 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
490 if (disc < N_TTY || disc >= NR_LDISCS)
493 spin_lock_irqsave(&tty_ldisc_lock, flags);
494 tty_ldiscs[disc] = *new_ldisc;
495 tty_ldiscs[disc].num = disc;
496 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
497 tty_ldiscs[disc].refcount = 0;
498 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
502 EXPORT_SYMBOL(tty_register_ldisc);
504 int tty_unregister_ldisc(int disc)
509 if (disc < N_TTY || disc >= NR_LDISCS)
512 spin_lock_irqsave(&tty_ldisc_lock, flags);
513 if (tty_ldiscs[disc].refcount)
516 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
517 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
521 EXPORT_SYMBOL(tty_unregister_ldisc);
523 struct tty_ldisc *tty_ldisc_get(int disc)
526 struct tty_ldisc *ld;
528 if (disc < N_TTY || disc >= NR_LDISCS)
531 spin_lock_irqsave(&tty_ldisc_lock, flags);
533 ld = &tty_ldiscs[disc];
534 /* Check the entry is defined */
535 if(ld->flags & LDISC_FLAG_DEFINED)
537 /* If the module is being unloaded we can't use it */
538 if (!try_module_get(ld->owner))
545 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
549 EXPORT_SYMBOL_GPL(tty_ldisc_get);
551 void tty_ldisc_put(int disc)
553 struct tty_ldisc *ld;
556 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
558 spin_lock_irqsave(&tty_ldisc_lock, flags);
559 ld = &tty_ldiscs[disc];
560 BUG_ON(ld->refcount == 0);
562 module_put(ld->owner);
563 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
566 EXPORT_SYMBOL_GPL(tty_ldisc_put);
568 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
571 tty->ldisc.refcount = 0;
575 * tty_ldisc_try - internal helper
578 * Make a single attempt to grab and bump the refcount on
579 * the tty ldisc. Return 0 on failure or 1 on success. This is
580 * used to implement both the waiting and non waiting versions
584 static int tty_ldisc_try(struct tty_struct *tty)
587 struct tty_ldisc *ld;
590 spin_lock_irqsave(&tty_ldisc_lock, flags);
592 if(test_bit(TTY_LDISC, &tty->flags))
597 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
602 * tty_ldisc_ref_wait - wait for the tty ldisc
605 * Dereference the line discipline for the terminal and take a
606 * reference to it. If the line discipline is in flux then
607 * wait patiently until it changes.
609 * Note: Must not be called from an IRQ/timer context. The caller
610 * must also be careful not to hold other locks that will deadlock
611 * against a discipline change, such as an existing ldisc reference
612 * (which we check for)
615 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
617 /* wait_event is a macro */
618 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
619 if(tty->ldisc.refcount == 0)
620 printk(KERN_ERR "tty_ldisc_ref_wait\n");
624 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
627 * tty_ldisc_ref - get the tty ldisc
630 * Dereference the line discipline for the terminal and take a
631 * reference to it. If the line discipline is in flux then
632 * return NULL. Can be called from IRQ and timer functions.
635 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
637 if(tty_ldisc_try(tty))
642 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
645 * tty_ldisc_deref - free a tty ldisc reference
646 * @ld: reference to free up
648 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
649 * be called in IRQ context.
652 void tty_ldisc_deref(struct tty_ldisc *ld)
658 spin_lock_irqsave(&tty_ldisc_lock, flags);
659 if(ld->refcount == 0)
660 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
663 if(ld->refcount == 0)
664 wake_up(&tty_ldisc_wait);
665 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
668 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
671 * tty_ldisc_enable - allow ldisc use
672 * @tty: terminal to activate ldisc on
674 * Set the TTY_LDISC flag when the line discipline can be called
675 * again. Do neccessary wakeups for existing sleepers.
677 * Note: nobody should set this bit except via this function. Clearing
678 * directly is allowed.
681 static void tty_ldisc_enable(struct tty_struct *tty)
683 set_bit(TTY_LDISC, &tty->flags);
684 wake_up(&tty_ldisc_wait);
688 * tty_set_ldisc - set line discipline
689 * @tty: the terminal to set
690 * @ldisc: the line discipline
692 * Set the discipline of a tty line. Must be called from a process
696 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
699 struct tty_ldisc o_ldisc;
703 struct tty_ldisc *ld;
704 struct tty_struct *o_tty;
706 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
711 ld = tty_ldisc_get(ldisc);
712 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
713 /* Cyrus Durgin <cider@speakeasy.org> */
715 request_module("tty-ldisc-%d", ldisc);
716 ld = tty_ldisc_get(ldisc);
722 * No more input please, we are switching. The new ldisc
723 * will update this value in the ldisc open function
726 tty->receive_room = 0;
729 * Problem: What do we do if this blocks ?
732 tty_wait_until_sent(tty, 0);
734 if (tty->ldisc.num == ldisc) {
735 tty_ldisc_put(ldisc);
739 o_ldisc = tty->ldisc;
743 * Make sure we don't change while someone holds a
744 * reference to the line discipline. The TTY_LDISC bit
745 * prevents anyone taking a reference once it is clear.
746 * We need the lock to avoid racing reference takers.
749 spin_lock_irqsave(&tty_ldisc_lock, flags);
750 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
751 if(tty->ldisc.refcount) {
752 /* Free the new ldisc we grabbed. Must drop the lock
754 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
755 tty_ldisc_put(ldisc);
757 * There are several reasons we may be busy, including
758 * random momentary I/O traffic. We must therefore
759 * retry. We could distinguish between blocking ops
760 * and retries if we made tty_ldisc_wait() smarter. That
761 * is up for discussion.
763 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
767 if(o_tty && o_tty->ldisc.refcount) {
768 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
769 tty_ldisc_put(ldisc);
770 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
776 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
778 if (!test_bit(TTY_LDISC, &tty->flags)) {
779 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
780 tty_ldisc_put(ldisc);
781 ld = tty_ldisc_ref_wait(tty);
786 clear_bit(TTY_LDISC, &tty->flags);
787 clear_bit(TTY_DONT_FLIP, &tty->flags);
789 clear_bit(TTY_LDISC, &o_tty->flags);
790 clear_bit(TTY_DONT_FLIP, &o_tty->flags);
792 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
795 * From this point on we know nobody has an ldisc
796 * usage reference, nor can they obtain one until
797 * we say so later on.
800 work = cancel_delayed_work(&tty->buf.work);
802 * Wait for ->hangup_work and ->buf.work handlers to terminate
805 flush_scheduled_work();
806 /* Shutdown the current discipline. */
807 if (tty->ldisc.close)
808 (tty->ldisc.close)(tty);
810 /* Now set up the new line discipline. */
811 tty_ldisc_assign(tty, ld);
812 tty_set_termios_ldisc(tty, ldisc);
814 retval = (tty->ldisc.open)(tty);
816 tty_ldisc_put(ldisc);
817 /* There is an outstanding reference here so this is safe */
818 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
819 tty_set_termios_ldisc(tty, tty->ldisc.num);
820 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
821 tty_ldisc_put(o_ldisc.num);
822 /* This driver is always present */
823 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
824 tty_set_termios_ldisc(tty, N_TTY);
825 if (tty->ldisc.open) {
826 int r = tty->ldisc.open(tty);
829 panic("Couldn't open N_TTY ldisc for "
831 tty_name(tty, buf), r);
835 /* At this point we hold a reference to the new ldisc and a
836 a reference to the old ldisc. If we ended up flipping back
837 to the existing ldisc we have two references to it */
839 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
840 tty->driver->set_ldisc(tty);
842 tty_ldisc_put(o_ldisc.num);
845 * Allow ldisc referencing to occur as soon as the driver
846 * ldisc callback completes.
849 tty_ldisc_enable(tty);
851 tty_ldisc_enable(o_tty);
853 /* Restart it in case no characters kick it off. Safe if
856 schedule_delayed_work(&tty->buf.work, 1);
861 * This routine returns a tty driver structure, given a device number
863 static struct tty_driver *get_tty_driver(dev_t device, int *index)
865 struct tty_driver *p;
867 list_for_each_entry(p, &tty_drivers, tty_drivers) {
868 dev_t base = MKDEV(p->major, p->minor_start);
869 if (device < base || device >= base + p->num)
871 *index = device - base;
878 * If we try to write to, or set the state of, a terminal and we're
879 * not in the foreground, send a SIGTTOU. If the signal is blocked or
880 * ignored, go ahead and perform the operation. (POSIX 7.2)
882 int tty_check_change(struct tty_struct * tty)
884 if (current->signal->tty != tty)
886 if (tty->pgrp <= 0) {
887 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
890 if (process_group(current) == tty->pgrp)
892 if (is_ignored(SIGTTOU))
894 if (is_orphaned_pgrp(process_group(current)))
896 (void) kill_pg(process_group(current), SIGTTOU, 1);
900 EXPORT_SYMBOL(tty_check_change);
902 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
903 size_t count, loff_t *ppos)
908 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
909 size_t count, loff_t *ppos)
914 /* No kernel lock held - none needed ;) */
915 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
917 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
920 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
921 unsigned int cmd, unsigned long arg)
923 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
926 static struct file_operations tty_fops = {
933 .release = tty_release,
934 .fasync = tty_fasync,
937 #ifdef CONFIG_UNIX98_PTYS
938 static struct file_operations ptmx_fops = {
945 .release = tty_release,
946 .fasync = tty_fasync,
950 static struct file_operations console_fops = {
953 .write = redirected_tty_write,
957 .release = tty_release,
958 .fasync = tty_fasync,
961 static struct file_operations hung_up_tty_fops = {
963 .read = hung_up_tty_read,
964 .write = hung_up_tty_write,
965 .poll = hung_up_tty_poll,
966 .ioctl = hung_up_tty_ioctl,
967 .release = tty_release,
970 static DEFINE_SPINLOCK(redirect_lock);
971 static struct file *redirect;
974 * tty_wakeup - request more data
977 * Internal and external helper for wakeups of tty. This function
978 * informs the line discipline if present that the driver is ready
979 * to receive more output data.
982 void tty_wakeup(struct tty_struct *tty)
984 struct tty_ldisc *ld;
986 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
987 ld = tty_ldisc_ref(tty);
990 ld->write_wakeup(tty);
994 wake_up_interruptible(&tty->write_wait);
997 EXPORT_SYMBOL_GPL(tty_wakeup);
1000 * tty_ldisc_flush - flush line discipline queue
1003 * Flush the line discipline queue (if any) for this tty. If there
1004 * is no line discipline active this is a no-op.
1007 void tty_ldisc_flush(struct tty_struct *tty)
1009 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1011 if(ld->flush_buffer)
1012 ld->flush_buffer(tty);
1013 tty_ldisc_deref(ld);
1017 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1020 * This can be called by the "eventd" kernel thread. That is process synchronous,
1021 * but doesn't hold any locks, so we need to make sure we have the appropriate
1022 * locks for what we're doing..
1024 static void do_tty_hangup(void *data)
1026 struct tty_struct *tty = (struct tty_struct *) data;
1027 struct file * cons_filp = NULL;
1028 struct file *filp, *f = NULL;
1029 struct task_struct *p;
1030 struct tty_ldisc *ld;
1031 int closecount = 0, n;
1036 /* inuse_filps is protected by the single kernel lock */
1039 spin_lock(&redirect_lock);
1040 if (redirect && redirect->private_data == tty) {
1044 spin_unlock(&redirect_lock);
1046 check_tty_count(tty, "do_tty_hangup");
1048 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1049 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1050 if (filp->f_op->write == redirected_tty_write)
1052 if (filp->f_op->write != tty_write)
1055 tty_fasync(-1, filp, 0); /* can't block */
1056 filp->f_op = &hung_up_tty_fops;
1060 /* FIXME! What are the locking issues here? This may me overdoing things..
1061 * this question is especially important now that we've removed the irqlock. */
1063 ld = tty_ldisc_ref(tty);
1064 if(ld != NULL) /* We may have no line discipline at this point */
1066 if (ld->flush_buffer)
1067 ld->flush_buffer(tty);
1068 if (tty->driver->flush_buffer)
1069 tty->driver->flush_buffer(tty);
1070 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1072 ld->write_wakeup(tty);
1077 /* FIXME: Once we trust the LDISC code better we can wait here for
1078 ldisc completion and fix the driver call race */
1080 wake_up_interruptible(&tty->write_wait);
1081 wake_up_interruptible(&tty->read_wait);
1084 * Shutdown the current line discipline, and reset it to
1087 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1089 down(&tty->termios_sem);
1090 *tty->termios = tty->driver->init_termios;
1091 up(&tty->termios_sem);
1094 /* Defer ldisc switch */
1095 /* tty_deferred_ldisc_switch(N_TTY);
1097 This should get done automatically when the port closes and
1098 tty_release is called */
1100 read_lock(&tasklist_lock);
1101 if (tty->session > 0) {
1102 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1103 if (p->signal->tty == tty)
1104 p->signal->tty = NULL;
1105 if (!p->signal->leader)
1107 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1108 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1110 p->signal->tty_old_pgrp = tty->pgrp;
1111 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1113 read_unlock(&tasklist_lock);
1118 tty->ctrl_status = 0;
1120 * If one of the devices matches a console pointer, we
1121 * cannot just call hangup() because that will cause
1122 * tty->count and state->count to go out of sync.
1123 * So we just call close() the right number of times.
1126 if (tty->driver->close)
1127 for (n = 0; n < closecount; n++)
1128 tty->driver->close(tty, cons_filp);
1129 } else if (tty->driver->hangup)
1130 (tty->driver->hangup)(tty);
1132 /* We don't want to have driver/ldisc interactions beyond
1133 the ones we did here. The driver layer expects no
1134 calls after ->hangup() from the ldisc side. However we
1135 can't yet guarantee all that */
1137 set_bit(TTY_HUPPED, &tty->flags);
1139 tty_ldisc_enable(tty);
1140 tty_ldisc_deref(ld);
1147 void tty_hangup(struct tty_struct * tty)
1149 #ifdef TTY_DEBUG_HANGUP
1152 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1154 schedule_work(&tty->hangup_work);
1157 EXPORT_SYMBOL(tty_hangup);
1159 void tty_vhangup(struct tty_struct * tty)
1161 #ifdef TTY_DEBUG_HANGUP
1164 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1166 do_tty_hangup((void *) tty);
1168 EXPORT_SYMBOL(tty_vhangup);
1170 int tty_hung_up_p(struct file * filp)
1172 return (filp->f_op == &hung_up_tty_fops);
1175 EXPORT_SYMBOL(tty_hung_up_p);
1178 * This function is typically called only by the session leader, when
1179 * it wants to disassociate itself from its controlling tty.
1181 * It performs the following functions:
1182 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1183 * (2) Clears the tty from being controlling the session
1184 * (3) Clears the controlling tty for all processes in the
1187 * The argument on_exit is set to 1 if called when a process is
1188 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1190 void disassociate_ctty(int on_exit)
1192 struct tty_struct *tty;
1193 struct task_struct *p;
1198 mutex_lock(&tty_mutex);
1199 tty = current->signal->tty;
1201 tty_pgrp = tty->pgrp;
1202 mutex_unlock(&tty_mutex);
1203 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1206 if (current->signal->tty_old_pgrp) {
1207 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1208 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1210 mutex_unlock(&tty_mutex);
1215 kill_pg(tty_pgrp, SIGHUP, on_exit);
1217 kill_pg(tty_pgrp, SIGCONT, on_exit);
1220 /* Must lock changes to tty_old_pgrp */
1221 mutex_lock(&tty_mutex);
1222 current->signal->tty_old_pgrp = 0;
1226 /* Now clear signal->tty under the lock */
1227 read_lock(&tasklist_lock);
1228 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1229 p->signal->tty = NULL;
1230 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1231 read_unlock(&tasklist_lock);
1232 mutex_unlock(&tty_mutex);
1236 void stop_tty(struct tty_struct *tty)
1241 if (tty->link && tty->link->packet) {
1242 tty->ctrl_status &= ~TIOCPKT_START;
1243 tty->ctrl_status |= TIOCPKT_STOP;
1244 wake_up_interruptible(&tty->link->read_wait);
1246 if (tty->driver->stop)
1247 (tty->driver->stop)(tty);
1250 EXPORT_SYMBOL(stop_tty);
1252 void start_tty(struct tty_struct *tty)
1254 if (!tty->stopped || tty->flow_stopped)
1257 if (tty->link && tty->link->packet) {
1258 tty->ctrl_status &= ~TIOCPKT_STOP;
1259 tty->ctrl_status |= TIOCPKT_START;
1260 wake_up_interruptible(&tty->link->read_wait);
1262 if (tty->driver->start)
1263 (tty->driver->start)(tty);
1265 /* If we have a running line discipline it may need kicking */
1267 wake_up_interruptible(&tty->write_wait);
1270 EXPORT_SYMBOL(start_tty);
1272 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1276 struct tty_struct * tty;
1277 struct inode *inode;
1278 struct tty_ldisc *ld;
1280 tty = (struct tty_struct *)file->private_data;
1281 inode = file->f_dentry->d_inode;
1282 if (tty_paranoia_check(tty, inode, "tty_read"))
1284 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1287 /* We want to wait for the line discipline to sort out in this
1289 ld = tty_ldisc_ref_wait(tty);
1292 i = (ld->read)(tty,file,buf,count);
1295 tty_ldisc_deref(ld);
1298 inode->i_atime = current_fs_time(inode->i_sb);
1303 * Split writes up in sane blocksizes to avoid
1304 * denial-of-service type attacks
1306 static inline ssize_t do_tty_write(
1307 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1308 struct tty_struct *tty,
1310 const char __user *buf,
1313 ssize_t ret = 0, written = 0;
1316 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1317 return -ERESTARTSYS;
1321 * We chunk up writes into a temporary buffer. This
1322 * simplifies low-level drivers immensely, since they
1323 * don't have locking issues and user mode accesses.
1325 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1328 * The default chunk-size is 2kB, because the NTTY
1329 * layer has problems with bigger chunks. It will
1330 * claim to be able to handle more characters than
1334 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1339 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1340 if (tty->write_cnt < chunk) {
1346 buf = kmalloc(chunk, GFP_KERNEL);
1348 mutex_unlock(&tty->atomic_write_lock);
1351 kfree(tty->write_buf);
1352 tty->write_cnt = chunk;
1353 tty->write_buf = buf;
1356 /* Do the write .. */
1358 size_t size = count;
1362 if (copy_from_user(tty->write_buf, buf, size))
1365 ret = write(tty, file, tty->write_buf, size);
1375 if (signal_pending(current))
1380 struct inode *inode = file->f_dentry->d_inode;
1381 inode->i_mtime = current_fs_time(inode->i_sb);
1384 mutex_unlock(&tty->atomic_write_lock);
1389 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1392 struct tty_struct * tty;
1393 struct inode *inode = file->f_dentry->d_inode;
1395 struct tty_ldisc *ld;
1397 tty = (struct tty_struct *)file->private_data;
1398 if (tty_paranoia_check(tty, inode, "tty_write"))
1400 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1403 ld = tty_ldisc_ref_wait(tty);
1407 ret = do_tty_write(ld->write, tty, file, buf, count);
1408 tty_ldisc_deref(ld);
1412 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1415 struct file *p = NULL;
1417 spin_lock(&redirect_lock);
1422 spin_unlock(&redirect_lock);
1426 res = vfs_write(p, buf, count, &p->f_pos);
1431 return tty_write(file, buf, count, ppos);
1434 static char ptychar[] = "pqrstuvwxyzabcde";
1436 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1438 int i = index + driver->name_base;
1439 /* ->name is initialized to "ttyp", but "tty" is expected */
1440 sprintf(p, "%s%c%x",
1441 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1442 ptychar[i >> 4 & 0xf], i & 0xf);
1445 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1447 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1451 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1452 * failed open. The new code protects the open with a mutex, so it's
1453 * really quite straightforward. The mutex locking can probably be
1454 * relaxed for the (most common) case of reopening a tty.
1456 static int init_dev(struct tty_driver *driver, int idx,
1457 struct tty_struct **ret_tty)
1459 struct tty_struct *tty, *o_tty;
1460 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1461 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1464 /* check whether we're reopening an existing tty */
1465 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1466 tty = devpts_get_tty(idx);
1467 if (tty && driver->subtype == PTY_TYPE_MASTER)
1470 tty = driver->ttys[idx];
1472 if (tty) goto fast_track;
1475 * First time open is complex, especially for PTY devices.
1476 * This code guarantees that either everything succeeds and the
1477 * TTY is ready for operation, or else the table slots are vacated
1478 * and the allocated memory released. (Except that the termios
1479 * and locked termios may be retained.)
1482 if (!try_module_get(driver->owner)) {
1491 tty = alloc_tty_struct();
1494 initialize_tty_struct(tty);
1495 tty->driver = driver;
1497 tty_line_name(driver, idx, tty->name);
1499 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1500 tp_loc = &tty->termios;
1501 ltp_loc = &tty->termios_locked;
1503 tp_loc = &driver->termios[idx];
1504 ltp_loc = &driver->termios_locked[idx];
1508 tp = (struct termios *) kmalloc(sizeof(struct termios),
1512 *tp = driver->init_termios;
1516 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1520 memset(ltp, 0, sizeof(struct termios));
1523 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1524 o_tty = alloc_tty_struct();
1527 initialize_tty_struct(o_tty);
1528 o_tty->driver = driver->other;
1530 tty_line_name(driver->other, idx, o_tty->name);
1532 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1533 o_tp_loc = &o_tty->termios;
1534 o_ltp_loc = &o_tty->termios_locked;
1536 o_tp_loc = &driver->other->termios[idx];
1537 o_ltp_loc = &driver->other->termios_locked[idx];
1541 o_tp = (struct termios *)
1542 kmalloc(sizeof(struct termios), GFP_KERNEL);
1545 *o_tp = driver->other->init_termios;
1549 o_ltp = (struct termios *)
1550 kmalloc(sizeof(struct termios), GFP_KERNEL);
1553 memset(o_ltp, 0, sizeof(struct termios));
1557 * Everything allocated ... set up the o_tty structure.
1559 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1560 driver->other->ttys[idx] = o_tty;
1566 o_tty->termios = *o_tp_loc;
1567 o_tty->termios_locked = *o_ltp_loc;
1568 driver->other->refcount++;
1569 if (driver->subtype == PTY_TYPE_MASTER)
1572 /* Establish the links in both directions */
1578 * All structures have been allocated, so now we install them.
1579 * Failures after this point use release_mem to clean up, so
1580 * there's no need to null out the local pointers.
1582 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1583 driver->ttys[idx] = tty;
1590 tty->termios = *tp_loc;
1591 tty->termios_locked = *ltp_loc;
1596 * Structures all installed ... call the ldisc open routines.
1597 * If we fail here just call release_mem to clean up. No need
1598 * to decrement the use counts, as release_mem doesn't care.
1601 if (tty->ldisc.open) {
1602 retval = (tty->ldisc.open)(tty);
1604 goto release_mem_out;
1606 if (o_tty && o_tty->ldisc.open) {
1607 retval = (o_tty->ldisc.open)(o_tty);
1609 if (tty->ldisc.close)
1610 (tty->ldisc.close)(tty);
1611 goto release_mem_out;
1613 tty_ldisc_enable(o_tty);
1615 tty_ldisc_enable(tty);
1619 * This fast open can be used if the tty is already open.
1620 * No memory is allocated, and the only failures are from
1621 * attempting to open a closing tty or attempting multiple
1622 * opens on a pty master.
1625 if (test_bit(TTY_CLOSING, &tty->flags)) {
1629 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1630 driver->subtype == PTY_TYPE_MASTER) {
1632 * special case for PTY masters: only one open permitted,
1633 * and the slave side open count is incremented as well.
1642 tty->driver = driver; /* N.B. why do this every time?? */
1645 if(!test_bit(TTY_LDISC, &tty->flags))
1646 printk(KERN_ERR "init_dev but no ldisc\n");
1650 /* All paths come through here to release the mutex */
1654 /* Release locally allocated memory ... nothing placed in slots */
1658 free_tty_struct(o_tty);
1661 free_tty_struct(tty);
1664 module_put(driver->owner);
1668 /* call the tty release_mem routine to clean out this slot */
1670 printk(KERN_INFO "init_dev: ldisc open failed, "
1671 "clearing slot %d\n", idx);
1672 release_mem(tty, idx);
1677 * Releases memory associated with a tty structure, and clears out the
1678 * driver table slots.
1680 static void release_mem(struct tty_struct *tty, int idx)
1682 struct tty_struct *o_tty;
1684 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1686 if ((o_tty = tty->link) != NULL) {
1688 o_tty->driver->ttys[idx] = NULL;
1689 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1690 tp = o_tty->termios;
1692 o_tty->driver->termios[idx] = NULL;
1695 tp = o_tty->termios_locked;
1697 o_tty->driver->termios_locked[idx] = NULL;
1701 o_tty->driver->refcount--;
1703 list_del_init(&o_tty->tty_files);
1705 free_tty_struct(o_tty);
1709 tty->driver->ttys[idx] = NULL;
1710 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1713 tty->driver->termios[idx] = NULL;
1716 tp = tty->termios_locked;
1718 tty->driver->termios_locked[idx] = NULL;
1723 tty->driver->refcount--;
1725 list_del_init(&tty->tty_files);
1727 module_put(tty->driver->owner);
1728 free_tty_struct(tty);
1732 * Even releasing the tty structures is a tricky business.. We have
1733 * to be very careful that the structures are all released at the
1734 * same time, as interrupts might otherwise get the wrong pointers.
1736 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1737 * lead to double frees or releasing memory still in use.
1739 static void release_dev(struct file * filp)
1741 struct tty_struct *tty, *o_tty;
1742 int pty_master, tty_closing, o_tty_closing, do_sleep;
1743 int devpts_master, devpts;
1746 unsigned long flags;
1748 tty = (struct tty_struct *)filp->private_data;
1749 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1752 check_tty_count(tty, "release_dev");
1754 tty_fasync(-1, filp, 0);
1757 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1758 tty->driver->subtype == PTY_TYPE_MASTER);
1759 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1760 devpts_master = pty_master && devpts;
1763 #ifdef TTY_PARANOIA_CHECK
1764 if (idx < 0 || idx >= tty->driver->num) {
1765 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1766 "free (%s)\n", tty->name);
1769 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1770 if (tty != tty->driver->ttys[idx]) {
1771 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1772 "for (%s)\n", idx, tty->name);
1775 if (tty->termios != tty->driver->termios[idx]) {
1776 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1781 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1782 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1783 "termios_locked for (%s)\n",
1790 #ifdef TTY_DEBUG_HANGUP
1791 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1792 tty_name(tty, buf), tty->count);
1795 #ifdef TTY_PARANOIA_CHECK
1796 if (tty->driver->other &&
1797 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1798 if (o_tty != tty->driver->other->ttys[idx]) {
1799 printk(KERN_DEBUG "release_dev: other->table[%d] "
1800 "not o_tty for (%s)\n",
1804 if (o_tty->termios != tty->driver->other->termios[idx]) {
1805 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1806 "not o_termios for (%s)\n",
1810 if (o_tty->termios_locked !=
1811 tty->driver->other->termios_locked[idx]) {
1812 printk(KERN_DEBUG "release_dev: other->termios_locked["
1813 "%d] not o_termios_locked for (%s)\n",
1817 if (o_tty->link != tty) {
1818 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1823 if (tty->driver->close)
1824 tty->driver->close(tty, filp);
1827 * Sanity check: if tty->count is going to zero, there shouldn't be
1828 * any waiters on tty->read_wait or tty->write_wait. We test the
1829 * wait queues and kick everyone out _before_ actually starting to
1830 * close. This ensures that we won't block while releasing the tty
1833 * The test for the o_tty closing is necessary, since the master and
1834 * slave sides may close in any order. If the slave side closes out
1835 * first, its count will be one, since the master side holds an open.
1836 * Thus this test wouldn't be triggered at the time the slave closes,
1839 * Note that it's possible for the tty to be opened again while we're
1840 * flushing out waiters. By recalculating the closing flags before
1841 * each iteration we avoid any problems.
1844 /* Guard against races with tty->count changes elsewhere and
1845 opens on /dev/tty */
1847 mutex_lock(&tty_mutex);
1848 tty_closing = tty->count <= 1;
1849 o_tty_closing = o_tty &&
1850 (o_tty->count <= (pty_master ? 1 : 0));
1854 if (waitqueue_active(&tty->read_wait)) {
1855 wake_up(&tty->read_wait);
1858 if (waitqueue_active(&tty->write_wait)) {
1859 wake_up(&tty->write_wait);
1863 if (o_tty_closing) {
1864 if (waitqueue_active(&o_tty->read_wait)) {
1865 wake_up(&o_tty->read_wait);
1868 if (waitqueue_active(&o_tty->write_wait)) {
1869 wake_up(&o_tty->write_wait);
1876 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1877 "active!\n", tty_name(tty, buf));
1878 mutex_unlock(&tty_mutex);
1883 * The closing flags are now consistent with the open counts on
1884 * both sides, and we've completed the last operation that could
1885 * block, so it's safe to proceed with closing.
1888 if (--o_tty->count < 0) {
1889 printk(KERN_WARNING "release_dev: bad pty slave count "
1891 o_tty->count, tty_name(o_tty, buf));
1895 if (--tty->count < 0) {
1896 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1897 tty->count, tty_name(tty, buf));
1902 * We've decremented tty->count, so we need to remove this file
1903 * descriptor off the tty->tty_files list; this serves two
1905 * - check_tty_count sees the correct number of file descriptors
1906 * associated with this tty.
1907 * - do_tty_hangup no longer sees this file descriptor as
1908 * something that needs to be handled for hangups.
1911 filp->private_data = NULL;
1914 * Perform some housekeeping before deciding whether to return.
1916 * Set the TTY_CLOSING flag if this was the last open. In the
1917 * case of a pty we may have to wait around for the other side
1918 * to close, and TTY_CLOSING makes sure we can't be reopened.
1921 set_bit(TTY_CLOSING, &tty->flags);
1923 set_bit(TTY_CLOSING, &o_tty->flags);
1926 * If _either_ side is closing, make sure there aren't any
1927 * processes that still think tty or o_tty is their controlling
1930 if (tty_closing || o_tty_closing) {
1931 struct task_struct *p;
1933 read_lock(&tasklist_lock);
1934 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1935 p->signal->tty = NULL;
1936 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1938 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1939 p->signal->tty = NULL;
1940 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1941 read_unlock(&tasklist_lock);
1944 mutex_unlock(&tty_mutex);
1946 /* check whether both sides are closing ... */
1947 if (!tty_closing || (o_tty && !o_tty_closing))
1950 #ifdef TTY_DEBUG_HANGUP
1951 printk(KERN_DEBUG "freeing tty structure...");
1954 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1955 * kill any delayed work. As this is the final close it does not
1956 * race with the set_ldisc code path.
1958 clear_bit(TTY_LDISC, &tty->flags);
1959 clear_bit(TTY_DONT_FLIP, &tty->flags);
1960 cancel_delayed_work(&tty->buf.work);
1963 * Wait for ->hangup_work and ->buf.work handlers to terminate
1966 flush_scheduled_work();
1969 * Wait for any short term users (we know they are just driver
1970 * side waiters as the file is closing so user count on the file
1973 spin_lock_irqsave(&tty_ldisc_lock, flags);
1974 while(tty->ldisc.refcount)
1976 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1977 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1978 spin_lock_irqsave(&tty_ldisc_lock, flags);
1980 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1982 * Shutdown the current line discipline, and reset it to N_TTY.
1983 * N.B. why reset ldisc when we're releasing the memory??
1985 * FIXME: this MUST get fixed for the new reflocking
1987 if (tty->ldisc.close)
1988 (tty->ldisc.close)(tty);
1989 tty_ldisc_put(tty->ldisc.num);
1992 * Switch the line discipline back
1994 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1995 tty_set_termios_ldisc(tty,N_TTY);
1997 /* FIXME: could o_tty be in setldisc here ? */
1998 clear_bit(TTY_LDISC, &o_tty->flags);
1999 if (o_tty->ldisc.close)
2000 (o_tty->ldisc.close)(o_tty);
2001 tty_ldisc_put(o_tty->ldisc.num);
2002 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2003 tty_set_termios_ldisc(o_tty,N_TTY);
2006 * The release_mem function takes care of the details of clearing
2007 * the slots and preserving the termios structure.
2009 release_mem(tty, idx);
2011 #ifdef CONFIG_UNIX98_PTYS
2012 /* Make this pty number available for reallocation */
2014 down(&allocated_ptys_lock);
2015 idr_remove(&allocated_ptys, idx);
2016 up(&allocated_ptys_lock);
2023 * tty_open and tty_release keep up the tty count that contains the
2024 * number of opens done on a tty. We cannot use the inode-count, as
2025 * different inodes might point to the same tty.
2027 * Open-counting is needed for pty masters, as well as for keeping
2028 * track of serial lines: DTR is dropped when the last close happens.
2029 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2031 * The termios state of a pty is reset on first open so that
2032 * settings don't persist across reuse.
2034 static int tty_open(struct inode * inode, struct file * filp)
2036 struct tty_struct *tty;
2038 struct tty_driver *driver;
2040 dev_t device = inode->i_rdev;
2041 unsigned short saved_flags = filp->f_flags;
2043 nonseekable_open(inode, filp);
2046 noctty = filp->f_flags & O_NOCTTY;
2050 mutex_lock(&tty_mutex);
2052 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2053 if (!current->signal->tty) {
2054 mutex_unlock(&tty_mutex);
2057 driver = current->signal->tty->driver;
2058 index = current->signal->tty->index;
2059 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2064 if (device == MKDEV(TTY_MAJOR,0)) {
2065 extern struct tty_driver *console_driver;
2066 driver = console_driver;
2072 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2073 driver = console_device(&index);
2075 /* Don't let /dev/console block */
2076 filp->f_flags |= O_NONBLOCK;
2080 mutex_unlock(&tty_mutex);
2084 driver = get_tty_driver(device, &index);
2086 mutex_unlock(&tty_mutex);
2090 retval = init_dev(driver, index, &tty);
2091 mutex_unlock(&tty_mutex);
2095 filp->private_data = tty;
2096 file_move(filp, &tty->tty_files);
2097 check_tty_count(tty, "tty_open");
2098 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2099 tty->driver->subtype == PTY_TYPE_MASTER)
2101 #ifdef TTY_DEBUG_HANGUP
2102 printk(KERN_DEBUG "opening %s...", tty->name);
2105 if (tty->driver->open)
2106 retval = tty->driver->open(tty, filp);
2110 filp->f_flags = saved_flags;
2112 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2116 #ifdef TTY_DEBUG_HANGUP
2117 printk(KERN_DEBUG "error %d in opening %s...", retval,
2121 if (retval != -ERESTARTSYS)
2123 if (signal_pending(current))
2127 * Need to reset f_op in case a hangup happened.
2129 if (filp->f_op == &hung_up_tty_fops)
2130 filp->f_op = &tty_fops;
2134 current->signal->leader &&
2135 !current->signal->tty &&
2136 tty->session == 0) {
2138 current->signal->tty = tty;
2139 task_unlock(current);
2140 current->signal->tty_old_pgrp = 0;
2141 tty->session = current->signal->session;
2142 tty->pgrp = process_group(current);
2147 #ifdef CONFIG_UNIX98_PTYS
2148 static int ptmx_open(struct inode * inode, struct file * filp)
2150 struct tty_struct *tty;
2155 nonseekable_open(inode, filp);
2157 /* find a device that is not in use. */
2158 down(&allocated_ptys_lock);
2159 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2160 up(&allocated_ptys_lock);
2163 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2165 up(&allocated_ptys_lock);
2166 if (idr_ret == -EAGAIN)
2170 if (index >= pty_limit) {
2171 idr_remove(&allocated_ptys, index);
2172 up(&allocated_ptys_lock);
2175 up(&allocated_ptys_lock);
2177 mutex_lock(&tty_mutex);
2178 retval = init_dev(ptm_driver, index, &tty);
2179 mutex_unlock(&tty_mutex);
2184 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2185 filp->private_data = tty;
2186 file_move(filp, &tty->tty_files);
2189 if (devpts_pty_new(tty->link))
2192 check_tty_count(tty, "tty_open");
2193 retval = ptm_driver->open(tty, filp);
2200 down(&allocated_ptys_lock);
2201 idr_remove(&allocated_ptys, index);
2202 up(&allocated_ptys_lock);
2207 static int tty_release(struct inode * inode, struct file * filp)
2215 /* No kernel lock held - fine */
2216 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2218 struct tty_struct * tty;
2219 struct tty_ldisc *ld;
2222 tty = (struct tty_struct *)filp->private_data;
2223 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2226 ld = tty_ldisc_ref_wait(tty);
2228 ret = (ld->poll)(tty, filp, wait);
2229 tty_ldisc_deref(ld);
2233 static int tty_fasync(int fd, struct file * filp, int on)
2235 struct tty_struct * tty;
2238 tty = (struct tty_struct *)filp->private_data;
2239 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2242 retval = fasync_helper(fd, filp, on, &tty->fasync);
2247 if (!waitqueue_active(&tty->read_wait))
2248 tty->minimum_to_wake = 1;
2249 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2253 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2254 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2259 static int tiocsti(struct tty_struct *tty, char __user *p)
2262 struct tty_ldisc *ld;
2264 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2266 if (get_user(ch, p))
2268 ld = tty_ldisc_ref_wait(tty);
2269 ld->receive_buf(tty, &ch, &mbz, 1);
2270 tty_ldisc_deref(ld);
2274 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2276 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2281 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2282 struct winsize __user * arg)
2284 struct winsize tmp_ws;
2286 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2288 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2291 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2294 acquire_console_sem();
2295 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2296 release_console_sem();
2302 kill_pg(tty->pgrp, SIGWINCH, 1);
2303 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2304 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2305 tty->winsize = tmp_ws;
2306 real_tty->winsize = tmp_ws;
2310 static int tioccons(struct file *file)
2312 if (!capable(CAP_SYS_ADMIN))
2314 if (file->f_op->write == redirected_tty_write) {
2316 spin_lock(&redirect_lock);
2319 spin_unlock(&redirect_lock);
2324 spin_lock(&redirect_lock);
2326 spin_unlock(&redirect_lock);
2331 spin_unlock(&redirect_lock);
2336 static int fionbio(struct file *file, int __user *p)
2340 if (get_user(nonblock, p))
2344 file->f_flags |= O_NONBLOCK;
2346 file->f_flags &= ~O_NONBLOCK;
2350 static int tiocsctty(struct tty_struct *tty, int arg)
2354 if (current->signal->leader &&
2355 (current->signal->session == tty->session))
2358 * The process must be a session leader and
2359 * not have a controlling tty already.
2361 if (!current->signal->leader || current->signal->tty)
2363 if (tty->session > 0) {
2365 * This tty is already the controlling
2366 * tty for another session group!
2368 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2373 read_lock(&tasklist_lock);
2374 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2375 p->signal->tty = NULL;
2376 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2377 read_unlock(&tasklist_lock);
2382 current->signal->tty = tty;
2383 task_unlock(current);
2384 current->signal->tty_old_pgrp = 0;
2385 tty->session = current->signal->session;
2386 tty->pgrp = process_group(current);
2390 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2393 * (tty == real_tty) is a cheap way of
2394 * testing if the tty is NOT a master pty.
2396 if (tty == real_tty && current->signal->tty != real_tty)
2398 return put_user(real_tty->pgrp, p);
2401 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2404 int retval = tty_check_change(real_tty);
2410 if (!current->signal->tty ||
2411 (current->signal->tty != real_tty) ||
2412 (real_tty->session != current->signal->session))
2414 if (get_user(pgrp, p))
2418 if (session_of_pgrp(pgrp) != current->signal->session)
2420 real_tty->pgrp = pgrp;
2424 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2427 * (tty == real_tty) is a cheap way of
2428 * testing if the tty is NOT a master pty.
2430 if (tty == real_tty && current->signal->tty != real_tty)
2432 if (real_tty->session <= 0)
2434 return put_user(real_tty->session, p);
2437 static int tiocsetd(struct tty_struct *tty, int __user *p)
2441 if (get_user(ldisc, p))
2443 return tty_set_ldisc(tty, ldisc);
2446 static int send_break(struct tty_struct *tty, unsigned int duration)
2448 tty->driver->break_ctl(tty, -1);
2449 if (!signal_pending(current)) {
2450 msleep_interruptible(duration);
2452 tty->driver->break_ctl(tty, 0);
2453 if (signal_pending(current))
2459 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2461 int retval = -EINVAL;
2463 if (tty->driver->tiocmget) {
2464 retval = tty->driver->tiocmget(tty, file);
2467 retval = put_user(retval, p);
2473 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2476 int retval = -EINVAL;
2478 if (tty->driver->tiocmset) {
2479 unsigned int set, clear, val;
2481 retval = get_user(val, p);
2499 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2500 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2502 retval = tty->driver->tiocmset(tty, file, set, clear);
2508 * Split this up, as gcc can choke on it otherwise..
2510 int tty_ioctl(struct inode * inode, struct file * file,
2511 unsigned int cmd, unsigned long arg)
2513 struct tty_struct *tty, *real_tty;
2514 void __user *p = (void __user *)arg;
2516 struct tty_ldisc *ld;
2518 tty = (struct tty_struct *)file->private_data;
2519 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2523 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2524 tty->driver->subtype == PTY_TYPE_MASTER)
2525 real_tty = tty->link;
2528 * Break handling by driver
2530 if (!tty->driver->break_ctl) {
2534 if (tty->driver->ioctl)
2535 return tty->driver->ioctl(tty, file, cmd, arg);
2538 /* These two ioctl's always return success; even if */
2539 /* the driver doesn't support them. */
2542 if (!tty->driver->ioctl)
2544 retval = tty->driver->ioctl(tty, file, cmd, arg);
2545 if (retval == -ENOIOCTLCMD)
2552 * Factor out some common prep work
2560 retval = tty_check_change(tty);
2563 if (cmd != TIOCCBRK) {
2564 tty_wait_until_sent(tty, 0);
2565 if (signal_pending(current))
2573 return tiocsti(tty, p);
2575 return tiocgwinsz(tty, p);
2577 return tiocswinsz(tty, real_tty, p);
2579 return real_tty!=tty ? -EINVAL : tioccons(file);
2581 return fionbio(file, p);
2583 set_bit(TTY_EXCLUSIVE, &tty->flags);
2586 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2589 if (current->signal->tty != tty)
2591 if (current->signal->leader)
2592 disassociate_ctty(0);
2594 current->signal->tty = NULL;
2595 task_unlock(current);
2598 return tiocsctty(tty, arg);
2600 return tiocgpgrp(tty, real_tty, p);
2602 return tiocspgrp(tty, real_tty, p);
2604 return tiocgsid(tty, real_tty, p);
2606 /* FIXME: check this is ok */
2607 return put_user(tty->ldisc.num, (int __user *)p);
2609 return tiocsetd(tty, p);
2612 return tioclinux(tty, arg);
2617 case TIOCSBRK: /* Turn break on, unconditionally */
2618 tty->driver->break_ctl(tty, -1);
2621 case TIOCCBRK: /* Turn break off, unconditionally */
2622 tty->driver->break_ctl(tty, 0);
2624 case TCSBRK: /* SVID version: non-zero arg --> no break */
2626 * XXX is the above comment correct, or the
2627 * code below correct? Is this ioctl used at
2631 return send_break(tty, 250);
2633 case TCSBRKP: /* support for POSIX tcsendbreak() */
2634 return send_break(tty, arg ? arg*100 : 250);
2637 return tty_tiocmget(tty, file, p);
2642 return tty_tiocmset(tty, file, cmd, p);
2644 if (tty->driver->ioctl) {
2645 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2646 if (retval != -ENOIOCTLCMD)
2649 ld = tty_ldisc_ref_wait(tty);
2652 retval = ld->ioctl(tty, file, cmd, arg);
2653 if (retval == -ENOIOCTLCMD)
2656 tty_ldisc_deref(ld);
2662 * This implements the "Secure Attention Key" --- the idea is to
2663 * prevent trojan horses by killing all processes associated with this
2664 * tty when the user hits the "Secure Attention Key". Required for
2665 * super-paranoid applications --- see the Orange Book for more details.
2667 * This code could be nicer; ideally it should send a HUP, wait a few
2668 * seconds, then send a INT, and then a KILL signal. But you then
2669 * have to coordinate with the init process, since all processes associated
2670 * with the current tty must be dead before the new getty is allowed
2673 * Now, if it would be correct ;-/ The current code has a nasty hole -
2674 * it doesn't catch files in flight. We may send the descriptor to ourselves
2675 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2677 * Nasty bug: do_SAK is being called in interrupt context. This can
2678 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2680 static void __do_SAK(void *arg)
2685 struct tty_struct *tty = arg;
2686 struct task_struct *g, *p;
2690 struct tty_ldisc *disc;
2691 struct fdtable *fdt;
2695 session = tty->session;
2697 /* We don't want an ldisc switch during this */
2698 disc = tty_ldisc_ref(tty);
2699 if (disc && disc->flush_buffer)
2700 disc->flush_buffer(tty);
2701 tty_ldisc_deref(disc);
2703 if (tty->driver->flush_buffer)
2704 tty->driver->flush_buffer(tty);
2706 read_lock(&tasklist_lock);
2707 /* Kill the entire session */
2708 do_each_task_pid(session, PIDTYPE_SID, p) {
2709 printk(KERN_NOTICE "SAK: killed process %d"
2710 " (%s): p->signal->session==tty->session\n",
2712 send_sig(SIGKILL, p, 1);
2713 } while_each_task_pid(session, PIDTYPE_SID, p);
2714 /* Now kill any processes that happen to have the
2717 do_each_thread(g, p) {
2718 if (p->signal->tty == tty) {
2719 printk(KERN_NOTICE "SAK: killed process %d"
2720 " (%s): p->signal->session==tty->session\n",
2722 send_sig(SIGKILL, p, 1);
2728 fdt = files_fdtable(p->files);
2729 for (i=0; i < fdt->max_fds; i++) {
2730 filp = fcheck_files(p->files, i);
2733 if (filp->f_op->read == tty_read &&
2734 filp->private_data == tty) {
2735 printk(KERN_NOTICE "SAK: killed process %d"
2736 " (%s): fd#%d opened to the tty\n",
2737 p->pid, p->comm, i);
2738 send_sig(SIGKILL, p, 1);
2745 } while_each_thread(g, p);
2746 read_unlock(&tasklist_lock);
2751 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2752 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2753 * the values which we write to it will be identical to the values which it
2754 * already has. --akpm
2756 void do_SAK(struct tty_struct *tty)
2760 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2761 schedule_work(&tty->SAK_work);
2764 EXPORT_SYMBOL(do_SAK);
2767 * This routine is called out of the software interrupt to flush data
2768 * from the buffer chain to the line discipline.
2771 static void flush_to_ldisc(void *private_)
2773 struct tty_struct *tty = (struct tty_struct *) private_;
2774 unsigned long flags;
2775 struct tty_ldisc *disc;
2776 struct tty_buffer *tbuf;
2779 unsigned char *flag_buf;
2781 disc = tty_ldisc_ref(tty);
2782 if (disc == NULL) /* !TTY_LDISC */
2785 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2787 * Do it after the next timer tick:
2789 schedule_delayed_work(&tty->buf.work, 1);
2792 spin_lock_irqsave(&tty->buf.lock, flags);
2793 while((tbuf = tty->buf.head) != NULL) {
2794 while ((count = tbuf->commit - tbuf->read) != 0) {
2795 char_buf = tbuf->char_buf_ptr + tbuf->read;
2796 flag_buf = tbuf->flag_buf_ptr + tbuf->read;
2797 tbuf->read += count;
2798 spin_unlock_irqrestore(&tty->buf.lock, flags);
2799 disc->receive_buf(tty, char_buf, flag_buf, count);
2800 spin_lock_irqsave(&tty->buf.lock, flags);
2804 tty->buf.head = tbuf->next;
2805 if (tty->buf.head == NULL)
2806 tty->buf.tail = NULL;
2807 tty_buffer_free(tty, tbuf);
2809 spin_unlock_irqrestore(&tty->buf.lock, flags);
2811 tty_ldisc_deref(disc);
2815 * Routine which returns the baud rate of the tty
2817 * Note that the baud_table needs to be kept in sync with the
2818 * include/asm/termbits.h file.
2820 static int baud_table[] = {
2821 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2822 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2824 76800, 153600, 307200, 614400, 921600
2826 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2827 2500000, 3000000, 3500000, 4000000
2831 static int n_baud_table = ARRAY_SIZE(baud_table);
2834 * tty_termios_baud_rate
2835 * @termios: termios structure
2837 * Convert termios baud rate data into a speed. This should be called
2838 * with the termios lock held if this termios is a terminal termios
2839 * structure. May change the termios data.
2842 int tty_termios_baud_rate(struct termios *termios)
2846 cbaud = termios->c_cflag & CBAUD;
2848 if (cbaud & CBAUDEX) {
2851 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2852 termios->c_cflag &= ~CBAUDEX;
2856 return baud_table[cbaud];
2859 EXPORT_SYMBOL(tty_termios_baud_rate);
2862 * tty_get_baud_rate - get tty bit rates
2863 * @tty: tty to query
2865 * Returns the baud rate as an integer for this terminal. The
2866 * termios lock must be held by the caller and the terminal bit
2867 * flags may be updated.
2870 int tty_get_baud_rate(struct tty_struct *tty)
2872 int baud = tty_termios_baud_rate(tty->termios);
2874 if (baud == 38400 && tty->alt_speed) {
2876 printk(KERN_WARNING "Use of setserial/setrocket to "
2877 "set SPD_* flags is deprecated\n");
2880 baud = tty->alt_speed;
2886 EXPORT_SYMBOL(tty_get_baud_rate);
2889 * tty_flip_buffer_push - terminal
2892 * Queue a push of the terminal flip buffers to the line discipline. This
2893 * function must not be called from IRQ context if tty->low_latency is set.
2895 * In the event of the queue being busy for flipping the work will be
2896 * held off and retried later.
2899 void tty_flip_buffer_push(struct tty_struct *tty)
2901 unsigned long flags;
2902 spin_lock_irqsave(&tty->buf.lock, flags);
2903 if (tty->buf.tail != NULL) {
2904 tty->buf.tail->active = 0;
2905 tty->buf.tail->commit = tty->buf.tail->used;
2907 spin_unlock_irqrestore(&tty->buf.lock, flags);
2909 if (tty->low_latency)
2910 flush_to_ldisc((void *) tty);
2912 schedule_delayed_work(&tty->buf.work, 1);
2915 EXPORT_SYMBOL(tty_flip_buffer_push);
2919 * This subroutine initializes a tty structure.
2921 static void initialize_tty_struct(struct tty_struct *tty)
2923 memset(tty, 0, sizeof(struct tty_struct));
2924 tty->magic = TTY_MAGIC;
2925 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2927 tty->overrun_time = jiffies;
2928 tty->buf.head = tty->buf.tail = NULL;
2929 tty_buffer_init(tty);
2930 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
2931 init_MUTEX(&tty->buf.pty_sem);
2932 init_MUTEX(&tty->termios_sem);
2933 init_waitqueue_head(&tty->write_wait);
2934 init_waitqueue_head(&tty->read_wait);
2935 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2936 mutex_init(&tty->atomic_read_lock);
2937 mutex_init(&tty->atomic_write_lock);
2938 spin_lock_init(&tty->read_lock);
2939 INIT_LIST_HEAD(&tty->tty_files);
2940 INIT_WORK(&tty->SAK_work, NULL, NULL);
2944 * The default put_char routine if the driver did not define one.
2946 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2948 tty->driver->write(tty, &ch, 1);
2951 static struct class *tty_class;
2954 * tty_register_device - register a tty device
2955 * @driver: the tty driver that describes the tty device
2956 * @index: the index in the tty driver for this tty device
2957 * @device: a struct device that is associated with this tty device.
2958 * This field is optional, if there is no known struct device for this
2959 * tty device it can be set to NULL safely.
2961 * This call is required to be made to register an individual tty device if
2962 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2963 * bit is not set, this function should not be called.
2965 void tty_register_device(struct tty_driver *driver, unsigned index,
2966 struct device *device)
2969 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2971 if (index >= driver->num) {
2972 printk(KERN_ERR "Attempt to register invalid tty line number "
2977 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2978 "%s%d", driver->devfs_name, index + driver->name_base);
2980 if (driver->type == TTY_DRIVER_TYPE_PTY)
2981 pty_line_name(driver, index, name);
2983 tty_line_name(driver, index, name);
2984 class_device_create(tty_class, NULL, dev, device, "%s", name);
2988 * tty_unregister_device - unregister a tty device
2989 * @driver: the tty driver that describes the tty device
2990 * @index: the index in the tty driver for this tty device
2992 * If a tty device is registered with a call to tty_register_device() then
2993 * this function must be made when the tty device is gone.
2995 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2997 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2998 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3001 EXPORT_SYMBOL(tty_register_device);
3002 EXPORT_SYMBOL(tty_unregister_device);
3004 struct tty_driver *alloc_tty_driver(int lines)
3006 struct tty_driver *driver;
3008 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3010 memset(driver, 0, sizeof(struct tty_driver));
3011 driver->magic = TTY_DRIVER_MAGIC;
3012 driver->num = lines;
3013 /* later we'll move allocation of tables here */
3018 void put_tty_driver(struct tty_driver *driver)
3023 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3025 driver->open = op->open;
3026 driver->close = op->close;
3027 driver->write = op->write;
3028 driver->put_char = op->put_char;
3029 driver->flush_chars = op->flush_chars;
3030 driver->write_room = op->write_room;
3031 driver->chars_in_buffer = op->chars_in_buffer;
3032 driver->ioctl = op->ioctl;
3033 driver->set_termios = op->set_termios;
3034 driver->throttle = op->throttle;
3035 driver->unthrottle = op->unthrottle;
3036 driver->stop = op->stop;
3037 driver->start = op->start;
3038 driver->hangup = op->hangup;
3039 driver->break_ctl = op->break_ctl;
3040 driver->flush_buffer = op->flush_buffer;
3041 driver->set_ldisc = op->set_ldisc;
3042 driver->wait_until_sent = op->wait_until_sent;
3043 driver->send_xchar = op->send_xchar;
3044 driver->read_proc = op->read_proc;
3045 driver->write_proc = op->write_proc;
3046 driver->tiocmget = op->tiocmget;
3047 driver->tiocmset = op->tiocmset;
3051 EXPORT_SYMBOL(alloc_tty_driver);
3052 EXPORT_SYMBOL(put_tty_driver);
3053 EXPORT_SYMBOL(tty_set_operations);
3056 * Called by a tty driver to register itself.
3058 int tty_register_driver(struct tty_driver *driver)
3065 if (driver->flags & TTY_DRIVER_INSTALLED)
3068 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3069 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3072 memset(p, 0, driver->num * 3 * sizeof(void *));
3075 if (!driver->major) {
3076 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3077 (char*)driver->name);
3079 driver->major = MAJOR(dev);
3080 driver->minor_start = MINOR(dev);
3083 dev = MKDEV(driver->major, driver->minor_start);
3084 error = register_chrdev_region(dev, driver->num,
3085 (char*)driver->name);
3093 driver->ttys = (struct tty_struct **)p;
3094 driver->termios = (struct termios **)(p + driver->num);
3095 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3097 driver->ttys = NULL;
3098 driver->termios = NULL;
3099 driver->termios_locked = NULL;
3102 cdev_init(&driver->cdev, &tty_fops);
3103 driver->cdev.owner = driver->owner;
3104 error = cdev_add(&driver->cdev, dev, driver->num);
3106 cdev_del(&driver->cdev);
3107 unregister_chrdev_region(dev, driver->num);
3108 driver->ttys = NULL;
3109 driver->termios = driver->termios_locked = NULL;
3114 if (!driver->put_char)
3115 driver->put_char = tty_default_put_char;
3117 list_add(&driver->tty_drivers, &tty_drivers);
3119 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
3120 for(i = 0; i < driver->num; i++)
3121 tty_register_device(driver, i, NULL);
3123 proc_tty_register_driver(driver);
3127 EXPORT_SYMBOL(tty_register_driver);
3130 * Called by a tty driver to unregister itself.
3132 int tty_unregister_driver(struct tty_driver *driver)
3138 if (driver->refcount)
3141 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3144 list_del(&driver->tty_drivers);
3147 * Free the termios and termios_locked structures because
3148 * we don't want to get memory leaks when modular tty
3149 * drivers are removed from the kernel.
3151 for (i = 0; i < driver->num; i++) {
3152 tp = driver->termios[i];
3154 driver->termios[i] = NULL;
3157 tp = driver->termios_locked[i];
3159 driver->termios_locked[i] = NULL;
3162 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
3163 tty_unregister_device(driver, i);
3166 proc_tty_unregister_driver(driver);
3167 driver->ttys = NULL;
3168 driver->termios = driver->termios_locked = NULL;
3170 cdev_del(&driver->cdev);
3174 EXPORT_SYMBOL(tty_unregister_driver);
3178 * Initialize the console device. This is called *early*, so
3179 * we can't necessarily depend on lots of kernel help here.
3180 * Just do some early initializations, and do the complex setup
3183 void __init console_init(void)
3187 /* Setup the default TTY line discipline. */
3188 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3191 * set up the console device so that later boot sequences can
3192 * inform about problems etc..
3194 #ifdef CONFIG_EARLY_PRINTK
3195 disable_early_printk();
3197 call = __con_initcall_start;
3198 while (call < __con_initcall_end) {
3205 extern int vty_init(void);
3208 static int __init tty_class_init(void)
3210 tty_class = class_create(THIS_MODULE, "tty");
3211 if (IS_ERR(tty_class))
3212 return PTR_ERR(tty_class);
3216 postcore_initcall(tty_class_init);
3218 /* 3/2004 jmc: why do these devices exist? */
3220 static struct cdev tty_cdev, console_cdev;
3221 #ifdef CONFIG_UNIX98_PTYS
3222 static struct cdev ptmx_cdev;
3225 static struct cdev vc0_cdev;
3229 * Ok, now we can initialize the rest of the tty devices and can count
3230 * on memory allocations, interrupts etc..
3232 static int __init tty_init(void)
3234 cdev_init(&tty_cdev, &tty_fops);
3235 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3236 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3237 panic("Couldn't register /dev/tty driver\n");
3238 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
3239 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3241 cdev_init(&console_cdev, &console_fops);
3242 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3243 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3244 panic("Couldn't register /dev/console driver\n");
3245 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
3246 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3248 #ifdef CONFIG_UNIX98_PTYS
3249 cdev_init(&ptmx_cdev, &ptmx_fops);
3250 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3251 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3252 panic("Couldn't register /dev/ptmx driver\n");
3253 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
3254 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3258 cdev_init(&vc0_cdev, &console_fops);
3259 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3260 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3261 panic("Couldn't register /dev/tty0 driver\n");
3262 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3263 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3269 module_init(tty_init);