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(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);
788 clear_bit(TTY_LDISC, &o_tty->flags);
789 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
792 * From this point on we know nobody has an ldisc
793 * usage reference, nor can they obtain one until
794 * we say so later on.
797 work = cancel_delayed_work(&tty->buf.work);
799 * Wait for ->hangup_work and ->buf.work handlers to terminate
802 flush_scheduled_work();
803 /* Shutdown the current discipline. */
804 if (tty->ldisc.close)
805 (tty->ldisc.close)(tty);
807 /* Now set up the new line discipline. */
808 tty_ldisc_assign(tty, ld);
809 tty_set_termios_ldisc(tty, ldisc);
811 retval = (tty->ldisc.open)(tty);
813 tty_ldisc_put(ldisc);
814 /* There is an outstanding reference here so this is safe */
815 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
816 tty_set_termios_ldisc(tty, tty->ldisc.num);
817 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
818 tty_ldisc_put(o_ldisc.num);
819 /* This driver is always present */
820 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
821 tty_set_termios_ldisc(tty, N_TTY);
822 if (tty->ldisc.open) {
823 int r = tty->ldisc.open(tty);
826 panic("Couldn't open N_TTY ldisc for "
828 tty_name(tty, buf), r);
832 /* At this point we hold a reference to the new ldisc and a
833 a reference to the old ldisc. If we ended up flipping back
834 to the existing ldisc we have two references to it */
836 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
837 tty->driver->set_ldisc(tty);
839 tty_ldisc_put(o_ldisc.num);
842 * Allow ldisc referencing to occur as soon as the driver
843 * ldisc callback completes.
846 tty_ldisc_enable(tty);
848 tty_ldisc_enable(o_tty);
850 /* Restart it in case no characters kick it off. Safe if
853 schedule_delayed_work(&tty->buf.work, 1);
858 * This routine returns a tty driver structure, given a device number
860 static struct tty_driver *get_tty_driver(dev_t device, int *index)
862 struct tty_driver *p;
864 list_for_each_entry(p, &tty_drivers, tty_drivers) {
865 dev_t base = MKDEV(p->major, p->minor_start);
866 if (device < base || device >= base + p->num)
868 *index = device - base;
875 * If we try to write to, or set the state of, a terminal and we're
876 * not in the foreground, send a SIGTTOU. If the signal is blocked or
877 * ignored, go ahead and perform the operation. (POSIX 7.2)
879 int tty_check_change(struct tty_struct * tty)
881 if (current->signal->tty != tty)
883 if (tty->pgrp <= 0) {
884 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
887 if (process_group(current) == tty->pgrp)
889 if (is_ignored(SIGTTOU))
891 if (is_orphaned_pgrp(process_group(current)))
893 (void) kill_pg(process_group(current), SIGTTOU, 1);
897 EXPORT_SYMBOL(tty_check_change);
899 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
900 size_t count, loff_t *ppos)
905 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
906 size_t count, loff_t *ppos)
911 /* No kernel lock held - none needed ;) */
912 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
914 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
917 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
918 unsigned int cmd, unsigned long arg)
920 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
923 static struct file_operations tty_fops = {
930 .release = tty_release,
931 .fasync = tty_fasync,
934 #ifdef CONFIG_UNIX98_PTYS
935 static struct file_operations ptmx_fops = {
942 .release = tty_release,
943 .fasync = tty_fasync,
947 static struct file_operations console_fops = {
950 .write = redirected_tty_write,
954 .release = tty_release,
955 .fasync = tty_fasync,
958 static struct file_operations hung_up_tty_fops = {
960 .read = hung_up_tty_read,
961 .write = hung_up_tty_write,
962 .poll = hung_up_tty_poll,
963 .ioctl = hung_up_tty_ioctl,
964 .release = tty_release,
967 static DEFINE_SPINLOCK(redirect_lock);
968 static struct file *redirect;
971 * tty_wakeup - request more data
974 * Internal and external helper for wakeups of tty. This function
975 * informs the line discipline if present that the driver is ready
976 * to receive more output data.
979 void tty_wakeup(struct tty_struct *tty)
981 struct tty_ldisc *ld;
983 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
984 ld = tty_ldisc_ref(tty);
987 ld->write_wakeup(tty);
991 wake_up_interruptible(&tty->write_wait);
994 EXPORT_SYMBOL_GPL(tty_wakeup);
997 * tty_ldisc_flush - flush line discipline queue
1000 * Flush the line discipline queue (if any) for this tty. If there
1001 * is no line discipline active this is a no-op.
1004 void tty_ldisc_flush(struct tty_struct *tty)
1006 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1008 if(ld->flush_buffer)
1009 ld->flush_buffer(tty);
1010 tty_ldisc_deref(ld);
1014 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1017 * This can be called by the "eventd" kernel thread. That is process synchronous,
1018 * but doesn't hold any locks, so we need to make sure we have the appropriate
1019 * locks for what we're doing..
1021 static void do_tty_hangup(void *data)
1023 struct tty_struct *tty = (struct tty_struct *) data;
1024 struct file * cons_filp = NULL;
1025 struct file *filp, *f = NULL;
1026 struct task_struct *p;
1027 struct tty_ldisc *ld;
1028 int closecount = 0, n;
1033 /* inuse_filps is protected by the single kernel lock */
1036 spin_lock(&redirect_lock);
1037 if (redirect && redirect->private_data == tty) {
1041 spin_unlock(&redirect_lock);
1043 check_tty_count(tty, "do_tty_hangup");
1045 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1046 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1047 if (filp->f_op->write == redirected_tty_write)
1049 if (filp->f_op->write != tty_write)
1052 tty_fasync(-1, filp, 0); /* can't block */
1053 filp->f_op = &hung_up_tty_fops;
1057 /* FIXME! What are the locking issues here? This may me overdoing things..
1058 * this question is especially important now that we've removed the irqlock. */
1060 ld = tty_ldisc_ref(tty);
1061 if(ld != NULL) /* We may have no line discipline at this point */
1063 if (ld->flush_buffer)
1064 ld->flush_buffer(tty);
1065 if (tty->driver->flush_buffer)
1066 tty->driver->flush_buffer(tty);
1067 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1069 ld->write_wakeup(tty);
1074 /* FIXME: Once we trust the LDISC code better we can wait here for
1075 ldisc completion and fix the driver call race */
1077 wake_up_interruptible(&tty->write_wait);
1078 wake_up_interruptible(&tty->read_wait);
1081 * Shutdown the current line discipline, and reset it to
1084 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1086 down(&tty->termios_sem);
1087 *tty->termios = tty->driver->init_termios;
1088 up(&tty->termios_sem);
1091 /* Defer ldisc switch */
1092 /* tty_deferred_ldisc_switch(N_TTY);
1094 This should get done automatically when the port closes and
1095 tty_release is called */
1097 read_lock(&tasklist_lock);
1098 if (tty->session > 0) {
1099 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1100 if (p->signal->tty == tty)
1101 p->signal->tty = NULL;
1102 if (!p->signal->leader)
1104 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1105 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1107 p->signal->tty_old_pgrp = tty->pgrp;
1108 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1110 read_unlock(&tasklist_lock);
1115 tty->ctrl_status = 0;
1117 * If one of the devices matches a console pointer, we
1118 * cannot just call hangup() because that will cause
1119 * tty->count and state->count to go out of sync.
1120 * So we just call close() the right number of times.
1123 if (tty->driver->close)
1124 for (n = 0; n < closecount; n++)
1125 tty->driver->close(tty, cons_filp);
1126 } else if (tty->driver->hangup)
1127 (tty->driver->hangup)(tty);
1129 /* We don't want to have driver/ldisc interactions beyond
1130 the ones we did here. The driver layer expects no
1131 calls after ->hangup() from the ldisc side. However we
1132 can't yet guarantee all that */
1134 set_bit(TTY_HUPPED, &tty->flags);
1136 tty_ldisc_enable(tty);
1137 tty_ldisc_deref(ld);
1144 void tty_hangup(struct tty_struct * tty)
1146 #ifdef TTY_DEBUG_HANGUP
1149 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1151 schedule_work(&tty->hangup_work);
1154 EXPORT_SYMBOL(tty_hangup);
1156 void tty_vhangup(struct tty_struct * tty)
1158 #ifdef TTY_DEBUG_HANGUP
1161 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1163 do_tty_hangup((void *) tty);
1165 EXPORT_SYMBOL(tty_vhangup);
1167 int tty_hung_up_p(struct file * filp)
1169 return (filp->f_op == &hung_up_tty_fops);
1172 EXPORT_SYMBOL(tty_hung_up_p);
1175 * This function is typically called only by the session leader, when
1176 * it wants to disassociate itself from its controlling tty.
1178 * It performs the following functions:
1179 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1180 * (2) Clears the tty from being controlling the session
1181 * (3) Clears the controlling tty for all processes in the
1184 * The argument on_exit is set to 1 if called when a process is
1185 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1187 void disassociate_ctty(int on_exit)
1189 struct tty_struct *tty;
1190 struct task_struct *p;
1195 mutex_lock(&tty_mutex);
1196 tty = current->signal->tty;
1198 tty_pgrp = tty->pgrp;
1199 mutex_unlock(&tty_mutex);
1200 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1203 if (current->signal->tty_old_pgrp) {
1204 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1205 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1207 mutex_unlock(&tty_mutex);
1212 kill_pg(tty_pgrp, SIGHUP, on_exit);
1214 kill_pg(tty_pgrp, SIGCONT, on_exit);
1217 /* Must lock changes to tty_old_pgrp */
1218 mutex_lock(&tty_mutex);
1219 current->signal->tty_old_pgrp = 0;
1223 /* Now clear signal->tty under the lock */
1224 read_lock(&tasklist_lock);
1225 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1226 p->signal->tty = NULL;
1227 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1228 read_unlock(&tasklist_lock);
1229 mutex_unlock(&tty_mutex);
1233 void stop_tty(struct tty_struct *tty)
1238 if (tty->link && tty->link->packet) {
1239 tty->ctrl_status &= ~TIOCPKT_START;
1240 tty->ctrl_status |= TIOCPKT_STOP;
1241 wake_up_interruptible(&tty->link->read_wait);
1243 if (tty->driver->stop)
1244 (tty->driver->stop)(tty);
1247 EXPORT_SYMBOL(stop_tty);
1249 void start_tty(struct tty_struct *tty)
1251 if (!tty->stopped || tty->flow_stopped)
1254 if (tty->link && tty->link->packet) {
1255 tty->ctrl_status &= ~TIOCPKT_STOP;
1256 tty->ctrl_status |= TIOCPKT_START;
1257 wake_up_interruptible(&tty->link->read_wait);
1259 if (tty->driver->start)
1260 (tty->driver->start)(tty);
1262 /* If we have a running line discipline it may need kicking */
1264 wake_up_interruptible(&tty->write_wait);
1267 EXPORT_SYMBOL(start_tty);
1269 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1273 struct tty_struct * tty;
1274 struct inode *inode;
1275 struct tty_ldisc *ld;
1277 tty = (struct tty_struct *)file->private_data;
1278 inode = file->f_dentry->d_inode;
1279 if (tty_paranoia_check(tty, inode, "tty_read"))
1281 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1284 /* We want to wait for the line discipline to sort out in this
1286 ld = tty_ldisc_ref_wait(tty);
1289 i = (ld->read)(tty,file,buf,count);
1292 tty_ldisc_deref(ld);
1295 inode->i_atime = current_fs_time(inode->i_sb);
1300 * Split writes up in sane blocksizes to avoid
1301 * denial-of-service type attacks
1303 static inline ssize_t do_tty_write(
1304 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1305 struct tty_struct *tty,
1307 const char __user *buf,
1310 ssize_t ret = 0, written = 0;
1313 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1314 return -ERESTARTSYS;
1318 * We chunk up writes into a temporary buffer. This
1319 * simplifies low-level drivers immensely, since they
1320 * don't have locking issues and user mode accesses.
1322 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1325 * The default chunk-size is 2kB, because the NTTY
1326 * layer has problems with bigger chunks. It will
1327 * claim to be able to handle more characters than
1331 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1336 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1337 if (tty->write_cnt < chunk) {
1343 buf = kmalloc(chunk, GFP_KERNEL);
1345 mutex_unlock(&tty->atomic_write_lock);
1348 kfree(tty->write_buf);
1349 tty->write_cnt = chunk;
1350 tty->write_buf = buf;
1353 /* Do the write .. */
1355 size_t size = count;
1359 if (copy_from_user(tty->write_buf, buf, size))
1362 ret = write(tty, file, tty->write_buf, size);
1372 if (signal_pending(current))
1377 struct inode *inode = file->f_dentry->d_inode;
1378 inode->i_mtime = current_fs_time(inode->i_sb);
1381 mutex_unlock(&tty->atomic_write_lock);
1386 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1389 struct tty_struct * tty;
1390 struct inode *inode = file->f_dentry->d_inode;
1392 struct tty_ldisc *ld;
1394 tty = (struct tty_struct *)file->private_data;
1395 if (tty_paranoia_check(tty, inode, "tty_write"))
1397 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1400 ld = tty_ldisc_ref_wait(tty);
1404 ret = do_tty_write(ld->write, tty, file, buf, count);
1405 tty_ldisc_deref(ld);
1409 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1412 struct file *p = NULL;
1414 spin_lock(&redirect_lock);
1419 spin_unlock(&redirect_lock);
1423 res = vfs_write(p, buf, count, &p->f_pos);
1428 return tty_write(file, buf, count, ppos);
1431 static char ptychar[] = "pqrstuvwxyzabcde";
1433 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1435 int i = index + driver->name_base;
1436 /* ->name is initialized to "ttyp", but "tty" is expected */
1437 sprintf(p, "%s%c%x",
1438 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1439 ptychar[i >> 4 & 0xf], i & 0xf);
1442 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1444 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1448 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1449 * failed open. The new code protects the open with a mutex, so it's
1450 * really quite straightforward. The mutex locking can probably be
1451 * relaxed for the (most common) case of reopening a tty.
1453 static int init_dev(struct tty_driver *driver, int idx,
1454 struct tty_struct **ret_tty)
1456 struct tty_struct *tty, *o_tty;
1457 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1458 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1461 /* check whether we're reopening an existing tty */
1462 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1463 tty = devpts_get_tty(idx);
1464 if (tty && driver->subtype == PTY_TYPE_MASTER)
1467 tty = driver->ttys[idx];
1469 if (tty) goto fast_track;
1472 * First time open is complex, especially for PTY devices.
1473 * This code guarantees that either everything succeeds and the
1474 * TTY is ready for operation, or else the table slots are vacated
1475 * and the allocated memory released. (Except that the termios
1476 * and locked termios may be retained.)
1479 if (!try_module_get(driver->owner)) {
1488 tty = alloc_tty_struct();
1491 initialize_tty_struct(tty);
1492 tty->driver = driver;
1494 tty_line_name(driver, idx, tty->name);
1496 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1497 tp_loc = &tty->termios;
1498 ltp_loc = &tty->termios_locked;
1500 tp_loc = &driver->termios[idx];
1501 ltp_loc = &driver->termios_locked[idx];
1505 tp = (struct termios *) kmalloc(sizeof(struct termios),
1509 *tp = driver->init_termios;
1513 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1517 memset(ltp, 0, sizeof(struct termios));
1520 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1521 o_tty = alloc_tty_struct();
1524 initialize_tty_struct(o_tty);
1525 o_tty->driver = driver->other;
1527 tty_line_name(driver->other, idx, o_tty->name);
1529 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1530 o_tp_loc = &o_tty->termios;
1531 o_ltp_loc = &o_tty->termios_locked;
1533 o_tp_loc = &driver->other->termios[idx];
1534 o_ltp_loc = &driver->other->termios_locked[idx];
1538 o_tp = (struct termios *)
1539 kmalloc(sizeof(struct termios), GFP_KERNEL);
1542 *o_tp = driver->other->init_termios;
1546 o_ltp = (struct termios *)
1547 kmalloc(sizeof(struct termios), GFP_KERNEL);
1550 memset(o_ltp, 0, sizeof(struct termios));
1554 * Everything allocated ... set up the o_tty structure.
1556 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1557 driver->other->ttys[idx] = o_tty;
1563 o_tty->termios = *o_tp_loc;
1564 o_tty->termios_locked = *o_ltp_loc;
1565 driver->other->refcount++;
1566 if (driver->subtype == PTY_TYPE_MASTER)
1569 /* Establish the links in both directions */
1575 * All structures have been allocated, so now we install them.
1576 * Failures after this point use release_mem to clean up, so
1577 * there's no need to null out the local pointers.
1579 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1580 driver->ttys[idx] = tty;
1587 tty->termios = *tp_loc;
1588 tty->termios_locked = *ltp_loc;
1593 * Structures all installed ... call the ldisc open routines.
1594 * If we fail here just call release_mem to clean up. No need
1595 * to decrement the use counts, as release_mem doesn't care.
1598 if (tty->ldisc.open) {
1599 retval = (tty->ldisc.open)(tty);
1601 goto release_mem_out;
1603 if (o_tty && o_tty->ldisc.open) {
1604 retval = (o_tty->ldisc.open)(o_tty);
1606 if (tty->ldisc.close)
1607 (tty->ldisc.close)(tty);
1608 goto release_mem_out;
1610 tty_ldisc_enable(o_tty);
1612 tty_ldisc_enable(tty);
1616 * This fast open can be used if the tty is already open.
1617 * No memory is allocated, and the only failures are from
1618 * attempting to open a closing tty or attempting multiple
1619 * opens on a pty master.
1622 if (test_bit(TTY_CLOSING, &tty->flags)) {
1626 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1627 driver->subtype == PTY_TYPE_MASTER) {
1629 * special case for PTY masters: only one open permitted,
1630 * and the slave side open count is incremented as well.
1639 tty->driver = driver; /* N.B. why do this every time?? */
1642 if(!test_bit(TTY_LDISC, &tty->flags))
1643 printk(KERN_ERR "init_dev but no ldisc\n");
1647 /* All paths come through here to release the mutex */
1651 /* Release locally allocated memory ... nothing placed in slots */
1655 free_tty_struct(o_tty);
1658 free_tty_struct(tty);
1661 module_put(driver->owner);
1665 /* call the tty release_mem routine to clean out this slot */
1667 printk(KERN_INFO "init_dev: ldisc open failed, "
1668 "clearing slot %d\n", idx);
1669 release_mem(tty, idx);
1674 * Releases memory associated with a tty structure, and clears out the
1675 * driver table slots.
1677 static void release_mem(struct tty_struct *tty, int idx)
1679 struct tty_struct *o_tty;
1681 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1683 if ((o_tty = tty->link) != NULL) {
1685 o_tty->driver->ttys[idx] = NULL;
1686 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1687 tp = o_tty->termios;
1689 o_tty->driver->termios[idx] = NULL;
1692 tp = o_tty->termios_locked;
1694 o_tty->driver->termios_locked[idx] = NULL;
1698 o_tty->driver->refcount--;
1700 list_del_init(&o_tty->tty_files);
1702 free_tty_struct(o_tty);
1706 tty->driver->ttys[idx] = NULL;
1707 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1710 tty->driver->termios[idx] = NULL;
1713 tp = tty->termios_locked;
1715 tty->driver->termios_locked[idx] = NULL;
1720 tty->driver->refcount--;
1722 list_del_init(&tty->tty_files);
1724 module_put(tty->driver->owner);
1725 free_tty_struct(tty);
1729 * Even releasing the tty structures is a tricky business.. We have
1730 * to be very careful that the structures are all released at the
1731 * same time, as interrupts might otherwise get the wrong pointers.
1733 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1734 * lead to double frees or releasing memory still in use.
1736 static void release_dev(struct file * filp)
1738 struct tty_struct *tty, *o_tty;
1739 int pty_master, tty_closing, o_tty_closing, do_sleep;
1743 unsigned long flags;
1745 tty = (struct tty_struct *)filp->private_data;
1746 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1749 check_tty_count(tty, "release_dev");
1751 tty_fasync(-1, filp, 0);
1754 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1755 tty->driver->subtype == PTY_TYPE_MASTER);
1756 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1759 #ifdef TTY_PARANOIA_CHECK
1760 if (idx < 0 || idx >= tty->driver->num) {
1761 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1762 "free (%s)\n", tty->name);
1765 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1766 if (tty != tty->driver->ttys[idx]) {
1767 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1768 "for (%s)\n", idx, tty->name);
1771 if (tty->termios != tty->driver->termios[idx]) {
1772 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1777 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1778 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1779 "termios_locked for (%s)\n",
1786 #ifdef TTY_DEBUG_HANGUP
1787 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1788 tty_name(tty, buf), tty->count);
1791 #ifdef TTY_PARANOIA_CHECK
1792 if (tty->driver->other &&
1793 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1794 if (o_tty != tty->driver->other->ttys[idx]) {
1795 printk(KERN_DEBUG "release_dev: other->table[%d] "
1796 "not o_tty for (%s)\n",
1800 if (o_tty->termios != tty->driver->other->termios[idx]) {
1801 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1802 "not o_termios for (%s)\n",
1806 if (o_tty->termios_locked !=
1807 tty->driver->other->termios_locked[idx]) {
1808 printk(KERN_DEBUG "release_dev: other->termios_locked["
1809 "%d] not o_termios_locked for (%s)\n",
1813 if (o_tty->link != tty) {
1814 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1819 if (tty->driver->close)
1820 tty->driver->close(tty, filp);
1823 * Sanity check: if tty->count is going to zero, there shouldn't be
1824 * any waiters on tty->read_wait or tty->write_wait. We test the
1825 * wait queues and kick everyone out _before_ actually starting to
1826 * close. This ensures that we won't block while releasing the tty
1829 * The test for the o_tty closing is necessary, since the master and
1830 * slave sides may close in any order. If the slave side closes out
1831 * first, its count will be one, since the master side holds an open.
1832 * Thus this test wouldn't be triggered at the time the slave closes,
1835 * Note that it's possible for the tty to be opened again while we're
1836 * flushing out waiters. By recalculating the closing flags before
1837 * each iteration we avoid any problems.
1840 /* Guard against races with tty->count changes elsewhere and
1841 opens on /dev/tty */
1843 mutex_lock(&tty_mutex);
1844 tty_closing = tty->count <= 1;
1845 o_tty_closing = o_tty &&
1846 (o_tty->count <= (pty_master ? 1 : 0));
1850 if (waitqueue_active(&tty->read_wait)) {
1851 wake_up(&tty->read_wait);
1854 if (waitqueue_active(&tty->write_wait)) {
1855 wake_up(&tty->write_wait);
1859 if (o_tty_closing) {
1860 if (waitqueue_active(&o_tty->read_wait)) {
1861 wake_up(&o_tty->read_wait);
1864 if (waitqueue_active(&o_tty->write_wait)) {
1865 wake_up(&o_tty->write_wait);
1872 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1873 "active!\n", tty_name(tty, buf));
1874 mutex_unlock(&tty_mutex);
1879 * The closing flags are now consistent with the open counts on
1880 * both sides, and we've completed the last operation that could
1881 * block, so it's safe to proceed with closing.
1884 if (--o_tty->count < 0) {
1885 printk(KERN_WARNING "release_dev: bad pty slave count "
1887 o_tty->count, tty_name(o_tty, buf));
1891 if (--tty->count < 0) {
1892 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1893 tty->count, tty_name(tty, buf));
1898 * We've decremented tty->count, so we need to remove this file
1899 * descriptor off the tty->tty_files list; this serves two
1901 * - check_tty_count sees the correct number of file descriptors
1902 * associated with this tty.
1903 * - do_tty_hangup no longer sees this file descriptor as
1904 * something that needs to be handled for hangups.
1907 filp->private_data = NULL;
1910 * Perform some housekeeping before deciding whether to return.
1912 * Set the TTY_CLOSING flag if this was the last open. In the
1913 * case of a pty we may have to wait around for the other side
1914 * to close, and TTY_CLOSING makes sure we can't be reopened.
1917 set_bit(TTY_CLOSING, &tty->flags);
1919 set_bit(TTY_CLOSING, &o_tty->flags);
1922 * If _either_ side is closing, make sure there aren't any
1923 * processes that still think tty or o_tty is their controlling
1926 if (tty_closing || o_tty_closing) {
1927 struct task_struct *p;
1929 read_lock(&tasklist_lock);
1930 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1931 p->signal->tty = NULL;
1932 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1934 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1935 p->signal->tty = NULL;
1936 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1937 read_unlock(&tasklist_lock);
1940 mutex_unlock(&tty_mutex);
1942 /* check whether both sides are closing ... */
1943 if (!tty_closing || (o_tty && !o_tty_closing))
1946 #ifdef TTY_DEBUG_HANGUP
1947 printk(KERN_DEBUG "freeing tty structure...");
1950 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1951 * kill any delayed work. As this is the final close it does not
1952 * race with the set_ldisc code path.
1954 clear_bit(TTY_LDISC, &tty->flags);
1955 cancel_delayed_work(&tty->buf.work);
1958 * Wait for ->hangup_work and ->buf.work handlers to terminate
1961 flush_scheduled_work();
1964 * Wait for any short term users (we know they are just driver
1965 * side waiters as the file is closing so user count on the file
1968 spin_lock_irqsave(&tty_ldisc_lock, flags);
1969 while(tty->ldisc.refcount)
1971 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1972 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1973 spin_lock_irqsave(&tty_ldisc_lock, flags);
1975 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1977 * Shutdown the current line discipline, and reset it to N_TTY.
1978 * N.B. why reset ldisc when we're releasing the memory??
1980 * FIXME: this MUST get fixed for the new reflocking
1982 if (tty->ldisc.close)
1983 (tty->ldisc.close)(tty);
1984 tty_ldisc_put(tty->ldisc.num);
1987 * Switch the line discipline back
1989 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1990 tty_set_termios_ldisc(tty,N_TTY);
1992 /* FIXME: could o_tty be in setldisc here ? */
1993 clear_bit(TTY_LDISC, &o_tty->flags);
1994 if (o_tty->ldisc.close)
1995 (o_tty->ldisc.close)(o_tty);
1996 tty_ldisc_put(o_tty->ldisc.num);
1997 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1998 tty_set_termios_ldisc(o_tty,N_TTY);
2001 * The release_mem function takes care of the details of clearing
2002 * the slots and preserving the termios structure.
2004 release_mem(tty, idx);
2006 #ifdef CONFIG_UNIX98_PTYS
2007 /* Make this pty number available for reallocation */
2009 down(&allocated_ptys_lock);
2010 idr_remove(&allocated_ptys, idx);
2011 up(&allocated_ptys_lock);
2018 * tty_open and tty_release keep up the tty count that contains the
2019 * number of opens done on a tty. We cannot use the inode-count, as
2020 * different inodes might point to the same tty.
2022 * Open-counting is needed for pty masters, as well as for keeping
2023 * track of serial lines: DTR is dropped when the last close happens.
2024 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2026 * The termios state of a pty is reset on first open so that
2027 * settings don't persist across reuse.
2029 static int tty_open(struct inode * inode, struct file * filp)
2031 struct tty_struct *tty;
2033 struct tty_driver *driver;
2035 dev_t device = inode->i_rdev;
2036 unsigned short saved_flags = filp->f_flags;
2038 nonseekable_open(inode, filp);
2041 noctty = filp->f_flags & O_NOCTTY;
2045 mutex_lock(&tty_mutex);
2047 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2048 if (!current->signal->tty) {
2049 mutex_unlock(&tty_mutex);
2052 driver = current->signal->tty->driver;
2053 index = current->signal->tty->index;
2054 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2059 if (device == MKDEV(TTY_MAJOR,0)) {
2060 extern struct tty_driver *console_driver;
2061 driver = console_driver;
2067 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2068 driver = console_device(&index);
2070 /* Don't let /dev/console block */
2071 filp->f_flags |= O_NONBLOCK;
2075 mutex_unlock(&tty_mutex);
2079 driver = get_tty_driver(device, &index);
2081 mutex_unlock(&tty_mutex);
2085 retval = init_dev(driver, index, &tty);
2086 mutex_unlock(&tty_mutex);
2090 filp->private_data = tty;
2091 file_move(filp, &tty->tty_files);
2092 check_tty_count(tty, "tty_open");
2093 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2094 tty->driver->subtype == PTY_TYPE_MASTER)
2096 #ifdef TTY_DEBUG_HANGUP
2097 printk(KERN_DEBUG "opening %s...", tty->name);
2100 if (tty->driver->open)
2101 retval = tty->driver->open(tty, filp);
2105 filp->f_flags = saved_flags;
2107 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2111 #ifdef TTY_DEBUG_HANGUP
2112 printk(KERN_DEBUG "error %d in opening %s...", retval,
2116 if (retval != -ERESTARTSYS)
2118 if (signal_pending(current))
2122 * Need to reset f_op in case a hangup happened.
2124 if (filp->f_op == &hung_up_tty_fops)
2125 filp->f_op = &tty_fops;
2129 current->signal->leader &&
2130 !current->signal->tty &&
2131 tty->session == 0) {
2133 current->signal->tty = tty;
2134 task_unlock(current);
2135 current->signal->tty_old_pgrp = 0;
2136 tty->session = current->signal->session;
2137 tty->pgrp = process_group(current);
2142 #ifdef CONFIG_UNIX98_PTYS
2143 static int ptmx_open(struct inode * inode, struct file * filp)
2145 struct tty_struct *tty;
2150 nonseekable_open(inode, filp);
2152 /* find a device that is not in use. */
2153 down(&allocated_ptys_lock);
2154 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2155 up(&allocated_ptys_lock);
2158 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2160 up(&allocated_ptys_lock);
2161 if (idr_ret == -EAGAIN)
2165 if (index >= pty_limit) {
2166 idr_remove(&allocated_ptys, index);
2167 up(&allocated_ptys_lock);
2170 up(&allocated_ptys_lock);
2172 mutex_lock(&tty_mutex);
2173 retval = init_dev(ptm_driver, index, &tty);
2174 mutex_unlock(&tty_mutex);
2179 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2180 filp->private_data = tty;
2181 file_move(filp, &tty->tty_files);
2184 if (devpts_pty_new(tty->link))
2187 check_tty_count(tty, "tty_open");
2188 retval = ptm_driver->open(tty, filp);
2195 down(&allocated_ptys_lock);
2196 idr_remove(&allocated_ptys, index);
2197 up(&allocated_ptys_lock);
2202 static int tty_release(struct inode * inode, struct file * filp)
2210 /* No kernel lock held - fine */
2211 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2213 struct tty_struct * tty;
2214 struct tty_ldisc *ld;
2217 tty = (struct tty_struct *)filp->private_data;
2218 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2221 ld = tty_ldisc_ref_wait(tty);
2223 ret = (ld->poll)(tty, filp, wait);
2224 tty_ldisc_deref(ld);
2228 static int tty_fasync(int fd, struct file * filp, int on)
2230 struct tty_struct * tty;
2233 tty = (struct tty_struct *)filp->private_data;
2234 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2237 retval = fasync_helper(fd, filp, on, &tty->fasync);
2242 if (!waitqueue_active(&tty->read_wait))
2243 tty->minimum_to_wake = 1;
2244 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2248 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2249 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2254 static int tiocsti(struct tty_struct *tty, char __user *p)
2257 struct tty_ldisc *ld;
2259 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2261 if (get_user(ch, p))
2263 ld = tty_ldisc_ref_wait(tty);
2264 ld->receive_buf(tty, &ch, &mbz, 1);
2265 tty_ldisc_deref(ld);
2269 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2271 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2276 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2277 struct winsize __user * arg)
2279 struct winsize tmp_ws;
2281 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2283 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2286 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2289 acquire_console_sem();
2290 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2291 release_console_sem();
2297 kill_pg(tty->pgrp, SIGWINCH, 1);
2298 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2299 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2300 tty->winsize = tmp_ws;
2301 real_tty->winsize = tmp_ws;
2305 static int tioccons(struct file *file)
2307 if (!capable(CAP_SYS_ADMIN))
2309 if (file->f_op->write == redirected_tty_write) {
2311 spin_lock(&redirect_lock);
2314 spin_unlock(&redirect_lock);
2319 spin_lock(&redirect_lock);
2321 spin_unlock(&redirect_lock);
2326 spin_unlock(&redirect_lock);
2331 static int fionbio(struct file *file, int __user *p)
2335 if (get_user(nonblock, p))
2339 file->f_flags |= O_NONBLOCK;
2341 file->f_flags &= ~O_NONBLOCK;
2345 static int tiocsctty(struct tty_struct *tty, int arg)
2349 if (current->signal->leader &&
2350 (current->signal->session == tty->session))
2353 * The process must be a session leader and
2354 * not have a controlling tty already.
2356 if (!current->signal->leader || current->signal->tty)
2358 if (tty->session > 0) {
2360 * This tty is already the controlling
2361 * tty for another session group!
2363 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2368 read_lock(&tasklist_lock);
2369 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2370 p->signal->tty = NULL;
2371 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2372 read_unlock(&tasklist_lock);
2377 current->signal->tty = tty;
2378 task_unlock(current);
2379 current->signal->tty_old_pgrp = 0;
2380 tty->session = current->signal->session;
2381 tty->pgrp = process_group(current);
2385 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2388 * (tty == real_tty) is a cheap way of
2389 * testing if the tty is NOT a master pty.
2391 if (tty == real_tty && current->signal->tty != real_tty)
2393 return put_user(real_tty->pgrp, p);
2396 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2399 int retval = tty_check_change(real_tty);
2405 if (!current->signal->tty ||
2406 (current->signal->tty != real_tty) ||
2407 (real_tty->session != current->signal->session))
2409 if (get_user(pgrp, p))
2413 if (session_of_pgrp(pgrp) != current->signal->session)
2415 real_tty->pgrp = pgrp;
2419 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2422 * (tty == real_tty) is a cheap way of
2423 * testing if the tty is NOT a master pty.
2425 if (tty == real_tty && current->signal->tty != real_tty)
2427 if (real_tty->session <= 0)
2429 return put_user(real_tty->session, p);
2432 static int tiocsetd(struct tty_struct *tty, int __user *p)
2436 if (get_user(ldisc, p))
2438 return tty_set_ldisc(tty, ldisc);
2441 static int send_break(struct tty_struct *tty, unsigned int duration)
2443 tty->driver->break_ctl(tty, -1);
2444 if (!signal_pending(current)) {
2445 msleep_interruptible(duration);
2447 tty->driver->break_ctl(tty, 0);
2448 if (signal_pending(current))
2454 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2456 int retval = -EINVAL;
2458 if (tty->driver->tiocmget) {
2459 retval = tty->driver->tiocmget(tty, file);
2462 retval = put_user(retval, p);
2468 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2471 int retval = -EINVAL;
2473 if (tty->driver->tiocmset) {
2474 unsigned int set, clear, val;
2476 retval = get_user(val, p);
2494 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2495 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2497 retval = tty->driver->tiocmset(tty, file, set, clear);
2503 * Split this up, as gcc can choke on it otherwise..
2505 int tty_ioctl(struct inode * inode, struct file * file,
2506 unsigned int cmd, unsigned long arg)
2508 struct tty_struct *tty, *real_tty;
2509 void __user *p = (void __user *)arg;
2511 struct tty_ldisc *ld;
2513 tty = (struct tty_struct *)file->private_data;
2514 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2518 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2519 tty->driver->subtype == PTY_TYPE_MASTER)
2520 real_tty = tty->link;
2523 * Break handling by driver
2525 if (!tty->driver->break_ctl) {
2529 if (tty->driver->ioctl)
2530 return tty->driver->ioctl(tty, file, cmd, arg);
2533 /* These two ioctl's always return success; even if */
2534 /* the driver doesn't support them. */
2537 if (!tty->driver->ioctl)
2539 retval = tty->driver->ioctl(tty, file, cmd, arg);
2540 if (retval == -ENOIOCTLCMD)
2547 * Factor out some common prep work
2555 retval = tty_check_change(tty);
2558 if (cmd != TIOCCBRK) {
2559 tty_wait_until_sent(tty, 0);
2560 if (signal_pending(current))
2568 return tiocsti(tty, p);
2570 return tiocgwinsz(tty, p);
2572 return tiocswinsz(tty, real_tty, p);
2574 return real_tty!=tty ? -EINVAL : tioccons(file);
2576 return fionbio(file, p);
2578 set_bit(TTY_EXCLUSIVE, &tty->flags);
2581 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2584 if (current->signal->tty != tty)
2586 if (current->signal->leader)
2587 disassociate_ctty(0);
2589 current->signal->tty = NULL;
2590 task_unlock(current);
2593 return tiocsctty(tty, arg);
2595 return tiocgpgrp(tty, real_tty, p);
2597 return tiocspgrp(tty, real_tty, p);
2599 return tiocgsid(tty, real_tty, p);
2601 /* FIXME: check this is ok */
2602 return put_user(tty->ldisc.num, (int __user *)p);
2604 return tiocsetd(tty, p);
2607 return tioclinux(tty, arg);
2612 case TIOCSBRK: /* Turn break on, unconditionally */
2613 tty->driver->break_ctl(tty, -1);
2616 case TIOCCBRK: /* Turn break off, unconditionally */
2617 tty->driver->break_ctl(tty, 0);
2619 case TCSBRK: /* SVID version: non-zero arg --> no break */
2620 /* non-zero arg means wait for all output data
2621 * to be sent (performed above) but don't send break.
2622 * This is used by the tcdrain() termios function.
2625 return send_break(tty, 250);
2627 case TCSBRKP: /* support for POSIX tcsendbreak() */
2628 return send_break(tty, arg ? arg*100 : 250);
2631 return tty_tiocmget(tty, file, p);
2636 return tty_tiocmset(tty, file, cmd, p);
2638 if (tty->driver->ioctl) {
2639 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2640 if (retval != -ENOIOCTLCMD)
2643 ld = tty_ldisc_ref_wait(tty);
2646 retval = ld->ioctl(tty, file, cmd, arg);
2647 if (retval == -ENOIOCTLCMD)
2650 tty_ldisc_deref(ld);
2656 * This implements the "Secure Attention Key" --- the idea is to
2657 * prevent trojan horses by killing all processes associated with this
2658 * tty when the user hits the "Secure Attention Key". Required for
2659 * super-paranoid applications --- see the Orange Book for more details.
2661 * This code could be nicer; ideally it should send a HUP, wait a few
2662 * seconds, then send a INT, and then a KILL signal. But you then
2663 * have to coordinate with the init process, since all processes associated
2664 * with the current tty must be dead before the new getty is allowed
2667 * Now, if it would be correct ;-/ The current code has a nasty hole -
2668 * it doesn't catch files in flight. We may send the descriptor to ourselves
2669 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2671 * Nasty bug: do_SAK is being called in interrupt context. This can
2672 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2674 static void __do_SAK(void *arg)
2679 struct tty_struct *tty = arg;
2680 struct task_struct *g, *p;
2684 struct tty_ldisc *disc;
2685 struct fdtable *fdt;
2689 session = tty->session;
2691 /* We don't want an ldisc switch during this */
2692 disc = tty_ldisc_ref(tty);
2693 if (disc && disc->flush_buffer)
2694 disc->flush_buffer(tty);
2695 tty_ldisc_deref(disc);
2697 if (tty->driver->flush_buffer)
2698 tty->driver->flush_buffer(tty);
2700 read_lock(&tasklist_lock);
2701 /* Kill the entire session */
2702 do_each_task_pid(session, PIDTYPE_SID, p) {
2703 printk(KERN_NOTICE "SAK: killed process %d"
2704 " (%s): p->signal->session==tty->session\n",
2706 send_sig(SIGKILL, p, 1);
2707 } while_each_task_pid(session, PIDTYPE_SID, p);
2708 /* Now kill any processes that happen to have the
2711 do_each_thread(g, p) {
2712 if (p->signal->tty == tty) {
2713 printk(KERN_NOTICE "SAK: killed process %d"
2714 " (%s): p->signal->session==tty->session\n",
2716 send_sig(SIGKILL, p, 1);
2722 * We don't take a ref to the file, so we must
2723 * hold ->file_lock instead.
2725 spin_lock(&p->files->file_lock);
2726 fdt = files_fdtable(p->files);
2727 for (i=0; i < fdt->max_fds; i++) {
2728 filp = fcheck_files(p->files, i);
2731 if (filp->f_op->read == tty_read &&
2732 filp->private_data == tty) {
2733 printk(KERN_NOTICE "SAK: killed process %d"
2734 " (%s): fd#%d opened to the tty\n",
2735 p->pid, p->comm, i);
2736 force_sig(SIGKILL, p);
2740 spin_unlock(&p->files->file_lock);
2743 } while_each_thread(g, p);
2744 read_unlock(&tasklist_lock);
2749 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2750 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2751 * the values which we write to it will be identical to the values which it
2752 * already has. --akpm
2754 void do_SAK(struct tty_struct *tty)
2758 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2759 schedule_work(&tty->SAK_work);
2762 EXPORT_SYMBOL(do_SAK);
2765 * This routine is called out of the software interrupt to flush data
2766 * from the buffer chain to the line discipline.
2769 static void flush_to_ldisc(void *private_)
2771 struct tty_struct *tty = (struct tty_struct *) private_;
2772 unsigned long flags;
2773 struct tty_ldisc *disc;
2774 struct tty_buffer *tbuf, *head;
2776 unsigned char *flag_buf;
2778 disc = tty_ldisc_ref(tty);
2779 if (disc == NULL) /* !TTY_LDISC */
2782 spin_lock_irqsave(&tty->buf.lock, flags);
2783 head = tty->buf.head;
2785 tty->buf.head = NULL;
2787 int count = head->commit - head->read;
2789 if (head->next == NULL)
2793 tty_buffer_free(tty, tbuf);
2796 if (!tty->receive_room) {
2797 schedule_delayed_work(&tty->buf.work, 1);
2800 if (count > tty->receive_room)
2801 count = tty->receive_room;
2802 char_buf = head->char_buf_ptr + head->read;
2803 flag_buf = head->flag_buf_ptr + head->read;
2804 head->read += count;
2805 spin_unlock_irqrestore(&tty->buf.lock, flags);
2806 disc->receive_buf(tty, char_buf, flag_buf, count);
2807 spin_lock_irqsave(&tty->buf.lock, flags);
2809 tty->buf.head = head;
2811 spin_unlock_irqrestore(&tty->buf.lock, flags);
2813 tty_ldisc_deref(disc);
2817 * Routine which returns the baud rate of the tty
2819 * Note that the baud_table needs to be kept in sync with the
2820 * include/asm/termbits.h file.
2822 static int baud_table[] = {
2823 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2824 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2826 76800, 153600, 307200, 614400, 921600
2828 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2829 2500000, 3000000, 3500000, 4000000
2833 static int n_baud_table = ARRAY_SIZE(baud_table);
2836 * tty_termios_baud_rate
2837 * @termios: termios structure
2839 * Convert termios baud rate data into a speed. This should be called
2840 * with the termios lock held if this termios is a terminal termios
2841 * structure. May change the termios data.
2844 int tty_termios_baud_rate(struct termios *termios)
2848 cbaud = termios->c_cflag & CBAUD;
2850 if (cbaud & CBAUDEX) {
2853 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2854 termios->c_cflag &= ~CBAUDEX;
2858 return baud_table[cbaud];
2861 EXPORT_SYMBOL(tty_termios_baud_rate);
2864 * tty_get_baud_rate - get tty bit rates
2865 * @tty: tty to query
2867 * Returns the baud rate as an integer for this terminal. The
2868 * termios lock must be held by the caller and the terminal bit
2869 * flags may be updated.
2872 int tty_get_baud_rate(struct tty_struct *tty)
2874 int baud = tty_termios_baud_rate(tty->termios);
2876 if (baud == 38400 && tty->alt_speed) {
2878 printk(KERN_WARNING "Use of setserial/setrocket to "
2879 "set SPD_* flags is deprecated\n");
2882 baud = tty->alt_speed;
2888 EXPORT_SYMBOL(tty_get_baud_rate);
2891 * tty_flip_buffer_push - terminal
2894 * Queue a push of the terminal flip buffers to the line discipline. This
2895 * function must not be called from IRQ context if tty->low_latency is set.
2897 * In the event of the queue being busy for flipping the work will be
2898 * held off and retried later.
2901 void tty_flip_buffer_push(struct tty_struct *tty)
2903 unsigned long flags;
2904 spin_lock_irqsave(&tty->buf.lock, flags);
2905 if (tty->buf.tail != NULL) {
2906 tty->buf.tail->active = 0;
2907 tty->buf.tail->commit = tty->buf.tail->used;
2909 spin_unlock_irqrestore(&tty->buf.lock, flags);
2911 if (tty->low_latency)
2912 flush_to_ldisc((void *) tty);
2914 schedule_delayed_work(&tty->buf.work, 1);
2917 EXPORT_SYMBOL(tty_flip_buffer_push);
2921 * This subroutine initializes a tty structure.
2923 static void initialize_tty_struct(struct tty_struct *tty)
2925 memset(tty, 0, sizeof(struct tty_struct));
2926 tty->magic = TTY_MAGIC;
2927 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2929 tty->overrun_time = jiffies;
2930 tty->buf.head = tty->buf.tail = NULL;
2931 tty_buffer_init(tty);
2932 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
2933 init_MUTEX(&tty->buf.pty_sem);
2934 init_MUTEX(&tty->termios_sem);
2935 init_waitqueue_head(&tty->write_wait);
2936 init_waitqueue_head(&tty->read_wait);
2937 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2938 mutex_init(&tty->atomic_read_lock);
2939 mutex_init(&tty->atomic_write_lock);
2940 spin_lock_init(&tty->read_lock);
2941 INIT_LIST_HEAD(&tty->tty_files);
2942 INIT_WORK(&tty->SAK_work, NULL, NULL);
2946 * The default put_char routine if the driver did not define one.
2948 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2950 tty->driver->write(tty, &ch, 1);
2953 static struct class *tty_class;
2956 * tty_register_device - register a tty device
2957 * @driver: the tty driver that describes the tty device
2958 * @index: the index in the tty driver for this tty device
2959 * @device: a struct device that is associated with this tty device.
2960 * This field is optional, if there is no known struct device for this
2961 * tty device it can be set to NULL safely.
2963 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
2965 * This call is required to be made to register an individual tty device if
2966 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2967 * bit is not set, this function should not be called.
2969 struct class_device *tty_register_device(struct tty_driver *driver,
2970 unsigned index, struct device *device)
2973 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2975 if (index >= driver->num) {
2976 printk(KERN_ERR "Attempt to register invalid tty line number "
2978 return ERR_PTR(-EINVAL);
2981 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2982 "%s%d", driver->devfs_name, index + driver->name_base);
2984 if (driver->type == TTY_DRIVER_TYPE_PTY)
2985 pty_line_name(driver, index, name);
2987 tty_line_name(driver, index, name);
2989 return class_device_create(tty_class, NULL, dev, device, "%s", name);
2993 * tty_unregister_device - unregister a tty device
2994 * @driver: the tty driver that describes the tty device
2995 * @index: the index in the tty driver for this tty device
2997 * If a tty device is registered with a call to tty_register_device() then
2998 * this function must be made when the tty device is gone.
3000 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3002 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
3003 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3006 EXPORT_SYMBOL(tty_register_device);
3007 EXPORT_SYMBOL(tty_unregister_device);
3009 struct tty_driver *alloc_tty_driver(int lines)
3011 struct tty_driver *driver;
3013 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3015 memset(driver, 0, sizeof(struct tty_driver));
3016 driver->magic = TTY_DRIVER_MAGIC;
3017 driver->num = lines;
3018 /* later we'll move allocation of tables here */
3023 void put_tty_driver(struct tty_driver *driver)
3028 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3030 driver->open = op->open;
3031 driver->close = op->close;
3032 driver->write = op->write;
3033 driver->put_char = op->put_char;
3034 driver->flush_chars = op->flush_chars;
3035 driver->write_room = op->write_room;
3036 driver->chars_in_buffer = op->chars_in_buffer;
3037 driver->ioctl = op->ioctl;
3038 driver->set_termios = op->set_termios;
3039 driver->throttle = op->throttle;
3040 driver->unthrottle = op->unthrottle;
3041 driver->stop = op->stop;
3042 driver->start = op->start;
3043 driver->hangup = op->hangup;
3044 driver->break_ctl = op->break_ctl;
3045 driver->flush_buffer = op->flush_buffer;
3046 driver->set_ldisc = op->set_ldisc;
3047 driver->wait_until_sent = op->wait_until_sent;
3048 driver->send_xchar = op->send_xchar;
3049 driver->read_proc = op->read_proc;
3050 driver->write_proc = op->write_proc;
3051 driver->tiocmget = op->tiocmget;
3052 driver->tiocmset = op->tiocmset;
3056 EXPORT_SYMBOL(alloc_tty_driver);
3057 EXPORT_SYMBOL(put_tty_driver);
3058 EXPORT_SYMBOL(tty_set_operations);
3061 * Called by a tty driver to register itself.
3063 int tty_register_driver(struct tty_driver *driver)
3070 if (driver->flags & TTY_DRIVER_INSTALLED)
3073 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3074 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3077 memset(p, 0, driver->num * 3 * sizeof(void *));
3080 if (!driver->major) {
3081 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3082 (char*)driver->name);
3084 driver->major = MAJOR(dev);
3085 driver->minor_start = MINOR(dev);
3088 dev = MKDEV(driver->major, driver->minor_start);
3089 error = register_chrdev_region(dev, driver->num,
3090 (char*)driver->name);
3098 driver->ttys = (struct tty_struct **)p;
3099 driver->termios = (struct termios **)(p + driver->num);
3100 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3102 driver->ttys = NULL;
3103 driver->termios = NULL;
3104 driver->termios_locked = NULL;
3107 cdev_init(&driver->cdev, &tty_fops);
3108 driver->cdev.owner = driver->owner;
3109 error = cdev_add(&driver->cdev, dev, driver->num);
3111 cdev_del(&driver->cdev);
3112 unregister_chrdev_region(dev, driver->num);
3113 driver->ttys = NULL;
3114 driver->termios = driver->termios_locked = NULL;
3119 if (!driver->put_char)
3120 driver->put_char = tty_default_put_char;
3122 list_add(&driver->tty_drivers, &tty_drivers);
3124 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
3125 for(i = 0; i < driver->num; i++)
3126 tty_register_device(driver, i, NULL);
3128 proc_tty_register_driver(driver);
3132 EXPORT_SYMBOL(tty_register_driver);
3135 * Called by a tty driver to unregister itself.
3137 int tty_unregister_driver(struct tty_driver *driver)
3143 if (driver->refcount)
3146 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3149 list_del(&driver->tty_drivers);
3152 * Free the termios and termios_locked structures because
3153 * we don't want to get memory leaks when modular tty
3154 * drivers are removed from the kernel.
3156 for (i = 0; i < driver->num; i++) {
3157 tp = driver->termios[i];
3159 driver->termios[i] = NULL;
3162 tp = driver->termios_locked[i];
3164 driver->termios_locked[i] = NULL;
3167 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
3168 tty_unregister_device(driver, i);
3171 proc_tty_unregister_driver(driver);
3172 driver->ttys = NULL;
3173 driver->termios = driver->termios_locked = NULL;
3175 cdev_del(&driver->cdev);
3179 EXPORT_SYMBOL(tty_unregister_driver);
3183 * Initialize the console device. This is called *early*, so
3184 * we can't necessarily depend on lots of kernel help here.
3185 * Just do some early initializations, and do the complex setup
3188 void __init console_init(void)
3192 /* Setup the default TTY line discipline. */
3193 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3196 * set up the console device so that later boot sequences can
3197 * inform about problems etc..
3199 #ifdef CONFIG_EARLY_PRINTK
3200 disable_early_printk();
3202 call = __con_initcall_start;
3203 while (call < __con_initcall_end) {
3210 extern int vty_init(void);
3213 static int __init tty_class_init(void)
3215 tty_class = class_create(THIS_MODULE, "tty");
3216 if (IS_ERR(tty_class))
3217 return PTR_ERR(tty_class);
3221 postcore_initcall(tty_class_init);
3223 /* 3/2004 jmc: why do these devices exist? */
3225 static struct cdev tty_cdev, console_cdev;
3226 #ifdef CONFIG_UNIX98_PTYS
3227 static struct cdev ptmx_cdev;
3230 static struct cdev vc0_cdev;
3234 * Ok, now we can initialize the rest of the tty devices and can count
3235 * on memory allocations, interrupts etc..
3237 static int __init tty_init(void)
3239 cdev_init(&tty_cdev, &tty_fops);
3240 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3241 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3242 panic("Couldn't register /dev/tty driver\n");
3243 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
3244 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3246 cdev_init(&console_cdev, &console_fops);
3247 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3248 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3249 panic("Couldn't register /dev/console driver\n");
3250 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
3251 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3253 #ifdef CONFIG_UNIX98_PTYS
3254 cdev_init(&ptmx_cdev, &ptmx_fops);
3255 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3256 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3257 panic("Couldn't register /dev/ptmx driver\n");
3258 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
3259 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3263 cdev_init(&vc0_cdev, &console_fops);
3264 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3265 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3266 panic("Couldn't register /dev/tty0 driver\n");
3267 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3268 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3274 module_init(tty_init);