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>
106 #include <linux/vs_cvirt.h>
108 #include <linux/kmod.h>
110 #undef TTY_DEBUG_HANGUP
112 #define TTY_PARANOIA_CHECK 1
113 #define CHECK_TTY_COUNT 1
115 struct termios tty_std_termios = { /* for the benefit of tty drivers */
116 .c_iflag = ICRNL | IXON,
117 .c_oflag = OPOST | ONLCR,
118 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
119 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
120 ECHOCTL | ECHOKE | IEXTEN,
124 EXPORT_SYMBOL(tty_std_termios);
126 /* This list gets poked at by procfs and various bits of boot up code. This
127 could do with some rationalisation such as pulling the tty proc function
130 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
132 /* Semaphore to protect creating and releasing a tty. This is shared with
133 vt.c for deeply disgusting hack reasons */
134 DEFINE_MUTEX(tty_mutex);
136 #ifdef CONFIG_UNIX98_PTYS
137 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
138 extern int pty_limit; /* Config limit on Unix98 ptys */
139 static DEFINE_IDR(allocated_ptys);
140 static DECLARE_MUTEX(allocated_ptys_lock);
141 static int ptmx_open(struct inode *, struct file *);
144 extern void disable_early_printk(void);
146 static void initialize_tty_struct(struct tty_struct *tty);
148 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
149 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
150 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
151 static unsigned int tty_poll(struct file *, poll_table *);
152 static int tty_open(struct inode *, struct file *);
153 static int tty_release(struct inode *, struct file *);
154 int tty_ioctl(struct inode * inode, struct file * file,
155 unsigned int cmd, unsigned long arg);
156 static int tty_fasync(int fd, struct file * filp, int on);
157 static void release_mem(struct tty_struct *tty, int idx);
160 static struct tty_struct *alloc_tty_struct(void)
162 struct tty_struct *tty;
164 tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
166 memset(tty, 0, sizeof(struct tty_struct));
170 static void tty_buffer_free_all(struct tty_struct *);
172 static inline void free_tty_struct(struct tty_struct *tty)
174 kfree(tty->write_buf);
175 tty_buffer_free_all(tty);
179 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
181 char *tty_name(struct tty_struct *tty, char *buf)
183 if (!tty) /* Hmm. NULL pointer. That's fun. */
184 strcpy(buf, "NULL tty");
186 strcpy(buf, tty->name);
190 EXPORT_SYMBOL(tty_name);
192 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
195 #ifdef TTY_PARANOIA_CHECK
198 "null TTY for (%d:%d) in %s\n",
199 imajor(inode), iminor(inode), routine);
202 if (tty->magic != TTY_MAGIC) {
204 "bad magic number for tty struct (%d:%d) in %s\n",
205 imajor(inode), iminor(inode), routine);
212 static int check_tty_count(struct tty_struct *tty, const char *routine)
214 #ifdef CHECK_TTY_COUNT
219 list_for_each(p, &tty->tty_files) {
223 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
224 tty->driver->subtype == PTY_TYPE_SLAVE &&
225 tty->link && tty->link->count)
227 if (tty->count != count) {
228 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
229 "!= #fd's(%d) in %s\n",
230 tty->name, tty->count, count, routine);
238 * Tty buffer allocation management
241 static void tty_buffer_free_all(struct tty_struct *tty)
243 struct tty_buffer *thead;
244 while((thead = tty->buf.head) != NULL) {
245 tty->buf.head = thead->next;
248 while((thead = tty->buf.free) != NULL) {
249 tty->buf.free = thead->next;
252 tty->buf.tail = NULL;
255 static void tty_buffer_init(struct tty_struct *tty)
257 spin_lock_init(&tty->buf.lock);
258 tty->buf.head = NULL;
259 tty->buf.tail = NULL;
260 tty->buf.free = NULL;
263 static struct tty_buffer *tty_buffer_alloc(size_t size)
265 struct tty_buffer *p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
274 p->char_buf_ptr = (char *)(p->data);
275 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
276 /* printk("Flip create %p\n", p); */
280 /* Must be called with the tty_read lock held. This needs to acquire strategy
281 code to decide if we should kfree or relink a given expired buffer */
283 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
285 /* Dumb strategy for now - should keep some stats */
286 /* printk("Flip dispose %p\n", b); */
290 b->next = tty->buf.free;
295 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
297 struct tty_buffer **tbh = &tty->buf.free;
298 while((*tbh) != NULL) {
299 struct tty_buffer *t = *tbh;
300 if(t->size >= size) {
307 /* memset(t->data, '*', size); */
308 /* printk("Flip recycle %p\n", t); */
311 tbh = &((*tbh)->next);
313 /* Round the buffer size out */
314 size = (size + 0xFF) & ~ 0xFF;
315 return tty_buffer_alloc(size);
316 /* Should possibly check if this fails for the largest buffer we
317 have queued and recycle that ? */
320 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
322 struct tty_buffer *b, *n;
326 spin_lock_irqsave(&tty->buf.lock, flags);
328 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
329 remove this conditional if its worth it. This would be invisible
331 if ((b = tty->buf.tail) != NULL) {
332 left = b->size - b->used;
338 /* This is the slow path - looking for new buffers to use */
339 if ((n = tty_buffer_find(tty, size)) != NULL) {
352 spin_unlock_irqrestore(&tty->buf.lock, flags);
355 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
357 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
362 int space = tty_buffer_request_room(tty, size - copied);
363 struct tty_buffer *tb = tty->buf.tail;
364 /* If there is no space then tb may be NULL */
365 if(unlikely(space == 0))
367 memcpy(tb->char_buf_ptr + tb->used, chars, space);
368 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
373 /* There is a small chance that we need to split the data over
374 several buffers. If this is the case we must loop */
375 while (unlikely(size > copied));
378 EXPORT_SYMBOL(tty_insert_flip_string);
380 int tty_insert_flip_string_flags(struct tty_struct *tty,
381 const unsigned char *chars, const char *flags, size_t size)
385 int space = tty_buffer_request_room(tty, size - copied);
386 struct tty_buffer *tb = tty->buf.tail;
387 /* If there is no space then tb may be NULL */
388 if(unlikely(space == 0))
390 memcpy(tb->char_buf_ptr + tb->used, chars, space);
391 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
397 /* There is a small chance that we need to split the data over
398 several buffers. If this is the case we must loop */
399 while (unlikely(size > copied));
402 EXPORT_SYMBOL(tty_insert_flip_string_flags);
404 void tty_schedule_flip(struct tty_struct *tty)
407 spin_lock_irqsave(&tty->buf.lock, flags);
408 if (tty->buf.tail != NULL) {
409 tty->buf.tail->active = 0;
410 tty->buf.tail->commit = tty->buf.tail->used;
412 spin_unlock_irqrestore(&tty->buf.lock, flags);
413 schedule_delayed_work(&tty->buf.work, 1);
415 EXPORT_SYMBOL(tty_schedule_flip);
418 * Prepare a block of space in the buffer for data. Returns the length
419 * available and buffer pointer to the space which is now allocated and
420 * accounted for as ready for normal characters. This is used for drivers
421 * that need their own block copy routines into the buffer. There is no
422 * guarantee the buffer is a DMA target!
425 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
427 int space = tty_buffer_request_room(tty, size);
429 struct tty_buffer *tb = tty->buf.tail;
430 *chars = tb->char_buf_ptr + tb->used;
431 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
437 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
440 * Prepare a block of space in the buffer for data. Returns the length
441 * available and buffer pointer to the space which is now allocated and
442 * accounted for as ready for characters. This is used for drivers
443 * that need their own block copy routines into the buffer. There is no
444 * guarantee the buffer is a DMA target!
447 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
449 int space = tty_buffer_request_room(tty, size);
451 struct tty_buffer *tb = tty->buf.tail;
452 *chars = tb->char_buf_ptr + tb->used;
453 *flags = tb->flag_buf_ptr + tb->used;
459 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
464 * This is probably overkill for real world processors but
465 * they are not on hot paths so a little discipline won't do
469 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
471 down(&tty->termios_sem);
472 tty->termios->c_line = num;
473 up(&tty->termios_sem);
477 * This guards the refcounted line discipline lists. The lock
478 * must be taken with irqs off because there are hangup path
479 * callers who will do ldisc lookups and cannot sleep.
482 static DEFINE_SPINLOCK(tty_ldisc_lock);
483 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
484 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
486 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
491 if (disc < N_TTY || disc >= NR_LDISCS)
494 spin_lock_irqsave(&tty_ldisc_lock, flags);
495 tty_ldiscs[disc] = *new_ldisc;
496 tty_ldiscs[disc].num = disc;
497 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
498 tty_ldiscs[disc].refcount = 0;
499 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
503 EXPORT_SYMBOL(tty_register_ldisc);
505 int tty_unregister_ldisc(int disc)
510 if (disc < N_TTY || disc >= NR_LDISCS)
513 spin_lock_irqsave(&tty_ldisc_lock, flags);
514 if (tty_ldiscs[disc].refcount)
517 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
518 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
522 EXPORT_SYMBOL(tty_unregister_ldisc);
524 struct tty_ldisc *tty_ldisc_get(int disc)
527 struct tty_ldisc *ld;
529 if (disc < N_TTY || disc >= NR_LDISCS)
532 spin_lock_irqsave(&tty_ldisc_lock, flags);
534 ld = &tty_ldiscs[disc];
535 /* Check the entry is defined */
536 if(ld->flags & LDISC_FLAG_DEFINED)
538 /* If the module is being unloaded we can't use it */
539 if (!try_module_get(ld->owner))
546 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
550 EXPORT_SYMBOL_GPL(tty_ldisc_get);
552 void tty_ldisc_put(int disc)
554 struct tty_ldisc *ld;
557 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
559 spin_lock_irqsave(&tty_ldisc_lock, flags);
560 ld = &tty_ldiscs[disc];
561 BUG_ON(ld->refcount == 0);
563 module_put(ld->owner);
564 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
567 EXPORT_SYMBOL_GPL(tty_ldisc_put);
569 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
572 tty->ldisc.refcount = 0;
576 * tty_ldisc_try - internal helper
579 * Make a single attempt to grab and bump the refcount on
580 * the tty ldisc. Return 0 on failure or 1 on success. This is
581 * used to implement both the waiting and non waiting versions
585 static int tty_ldisc_try(struct tty_struct *tty)
588 struct tty_ldisc *ld;
591 spin_lock_irqsave(&tty_ldisc_lock, flags);
593 if(test_bit(TTY_LDISC, &tty->flags))
598 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
603 * tty_ldisc_ref_wait - wait for the tty ldisc
606 * Dereference the line discipline for the terminal and take a
607 * reference to it. If the line discipline is in flux then
608 * wait patiently until it changes.
610 * Note: Must not be called from an IRQ/timer context. The caller
611 * must also be careful not to hold other locks that will deadlock
612 * against a discipline change, such as an existing ldisc reference
613 * (which we check for)
616 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
618 /* wait_event is a macro */
619 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
620 if(tty->ldisc.refcount == 0)
621 printk(KERN_ERR "tty_ldisc_ref_wait\n");
625 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
628 * tty_ldisc_ref - get the tty ldisc
631 * Dereference the line discipline for the terminal and take a
632 * reference to it. If the line discipline is in flux then
633 * return NULL. Can be called from IRQ and timer functions.
636 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
638 if(tty_ldisc_try(tty))
643 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
646 * tty_ldisc_deref - free a tty ldisc reference
647 * @ld: reference to free up
649 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
650 * be called in IRQ context.
653 void tty_ldisc_deref(struct tty_ldisc *ld)
659 spin_lock_irqsave(&tty_ldisc_lock, flags);
660 if(ld->refcount == 0)
661 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
664 if(ld->refcount == 0)
665 wake_up(&tty_ldisc_wait);
666 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
669 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
672 * tty_ldisc_enable - allow ldisc use
673 * @tty: terminal to activate ldisc on
675 * Set the TTY_LDISC flag when the line discipline can be called
676 * again. Do neccessary wakeups for existing sleepers.
678 * Note: nobody should set this bit except via this function. Clearing
679 * directly is allowed.
682 static void tty_ldisc_enable(struct tty_struct *tty)
684 set_bit(TTY_LDISC, &tty->flags);
685 wake_up(&tty_ldisc_wait);
689 * tty_set_ldisc - set line discipline
690 * @tty: the terminal to set
691 * @ldisc: the line discipline
693 * Set the discipline of a tty line. Must be called from a process
697 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
700 struct tty_ldisc o_ldisc;
704 struct tty_ldisc *ld;
705 struct tty_struct *o_tty;
707 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
712 ld = tty_ldisc_get(ldisc);
713 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
714 /* Cyrus Durgin <cider@speakeasy.org> */
716 request_module("tty-ldisc-%d", ldisc);
717 ld = tty_ldisc_get(ldisc);
723 * No more input please, we are switching. The new ldisc
724 * will update this value in the ldisc open function
727 tty->receive_room = 0;
730 * Problem: What do we do if this blocks ?
733 tty_wait_until_sent(tty, 0);
735 if (tty->ldisc.num == ldisc) {
736 tty_ldisc_put(ldisc);
740 o_ldisc = tty->ldisc;
744 * Make sure we don't change while someone holds a
745 * reference to the line discipline. The TTY_LDISC bit
746 * prevents anyone taking a reference once it is clear.
747 * We need the lock to avoid racing reference takers.
750 spin_lock_irqsave(&tty_ldisc_lock, flags);
751 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
752 if(tty->ldisc.refcount) {
753 /* Free the new ldisc we grabbed. Must drop the lock
755 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
756 tty_ldisc_put(ldisc);
758 * There are several reasons we may be busy, including
759 * random momentary I/O traffic. We must therefore
760 * retry. We could distinguish between blocking ops
761 * and retries if we made tty_ldisc_wait() smarter. That
762 * is up for discussion.
764 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
768 if(o_tty && o_tty->ldisc.refcount) {
769 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
770 tty_ldisc_put(ldisc);
771 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
777 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
779 if (!test_bit(TTY_LDISC, &tty->flags)) {
780 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
781 tty_ldisc_put(ldisc);
782 ld = tty_ldisc_ref_wait(tty);
787 clear_bit(TTY_LDISC, &tty->flags);
788 clear_bit(TTY_DONT_FLIP, &tty->flags);
790 clear_bit(TTY_LDISC, &o_tty->flags);
791 clear_bit(TTY_DONT_FLIP, &o_tty->flags);
793 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
796 * From this point on we know nobody has an ldisc
797 * usage reference, nor can they obtain one until
798 * we say so later on.
801 work = cancel_delayed_work(&tty->buf.work);
803 * Wait for ->hangup_work and ->buf.work handlers to terminate
806 flush_scheduled_work();
807 /* Shutdown the current discipline. */
808 if (tty->ldisc.close)
809 (tty->ldisc.close)(tty);
811 /* Now set up the new line discipline. */
812 tty_ldisc_assign(tty, ld);
813 tty_set_termios_ldisc(tty, ldisc);
815 retval = (tty->ldisc.open)(tty);
817 tty_ldisc_put(ldisc);
818 /* There is an outstanding reference here so this is safe */
819 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
820 tty_set_termios_ldisc(tty, tty->ldisc.num);
821 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
822 tty_ldisc_put(o_ldisc.num);
823 /* This driver is always present */
824 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
825 tty_set_termios_ldisc(tty, N_TTY);
826 if (tty->ldisc.open) {
827 int r = tty->ldisc.open(tty);
830 panic("Couldn't open N_TTY ldisc for "
832 tty_name(tty, buf), r);
836 /* At this point we hold a reference to the new ldisc and a
837 a reference to the old ldisc. If we ended up flipping back
838 to the existing ldisc we have two references to it */
840 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
841 tty->driver->set_ldisc(tty);
843 tty_ldisc_put(o_ldisc.num);
846 * Allow ldisc referencing to occur as soon as the driver
847 * ldisc callback completes.
850 tty_ldisc_enable(tty);
852 tty_ldisc_enable(o_tty);
854 /* Restart it in case no characters kick it off. Safe if
857 schedule_delayed_work(&tty->buf.work, 1);
862 * This routine returns a tty driver structure, given a device number
864 static struct tty_driver *get_tty_driver(dev_t device, int *index)
866 struct tty_driver *p;
868 list_for_each_entry(p, &tty_drivers, tty_drivers) {
869 dev_t base = MKDEV(p->major, p->minor_start);
870 if (device < base || device >= base + p->num)
872 *index = device - base;
879 * If we try to write to, or set the state of, a terminal and we're
880 * not in the foreground, send a SIGTTOU. If the signal is blocked or
881 * ignored, go ahead and perform the operation. (POSIX 7.2)
883 int tty_check_change(struct tty_struct * tty)
885 if (current->signal->tty != tty)
887 if (tty->pgrp <= 0) {
888 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
891 if (process_group(current) == tty->pgrp)
893 if (is_ignored(SIGTTOU))
895 if (is_orphaned_pgrp(process_group(current)))
897 (void) kill_pg(process_group(current), SIGTTOU, 1);
901 EXPORT_SYMBOL(tty_check_change);
903 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
904 size_t count, loff_t *ppos)
909 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
910 size_t count, loff_t *ppos)
915 /* No kernel lock held - none needed ;) */
916 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
918 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
921 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
922 unsigned int cmd, unsigned long arg)
924 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
927 static struct file_operations tty_fops = {
934 .release = tty_release,
935 .fasync = tty_fasync,
938 #ifdef CONFIG_UNIX98_PTYS
939 static struct file_operations ptmx_fops = {
946 .release = tty_release,
947 .fasync = tty_fasync,
951 static struct file_operations console_fops = {
954 .write = redirected_tty_write,
958 .release = tty_release,
959 .fasync = tty_fasync,
962 static struct file_operations hung_up_tty_fops = {
964 .read = hung_up_tty_read,
965 .write = hung_up_tty_write,
966 .poll = hung_up_tty_poll,
967 .ioctl = hung_up_tty_ioctl,
968 .release = tty_release,
971 static DEFINE_SPINLOCK(redirect_lock);
972 static struct file *redirect;
975 * tty_wakeup - request more data
978 * Internal and external helper for wakeups of tty. This function
979 * informs the line discipline if present that the driver is ready
980 * to receive more output data.
983 void tty_wakeup(struct tty_struct *tty)
985 struct tty_ldisc *ld;
987 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
988 ld = tty_ldisc_ref(tty);
991 ld->write_wakeup(tty);
995 wake_up_interruptible(&tty->write_wait);
998 EXPORT_SYMBOL_GPL(tty_wakeup);
1001 * tty_ldisc_flush - flush line discipline queue
1004 * Flush the line discipline queue (if any) for this tty. If there
1005 * is no line discipline active this is a no-op.
1008 void tty_ldisc_flush(struct tty_struct *tty)
1010 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1012 if(ld->flush_buffer)
1013 ld->flush_buffer(tty);
1014 tty_ldisc_deref(ld);
1018 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1021 * This can be called by the "eventd" kernel thread. That is process synchronous,
1022 * but doesn't hold any locks, so we need to make sure we have the appropriate
1023 * locks for what we're doing..
1025 static void do_tty_hangup(void *data)
1027 struct tty_struct *tty = (struct tty_struct *) data;
1028 struct file * cons_filp = NULL;
1029 struct file *filp, *f = NULL;
1030 struct task_struct *p;
1031 struct tty_ldisc *ld;
1032 int closecount = 0, n;
1037 /* inuse_filps is protected by the single kernel lock */
1040 spin_lock(&redirect_lock);
1041 if (redirect && redirect->private_data == tty) {
1045 spin_unlock(&redirect_lock);
1047 check_tty_count(tty, "do_tty_hangup");
1049 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1050 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1051 if (filp->f_op->write == redirected_tty_write)
1053 if (filp->f_op->write != tty_write)
1056 tty_fasync(-1, filp, 0); /* can't block */
1057 filp->f_op = &hung_up_tty_fops;
1061 /* FIXME! What are the locking issues here? This may me overdoing things..
1062 * this question is especially important now that we've removed the irqlock. */
1064 ld = tty_ldisc_ref(tty);
1065 if(ld != NULL) /* We may have no line discipline at this point */
1067 if (ld->flush_buffer)
1068 ld->flush_buffer(tty);
1069 if (tty->driver->flush_buffer)
1070 tty->driver->flush_buffer(tty);
1071 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1073 ld->write_wakeup(tty);
1078 /* FIXME: Once we trust the LDISC code better we can wait here for
1079 ldisc completion and fix the driver call race */
1081 wake_up_interruptible(&tty->write_wait);
1082 wake_up_interruptible(&tty->read_wait);
1085 * Shutdown the current line discipline, and reset it to
1088 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1090 down(&tty->termios_sem);
1091 *tty->termios = tty->driver->init_termios;
1092 up(&tty->termios_sem);
1095 /* Defer ldisc switch */
1096 /* tty_deferred_ldisc_switch(N_TTY);
1098 This should get done automatically when the port closes and
1099 tty_release is called */
1101 read_lock(&tasklist_lock);
1102 if (tty->session > 0) {
1103 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1104 if (p->signal->tty == tty)
1105 p->signal->tty = NULL;
1106 if (!p->signal->leader)
1108 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1109 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1111 p->signal->tty_old_pgrp = tty->pgrp;
1112 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1114 read_unlock(&tasklist_lock);
1119 tty->ctrl_status = 0;
1121 * If one of the devices matches a console pointer, we
1122 * cannot just call hangup() because that will cause
1123 * tty->count and state->count to go out of sync.
1124 * So we just call close() the right number of times.
1127 if (tty->driver->close)
1128 for (n = 0; n < closecount; n++)
1129 tty->driver->close(tty, cons_filp);
1130 } else if (tty->driver->hangup)
1131 (tty->driver->hangup)(tty);
1133 /* We don't want to have driver/ldisc interactions beyond
1134 the ones we did here. The driver layer expects no
1135 calls after ->hangup() from the ldisc side. However we
1136 can't yet guarantee all that */
1138 set_bit(TTY_HUPPED, &tty->flags);
1140 tty_ldisc_enable(tty);
1141 tty_ldisc_deref(ld);
1148 void tty_hangup(struct tty_struct * tty)
1150 #ifdef TTY_DEBUG_HANGUP
1153 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1155 schedule_work(&tty->hangup_work);
1158 EXPORT_SYMBOL(tty_hangup);
1160 void tty_vhangup(struct tty_struct * tty)
1162 #ifdef TTY_DEBUG_HANGUP
1165 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1167 do_tty_hangup((void *) tty);
1169 EXPORT_SYMBOL(tty_vhangup);
1171 int tty_hung_up_p(struct file * filp)
1173 return (filp->f_op == &hung_up_tty_fops);
1176 EXPORT_SYMBOL(tty_hung_up_p);
1179 * This function is typically called only by the session leader, when
1180 * it wants to disassociate itself from its controlling tty.
1182 * It performs the following functions:
1183 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1184 * (2) Clears the tty from being controlling the session
1185 * (3) Clears the controlling tty for all processes in the
1188 * The argument on_exit is set to 1 if called when a process is
1189 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1191 void disassociate_ctty(int on_exit)
1193 struct tty_struct *tty;
1194 struct task_struct *p;
1199 mutex_lock(&tty_mutex);
1200 tty = current->signal->tty;
1202 tty_pgrp = tty->pgrp;
1203 mutex_unlock(&tty_mutex);
1204 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1207 if (current->signal->tty_old_pgrp) {
1208 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1209 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1211 mutex_unlock(&tty_mutex);
1216 kill_pg(tty_pgrp, SIGHUP, on_exit);
1218 kill_pg(tty_pgrp, SIGCONT, on_exit);
1221 /* Must lock changes to tty_old_pgrp */
1222 mutex_lock(&tty_mutex);
1223 current->signal->tty_old_pgrp = 0;
1227 /* Now clear signal->tty under the lock */
1228 read_lock(&tasklist_lock);
1229 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1230 p->signal->tty = NULL;
1231 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1232 read_unlock(&tasklist_lock);
1233 mutex_unlock(&tty_mutex);
1237 void stop_tty(struct tty_struct *tty)
1242 if (tty->link && tty->link->packet) {
1243 tty->ctrl_status &= ~TIOCPKT_START;
1244 tty->ctrl_status |= TIOCPKT_STOP;
1245 wake_up_interruptible(&tty->link->read_wait);
1247 if (tty->driver->stop)
1248 (tty->driver->stop)(tty);
1251 EXPORT_SYMBOL(stop_tty);
1253 void start_tty(struct tty_struct *tty)
1255 if (!tty->stopped || tty->flow_stopped)
1258 if (tty->link && tty->link->packet) {
1259 tty->ctrl_status &= ~TIOCPKT_STOP;
1260 tty->ctrl_status |= TIOCPKT_START;
1261 wake_up_interruptible(&tty->link->read_wait);
1263 if (tty->driver->start)
1264 (tty->driver->start)(tty);
1266 /* If we have a running line discipline it may need kicking */
1268 wake_up_interruptible(&tty->write_wait);
1271 EXPORT_SYMBOL(start_tty);
1273 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1277 struct tty_struct * tty;
1278 struct inode *inode;
1279 struct tty_ldisc *ld;
1281 tty = (struct tty_struct *)file->private_data;
1282 inode = file->f_dentry->d_inode;
1283 if (tty_paranoia_check(tty, inode, "tty_read"))
1285 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1288 /* We want to wait for the line discipline to sort out in this
1290 ld = tty_ldisc_ref_wait(tty);
1293 i = (ld->read)(tty,file,buf,count);
1296 tty_ldisc_deref(ld);
1299 inode->i_atime = current_fs_time(inode->i_sb);
1304 * Split writes up in sane blocksizes to avoid
1305 * denial-of-service type attacks
1307 static inline ssize_t do_tty_write(
1308 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1309 struct tty_struct *tty,
1311 const char __user *buf,
1314 ssize_t ret = 0, written = 0;
1317 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1318 return -ERESTARTSYS;
1322 * We chunk up writes into a temporary buffer. This
1323 * simplifies low-level drivers immensely, since they
1324 * don't have locking issues and user mode accesses.
1326 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1329 * The default chunk-size is 2kB, because the NTTY
1330 * layer has problems with bigger chunks. It will
1331 * claim to be able to handle more characters than
1335 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1340 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1341 if (tty->write_cnt < chunk) {
1347 buf = kmalloc(chunk, GFP_KERNEL);
1349 mutex_unlock(&tty->atomic_write_lock);
1352 kfree(tty->write_buf);
1353 tty->write_cnt = chunk;
1354 tty->write_buf = buf;
1357 /* Do the write .. */
1359 size_t size = count;
1363 if (copy_from_user(tty->write_buf, buf, size))
1366 ret = write(tty, file, tty->write_buf, size);
1376 if (signal_pending(current))
1381 struct inode *inode = file->f_dentry->d_inode;
1382 inode->i_mtime = current_fs_time(inode->i_sb);
1385 mutex_unlock(&tty->atomic_write_lock);
1390 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1393 struct tty_struct * tty;
1394 struct inode *inode = file->f_dentry->d_inode;
1396 struct tty_ldisc *ld;
1398 tty = (struct tty_struct *)file->private_data;
1399 if (tty_paranoia_check(tty, inode, "tty_write"))
1401 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1404 ld = tty_ldisc_ref_wait(tty);
1408 ret = do_tty_write(ld->write, tty, file, buf, count);
1409 tty_ldisc_deref(ld);
1413 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1416 struct file *p = NULL;
1418 spin_lock(&redirect_lock);
1423 spin_unlock(&redirect_lock);
1427 res = vfs_write(p, buf, count, &p->f_pos);
1432 return tty_write(file, buf, count, ppos);
1435 static char ptychar[] = "pqrstuvwxyzabcde";
1437 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1439 int i = index + driver->name_base;
1440 /* ->name is initialized to "ttyp", but "tty" is expected */
1441 sprintf(p, "%s%c%x",
1442 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1443 ptychar[i >> 4 & 0xf], i & 0xf);
1446 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1448 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1452 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1453 * failed open. The new code protects the open with a mutex, so it's
1454 * really quite straightforward. The mutex locking can probably be
1455 * relaxed for the (most common) case of reopening a tty.
1457 static int init_dev(struct tty_driver *driver, int idx,
1458 struct tty_struct **ret_tty)
1460 struct tty_struct *tty, *o_tty;
1461 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1462 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1465 /* check whether we're reopening an existing tty */
1466 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1467 tty = devpts_get_tty(idx);
1468 if (tty && driver->subtype == PTY_TYPE_MASTER)
1471 tty = driver->ttys[idx];
1473 if (tty) goto fast_track;
1476 * First time open is complex, especially for PTY devices.
1477 * This code guarantees that either everything succeeds and the
1478 * TTY is ready for operation, or else the table slots are vacated
1479 * and the allocated memory released. (Except that the termios
1480 * and locked termios may be retained.)
1483 if (!try_module_get(driver->owner)) {
1492 tty = alloc_tty_struct();
1495 initialize_tty_struct(tty);
1496 tty->driver = driver;
1498 tty_line_name(driver, idx, tty->name);
1500 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1501 tp_loc = &tty->termios;
1502 ltp_loc = &tty->termios_locked;
1504 tp_loc = &driver->termios[idx];
1505 ltp_loc = &driver->termios_locked[idx];
1509 tp = (struct termios *) kmalloc(sizeof(struct termios),
1513 *tp = driver->init_termios;
1517 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1521 memset(ltp, 0, sizeof(struct termios));
1524 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1525 o_tty = alloc_tty_struct();
1528 initialize_tty_struct(o_tty);
1529 o_tty->driver = driver->other;
1531 tty_line_name(driver->other, idx, o_tty->name);
1533 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1534 o_tp_loc = &o_tty->termios;
1535 o_ltp_loc = &o_tty->termios_locked;
1537 o_tp_loc = &driver->other->termios[idx];
1538 o_ltp_loc = &driver->other->termios_locked[idx];
1542 o_tp = (struct termios *)
1543 kmalloc(sizeof(struct termios), GFP_KERNEL);
1546 *o_tp = driver->other->init_termios;
1550 o_ltp = (struct termios *)
1551 kmalloc(sizeof(struct termios), GFP_KERNEL);
1554 memset(o_ltp, 0, sizeof(struct termios));
1558 * Everything allocated ... set up the o_tty structure.
1560 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1561 driver->other->ttys[idx] = o_tty;
1567 o_tty->termios = *o_tp_loc;
1568 o_tty->termios_locked = *o_ltp_loc;
1569 driver->other->refcount++;
1570 if (driver->subtype == PTY_TYPE_MASTER)
1573 /* Establish the links in both directions */
1579 * All structures have been allocated, so now we install them.
1580 * Failures after this point use release_mem to clean up, so
1581 * there's no need to null out the local pointers.
1583 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1584 driver->ttys[idx] = tty;
1591 tty->termios = *tp_loc;
1592 tty->termios_locked = *ltp_loc;
1597 * Structures all installed ... call the ldisc open routines.
1598 * If we fail here just call release_mem to clean up. No need
1599 * to decrement the use counts, as release_mem doesn't care.
1602 if (tty->ldisc.open) {
1603 retval = (tty->ldisc.open)(tty);
1605 goto release_mem_out;
1607 if (o_tty && o_tty->ldisc.open) {
1608 retval = (o_tty->ldisc.open)(o_tty);
1610 if (tty->ldisc.close)
1611 (tty->ldisc.close)(tty);
1612 goto release_mem_out;
1614 tty_ldisc_enable(o_tty);
1616 tty_ldisc_enable(tty);
1620 * This fast open can be used if the tty is already open.
1621 * No memory is allocated, and the only failures are from
1622 * attempting to open a closing tty or attempting multiple
1623 * opens on a pty master.
1626 if (test_bit(TTY_CLOSING, &tty->flags)) {
1630 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1631 driver->subtype == PTY_TYPE_MASTER) {
1633 * special case for PTY masters: only one open permitted,
1634 * and the slave side open count is incremented as well.
1643 tty->driver = driver; /* N.B. why do this every time?? */
1646 if(!test_bit(TTY_LDISC, &tty->flags))
1647 printk(KERN_ERR "init_dev but no ldisc\n");
1651 /* All paths come through here to release the mutex */
1655 /* Release locally allocated memory ... nothing placed in slots */
1659 free_tty_struct(o_tty);
1662 free_tty_struct(tty);
1665 module_put(driver->owner);
1669 /* call the tty release_mem routine to clean out this slot */
1671 printk(KERN_INFO "init_dev: ldisc open failed, "
1672 "clearing slot %d\n", idx);
1673 release_mem(tty, idx);
1678 * Get a copy of the termios structure for the driver/index
1680 void tty_get_termios(struct tty_driver *driver, int idx, struct termios *tio)
1683 if (driver->termios[idx])
1684 *tio = *driver->termios[idx];
1686 *tio = driver->init_termios;
1691 * Releases memory associated with a tty structure, and clears out the
1692 * driver table slots.
1694 static void release_mem(struct tty_struct *tty, int idx)
1696 struct tty_struct *o_tty;
1698 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1700 if ((o_tty = tty->link) != NULL) {
1702 o_tty->driver->ttys[idx] = NULL;
1703 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1704 tp = o_tty->termios;
1706 o_tty->driver->termios[idx] = NULL;
1709 tp = o_tty->termios_locked;
1711 o_tty->driver->termios_locked[idx] = NULL;
1715 o_tty->driver->refcount--;
1717 list_del_init(&o_tty->tty_files);
1719 free_tty_struct(o_tty);
1723 tty->driver->ttys[idx] = NULL;
1724 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1727 tty->driver->termios[idx] = NULL;
1730 tp = tty->termios_locked;
1732 tty->driver->termios_locked[idx] = NULL;
1737 tty->driver->refcount--;
1739 list_del_init(&tty->tty_files);
1741 module_put(tty->driver->owner);
1742 free_tty_struct(tty);
1746 * Even releasing the tty structures is a tricky business.. We have
1747 * to be very careful that the structures are all released at the
1748 * same time, as interrupts might otherwise get the wrong pointers.
1750 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1751 * lead to double frees or releasing memory still in use.
1753 static void release_dev(struct file * filp)
1755 struct tty_struct *tty, *o_tty;
1756 int pty_master, tty_closing, o_tty_closing, do_sleep;
1760 unsigned long flags;
1762 tty = (struct tty_struct *)filp->private_data;
1763 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1766 check_tty_count(tty, "release_dev");
1768 tty_fasync(-1, filp, 0);
1771 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1772 tty->driver->subtype == PTY_TYPE_MASTER);
1773 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1776 #ifdef TTY_PARANOIA_CHECK
1777 if (idx < 0 || idx >= tty->driver->num) {
1778 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1779 "free (%s)\n", tty->name);
1782 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1783 if (tty != tty->driver->ttys[idx]) {
1784 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1785 "for (%s)\n", idx, tty->name);
1788 if (tty->termios != tty->driver->termios[idx]) {
1789 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1794 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1795 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1796 "termios_locked for (%s)\n",
1803 #ifdef TTY_DEBUG_HANGUP
1804 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1805 tty_name(tty, buf), tty->count);
1808 #ifdef TTY_PARANOIA_CHECK
1809 if (tty->driver->other &&
1810 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1811 if (o_tty != tty->driver->other->ttys[idx]) {
1812 printk(KERN_DEBUG "release_dev: other->table[%d] "
1813 "not o_tty for (%s)\n",
1817 if (o_tty->termios != tty->driver->other->termios[idx]) {
1818 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1819 "not o_termios for (%s)\n",
1823 if (o_tty->termios_locked !=
1824 tty->driver->other->termios_locked[idx]) {
1825 printk(KERN_DEBUG "release_dev: other->termios_locked["
1826 "%d] not o_termios_locked for (%s)\n",
1830 if (o_tty->link != tty) {
1831 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1836 if (tty->driver->close)
1837 tty->driver->close(tty, filp);
1840 * Sanity check: if tty->count is going to zero, there shouldn't be
1841 * any waiters on tty->read_wait or tty->write_wait. We test the
1842 * wait queues and kick everyone out _before_ actually starting to
1843 * close. This ensures that we won't block while releasing the tty
1846 * The test for the o_tty closing is necessary, since the master and
1847 * slave sides may close in any order. If the slave side closes out
1848 * first, its count will be one, since the master side holds an open.
1849 * Thus this test wouldn't be triggered at the time the slave closes,
1852 * Note that it's possible for the tty to be opened again while we're
1853 * flushing out waiters. By recalculating the closing flags before
1854 * each iteration we avoid any problems.
1857 /* Guard against races with tty->count changes elsewhere and
1858 opens on /dev/tty */
1860 mutex_lock(&tty_mutex);
1861 tty_closing = tty->count <= 1;
1862 o_tty_closing = o_tty &&
1863 (o_tty->count <= (pty_master ? 1 : 0));
1867 if (waitqueue_active(&tty->read_wait)) {
1868 wake_up(&tty->read_wait);
1871 if (waitqueue_active(&tty->write_wait)) {
1872 wake_up(&tty->write_wait);
1876 if (o_tty_closing) {
1877 if (waitqueue_active(&o_tty->read_wait)) {
1878 wake_up(&o_tty->read_wait);
1881 if (waitqueue_active(&o_tty->write_wait)) {
1882 wake_up(&o_tty->write_wait);
1889 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1890 "active!\n", tty_name(tty, buf));
1891 mutex_unlock(&tty_mutex);
1896 * The closing flags are now consistent with the open counts on
1897 * both sides, and we've completed the last operation that could
1898 * block, so it's safe to proceed with closing.
1901 if (--o_tty->count < 0) {
1902 printk(KERN_WARNING "release_dev: bad pty slave count "
1904 o_tty->count, tty_name(o_tty, buf));
1908 if (--tty->count < 0) {
1909 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1910 tty->count, tty_name(tty, buf));
1915 * We've decremented tty->count, so we need to remove this file
1916 * descriptor off the tty->tty_files list; this serves two
1918 * - check_tty_count sees the correct number of file descriptors
1919 * associated with this tty.
1920 * - do_tty_hangup no longer sees this file descriptor as
1921 * something that needs to be handled for hangups.
1924 filp->private_data = NULL;
1927 * Perform some housekeeping before deciding whether to return.
1929 * Set the TTY_CLOSING flag if this was the last open. In the
1930 * case of a pty we may have to wait around for the other side
1931 * to close, and TTY_CLOSING makes sure we can't be reopened.
1934 set_bit(TTY_CLOSING, &tty->flags);
1936 set_bit(TTY_CLOSING, &o_tty->flags);
1939 * If _either_ side is closing, make sure there aren't any
1940 * processes that still think tty or o_tty is their controlling
1943 if (tty_closing || o_tty_closing) {
1944 struct task_struct *p;
1946 read_lock(&tasklist_lock);
1947 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1948 p->signal->tty = NULL;
1949 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1951 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1952 p->signal->tty = NULL;
1953 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1954 read_unlock(&tasklist_lock);
1957 mutex_unlock(&tty_mutex);
1959 /* check whether both sides are closing ... */
1960 if (!tty_closing || (o_tty && !o_tty_closing))
1963 #ifdef TTY_DEBUG_HANGUP
1964 printk(KERN_DEBUG "freeing tty structure...");
1967 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1968 * kill any delayed work. As this is the final close it does not
1969 * race with the set_ldisc code path.
1971 clear_bit(TTY_LDISC, &tty->flags);
1972 clear_bit(TTY_DONT_FLIP, &tty->flags);
1973 cancel_delayed_work(&tty->buf.work);
1976 * Wait for ->hangup_work and ->buf.work handlers to terminate
1979 flush_scheduled_work();
1982 * Wait for any short term users (we know they are just driver
1983 * side waiters as the file is closing so user count on the file
1986 spin_lock_irqsave(&tty_ldisc_lock, flags);
1987 while(tty->ldisc.refcount)
1989 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1990 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1991 spin_lock_irqsave(&tty_ldisc_lock, flags);
1993 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1995 * Shutdown the current line discipline, and reset it to N_TTY.
1996 * N.B. why reset ldisc when we're releasing the memory??
1998 * FIXME: this MUST get fixed for the new reflocking
2000 if (tty->ldisc.close)
2001 (tty->ldisc.close)(tty);
2002 tty_ldisc_put(tty->ldisc.num);
2005 * Switch the line discipline back
2007 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2008 tty_set_termios_ldisc(tty,N_TTY);
2010 /* FIXME: could o_tty be in setldisc here ? */
2011 clear_bit(TTY_LDISC, &o_tty->flags);
2012 if (o_tty->ldisc.close)
2013 (o_tty->ldisc.close)(o_tty);
2014 tty_ldisc_put(o_tty->ldisc.num);
2015 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2016 tty_set_termios_ldisc(o_tty,N_TTY);
2019 * The release_mem function takes care of the details of clearing
2020 * the slots and preserving the termios structure.
2022 release_mem(tty, idx);
2024 #ifdef CONFIG_UNIX98_PTYS
2025 /* Make this pty number available for reallocation */
2027 down(&allocated_ptys_lock);
2028 idr_remove(&allocated_ptys, idx);
2029 up(&allocated_ptys_lock);
2036 * tty_open and tty_release keep up the tty count that contains the
2037 * number of opens done on a tty. We cannot use the inode-count, as
2038 * different inodes might point to the same tty.
2040 * Open-counting is needed for pty masters, as well as for keeping
2041 * track of serial lines: DTR is dropped when the last close happens.
2042 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2044 * The termios state of a pty is reset on first open so that
2045 * settings don't persist across reuse.
2047 static int tty_open(struct inode * inode, struct file * filp)
2049 struct tty_struct *tty;
2051 struct tty_driver *driver;
2053 dev_t device = inode->i_rdev;
2054 unsigned short saved_flags = filp->f_flags;
2056 nonseekable_open(inode, filp);
2059 noctty = filp->f_flags & O_NOCTTY;
2063 mutex_lock(&tty_mutex);
2065 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2066 if (!current->signal->tty) {
2067 mutex_unlock(&tty_mutex);
2070 driver = current->signal->tty->driver;
2071 index = current->signal->tty->index;
2072 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2077 if (device == MKDEV(TTY_MAJOR,0)) {
2078 extern struct tty_driver *console_driver;
2079 driver = console_driver;
2085 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2086 driver = console_device(&index);
2088 /* Don't let /dev/console block */
2089 filp->f_flags |= O_NONBLOCK;
2093 mutex_unlock(&tty_mutex);
2097 driver = get_tty_driver(device, &index);
2099 mutex_unlock(&tty_mutex);
2103 retval = init_dev(driver, index, &tty);
2104 mutex_unlock(&tty_mutex);
2108 filp->private_data = tty;
2109 file_move(filp, &tty->tty_files);
2110 check_tty_count(tty, "tty_open");
2111 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2112 tty->driver->subtype == PTY_TYPE_MASTER)
2114 #ifdef TTY_DEBUG_HANGUP
2115 printk(KERN_DEBUG "opening %s...", tty->name);
2118 if (tty->driver->open)
2119 retval = tty->driver->open(tty, filp);
2123 filp->f_flags = saved_flags;
2125 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2129 #ifdef TTY_DEBUG_HANGUP
2130 printk(KERN_DEBUG "error %d in opening %s...", retval,
2134 if (retval != -ERESTARTSYS)
2136 if (signal_pending(current))
2140 * Need to reset f_op in case a hangup happened.
2142 if (filp->f_op == &hung_up_tty_fops)
2143 filp->f_op = &tty_fops;
2147 current->signal->leader &&
2148 !current->signal->tty &&
2149 tty->session == 0) {
2151 current->signal->tty = tty;
2152 task_unlock(current);
2153 current->signal->tty_old_pgrp = 0;
2154 tty->session = current->signal->session;
2155 tty->pgrp = process_group(current);
2160 #ifdef CONFIG_UNIX98_PTYS
2161 static int ptmx_open(struct inode * inode, struct file * filp)
2163 struct tty_struct *tty;
2168 nonseekable_open(inode, filp);
2170 /* find a device that is not in use. */
2171 down(&allocated_ptys_lock);
2172 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2173 up(&allocated_ptys_lock);
2176 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2178 up(&allocated_ptys_lock);
2179 if (idr_ret == -EAGAIN)
2183 if (index >= pty_limit) {
2184 idr_remove(&allocated_ptys, index);
2185 up(&allocated_ptys_lock);
2188 up(&allocated_ptys_lock);
2190 mutex_lock(&tty_mutex);
2191 retval = init_dev(ptm_driver, index, &tty);
2192 mutex_unlock(&tty_mutex);
2197 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2198 filp->private_data = tty;
2199 file_move(filp, &tty->tty_files);
2202 if (devpts_pty_new(tty->link))
2205 check_tty_count(tty, "tty_open");
2206 retval = ptm_driver->open(tty, filp);
2213 down(&allocated_ptys_lock);
2214 idr_remove(&allocated_ptys, index);
2215 up(&allocated_ptys_lock);
2220 static int tty_release(struct inode * inode, struct file * filp)
2228 /* No kernel lock held - fine */
2229 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2231 struct tty_struct * tty;
2232 struct tty_ldisc *ld;
2235 tty = (struct tty_struct *)filp->private_data;
2236 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2239 ld = tty_ldisc_ref_wait(tty);
2241 ret = (ld->poll)(tty, filp, wait);
2242 tty_ldisc_deref(ld);
2246 static int tty_fasync(int fd, struct file * filp, int on)
2248 struct tty_struct * tty;
2251 tty = (struct tty_struct *)filp->private_data;
2252 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2255 retval = fasync_helper(fd, filp, on, &tty->fasync);
2260 if (!waitqueue_active(&tty->read_wait))
2261 tty->minimum_to_wake = 1;
2262 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2266 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2267 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2272 static int tiocsti(struct tty_struct *tty, char __user *p)
2275 struct tty_ldisc *ld;
2277 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2279 if (get_user(ch, p))
2281 ld = tty_ldisc_ref_wait(tty);
2282 ld->receive_buf(tty, &ch, &mbz, 1);
2283 tty_ldisc_deref(ld);
2287 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2289 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2294 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2295 struct winsize __user * arg)
2297 struct winsize tmp_ws;
2299 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2301 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2304 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2307 acquire_console_sem();
2308 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2309 release_console_sem();
2315 kill_pg(tty->pgrp, SIGWINCH, 1);
2316 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2317 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2318 tty->winsize = tmp_ws;
2319 real_tty->winsize = tmp_ws;
2323 static int tioccons(struct file *file)
2325 if (!capable(CAP_SYS_ADMIN))
2327 if (file->f_op->write == redirected_tty_write) {
2329 spin_lock(&redirect_lock);
2332 spin_unlock(&redirect_lock);
2337 spin_lock(&redirect_lock);
2339 spin_unlock(&redirect_lock);
2344 spin_unlock(&redirect_lock);
2349 static int fionbio(struct file *file, int __user *p)
2353 if (get_user(nonblock, p))
2357 file->f_flags |= O_NONBLOCK;
2359 file->f_flags &= ~O_NONBLOCK;
2363 static int tiocsctty(struct tty_struct *tty, int arg)
2367 if (current->signal->leader &&
2368 (current->signal->session == tty->session))
2371 * The process must be a session leader and
2372 * not have a controlling tty already.
2374 if (!current->signal->leader || current->signal->tty)
2376 if (tty->session > 0) {
2378 * This tty is already the controlling
2379 * tty for another session group!
2381 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2386 read_lock(&tasklist_lock);
2387 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2388 p->signal->tty = NULL;
2389 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2390 read_unlock(&tasklist_lock);
2395 current->signal->tty = tty;
2396 task_unlock(current);
2397 current->signal->tty_old_pgrp = 0;
2398 tty->session = current->signal->session;
2399 tty->pgrp = process_group(current);
2403 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2407 * (tty == real_tty) is a cheap way of
2408 * testing if the tty is NOT a master pty.
2410 if (tty == real_tty && current->signal->tty != real_tty)
2413 pgrp = vx_map_pid(real_tty->pgrp);
2414 return put_user(pgrp, p);
2417 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2420 int retval = tty_check_change(real_tty);
2426 if (!current->signal->tty ||
2427 (current->signal->tty != real_tty) ||
2428 (real_tty->session != current->signal->session))
2430 if (get_user(pgrp, p))
2433 pgrp = vx_rmap_pid(pgrp);
2436 if (session_of_pgrp(pgrp) != current->signal->session)
2438 real_tty->pgrp = pgrp;
2442 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2445 * (tty == real_tty) is a cheap way of
2446 * testing if the tty is NOT a master pty.
2448 if (tty == real_tty && current->signal->tty != real_tty)
2450 if (real_tty->session <= 0)
2452 return put_user(real_tty->session, p);
2455 static int tiocsetd(struct tty_struct *tty, int __user *p)
2459 if (get_user(ldisc, p))
2461 return tty_set_ldisc(tty, ldisc);
2464 static int send_break(struct tty_struct *tty, unsigned int duration)
2466 tty->driver->break_ctl(tty, -1);
2467 if (!signal_pending(current)) {
2468 msleep_interruptible(duration);
2470 tty->driver->break_ctl(tty, 0);
2471 if (signal_pending(current))
2477 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2479 int retval = -EINVAL;
2481 if (tty->driver->tiocmget) {
2482 retval = tty->driver->tiocmget(tty, file);
2485 retval = put_user(retval, p);
2491 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2494 int retval = -EINVAL;
2496 if (tty->driver->tiocmset) {
2497 unsigned int set, clear, val;
2499 retval = get_user(val, p);
2517 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2518 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2520 retval = tty->driver->tiocmset(tty, file, set, clear);
2526 * Split this up, as gcc can choke on it otherwise..
2528 int tty_ioctl(struct inode * inode, struct file * file,
2529 unsigned int cmd, unsigned long arg)
2531 struct tty_struct *tty, *real_tty;
2532 void __user *p = (void __user *)arg;
2534 struct tty_ldisc *ld;
2536 tty = (struct tty_struct *)file->private_data;
2537 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2541 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2542 tty->driver->subtype == PTY_TYPE_MASTER)
2543 real_tty = tty->link;
2546 * Break handling by driver
2548 if (!tty->driver->break_ctl) {
2552 if (tty->driver->ioctl)
2553 return tty->driver->ioctl(tty, file, cmd, arg);
2556 /* These two ioctl's always return success; even if */
2557 /* the driver doesn't support them. */
2560 if (!tty->driver->ioctl)
2562 retval = tty->driver->ioctl(tty, file, cmd, arg);
2563 if (retval == -ENOIOCTLCMD)
2570 * Factor out some common prep work
2578 retval = tty_check_change(tty);
2581 if (cmd != TIOCCBRK) {
2582 tty_wait_until_sent(tty, 0);
2583 if (signal_pending(current))
2591 return tiocsti(tty, p);
2593 return tiocgwinsz(tty, p);
2595 return tiocswinsz(tty, real_tty, p);
2597 return real_tty!=tty ? -EINVAL : tioccons(file);
2599 return fionbio(file, p);
2601 set_bit(TTY_EXCLUSIVE, &tty->flags);
2604 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2607 if (current->signal->tty != tty)
2609 if (current->signal->leader)
2610 disassociate_ctty(0);
2612 current->signal->tty = NULL;
2613 task_unlock(current);
2616 return tiocsctty(tty, arg);
2618 return tiocgpgrp(tty, real_tty, p);
2620 return tiocspgrp(tty, real_tty, p);
2622 return tiocgsid(tty, real_tty, p);
2624 /* FIXME: check this is ok */
2625 return put_user(tty->ldisc.num, (int __user *)p);
2627 return tiocsetd(tty, p);
2630 return tioclinux(tty, arg);
2635 case TIOCSBRK: /* Turn break on, unconditionally */
2636 tty->driver->break_ctl(tty, -1);
2639 case TIOCCBRK: /* Turn break off, unconditionally */
2640 tty->driver->break_ctl(tty, 0);
2642 case TCSBRK: /* SVID version: non-zero arg --> no break */
2644 * XXX is the above comment correct, or the
2645 * code below correct? Is this ioctl used at
2649 return send_break(tty, 250);
2651 case TCSBRKP: /* support for POSIX tcsendbreak() */
2652 return send_break(tty, arg ? arg*100 : 250);
2655 return tty_tiocmget(tty, file, p);
2660 return tty_tiocmset(tty, file, cmd, p);
2662 if (tty->driver->ioctl) {
2663 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2664 if (retval != -ENOIOCTLCMD)
2667 ld = tty_ldisc_ref_wait(tty);
2670 retval = ld->ioctl(tty, file, cmd, arg);
2671 if (retval == -ENOIOCTLCMD)
2674 tty_ldisc_deref(ld);
2680 * This implements the "Secure Attention Key" --- the idea is to
2681 * prevent trojan horses by killing all processes associated with this
2682 * tty when the user hits the "Secure Attention Key". Required for
2683 * super-paranoid applications --- see the Orange Book for more details.
2685 * This code could be nicer; ideally it should send a HUP, wait a few
2686 * seconds, then send a INT, and then a KILL signal. But you then
2687 * have to coordinate with the init process, since all processes associated
2688 * with the current tty must be dead before the new getty is allowed
2691 * Now, if it would be correct ;-/ The current code has a nasty hole -
2692 * it doesn't catch files in flight. We may send the descriptor to ourselves
2693 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2695 * Nasty bug: do_SAK is being called in interrupt context. This can
2696 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2698 static void __do_SAK(void *arg)
2703 struct tty_struct *tty = arg;
2704 struct task_struct *g, *p;
2708 struct tty_ldisc *disc;
2709 struct fdtable *fdt;
2713 session = tty->session;
2715 /* We don't want an ldisc switch during this */
2716 disc = tty_ldisc_ref(tty);
2717 if (disc && disc->flush_buffer)
2718 disc->flush_buffer(tty);
2719 tty_ldisc_deref(disc);
2721 if (tty->driver->flush_buffer)
2722 tty->driver->flush_buffer(tty);
2724 read_lock(&tasklist_lock);
2725 /* Kill the entire session */
2726 do_each_task_pid(session, PIDTYPE_SID, p) {
2727 printk(KERN_NOTICE "SAK: killed process %d"
2728 " (%s): p->signal->session==tty->session\n",
2730 send_sig(SIGKILL, p, 1);
2731 } while_each_task_pid(session, PIDTYPE_SID, p);
2732 /* Now kill any processes that happen to have the
2735 do_each_thread(g, p) {
2736 if (p->signal->tty == tty) {
2737 printk(KERN_NOTICE "SAK: killed process %d"
2738 " (%s): p->signal->session==tty->session\n",
2740 send_sig(SIGKILL, p, 1);
2746 * We don't take a ref to the file, so we must
2747 * hold ->file_lock instead.
2749 spin_lock(&p->files->file_lock);
2750 fdt = files_fdtable(p->files);
2751 for (i=0; i < fdt->max_fds; i++) {
2752 filp = fcheck_files(p->files, i);
2755 if (filp->f_op->read == tty_read &&
2756 filp->private_data == tty) {
2757 printk(KERN_NOTICE "SAK: killed process %d"
2758 " (%s): fd#%d opened to the tty\n",
2759 p->pid, p->comm, i);
2760 force_sig(SIGKILL, p);
2764 spin_unlock(&p->files->file_lock);
2767 } while_each_thread(g, p);
2768 read_unlock(&tasklist_lock);
2773 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2774 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2775 * the values which we write to it will be identical to the values which it
2776 * already has. --akpm
2778 void do_SAK(struct tty_struct *tty)
2782 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2783 schedule_work(&tty->SAK_work);
2786 EXPORT_SYMBOL(do_SAK);
2789 * This routine is called out of the software interrupt to flush data
2790 * from the buffer chain to the line discipline.
2793 static void flush_to_ldisc(void *private_)
2795 struct tty_struct *tty = (struct tty_struct *) private_;
2796 unsigned long flags;
2797 struct tty_ldisc *disc;
2798 struct tty_buffer *tbuf;
2801 unsigned char *flag_buf;
2803 disc = tty_ldisc_ref(tty);
2804 if (disc == NULL) /* !TTY_LDISC */
2807 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2809 * Do it after the next timer tick:
2811 schedule_delayed_work(&tty->buf.work, 1);
2814 spin_lock_irqsave(&tty->buf.lock, flags);
2815 while((tbuf = tty->buf.head) != NULL) {
2816 while ((count = tbuf->commit - tbuf->read) != 0) {
2817 char_buf = tbuf->char_buf_ptr + tbuf->read;
2818 flag_buf = tbuf->flag_buf_ptr + tbuf->read;
2819 tbuf->read += count;
2820 spin_unlock_irqrestore(&tty->buf.lock, flags);
2821 disc->receive_buf(tty, char_buf, flag_buf, count);
2822 spin_lock_irqsave(&tty->buf.lock, flags);
2826 tty->buf.head = tbuf->next;
2827 if (tty->buf.head == NULL)
2828 tty->buf.tail = NULL;
2829 tty_buffer_free(tty, tbuf);
2831 spin_unlock_irqrestore(&tty->buf.lock, flags);
2833 tty_ldisc_deref(disc);
2837 * Routine which returns the baud rate of the tty
2839 * Note that the baud_table needs to be kept in sync with the
2840 * include/asm/termbits.h file.
2842 static int baud_table[] = {
2843 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2844 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2846 76800, 153600, 307200, 614400, 921600
2848 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2849 2500000, 3000000, 3500000, 4000000
2853 static int n_baud_table = ARRAY_SIZE(baud_table);
2856 * tty_termios_baud_rate
2857 * @termios: termios structure
2859 * Convert termios baud rate data into a speed. This should be called
2860 * with the termios lock held if this termios is a terminal termios
2861 * structure. May change the termios data.
2864 int tty_termios_baud_rate(struct termios *termios)
2868 cbaud = termios->c_cflag & CBAUD;
2870 if (cbaud & CBAUDEX) {
2873 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2874 termios->c_cflag &= ~CBAUDEX;
2878 return baud_table[cbaud];
2881 EXPORT_SYMBOL(tty_termios_baud_rate);
2884 * tty_get_baud_rate - get tty bit rates
2885 * @tty: tty to query
2887 * Returns the baud rate as an integer for this terminal. The
2888 * termios lock must be held by the caller and the terminal bit
2889 * flags may be updated.
2892 int tty_get_baud_rate(struct tty_struct *tty)
2894 int baud = tty_termios_baud_rate(tty->termios);
2896 if (baud == 38400 && tty->alt_speed) {
2898 printk(KERN_WARNING "Use of setserial/setrocket to "
2899 "set SPD_* flags is deprecated\n");
2902 baud = tty->alt_speed;
2908 EXPORT_SYMBOL(tty_get_baud_rate);
2911 * tty_flip_buffer_push - terminal
2914 * Queue a push of the terminal flip buffers to the line discipline. This
2915 * function must not be called from IRQ context if tty->low_latency is set.
2917 * In the event of the queue being busy for flipping the work will be
2918 * held off and retried later.
2921 void tty_flip_buffer_push(struct tty_struct *tty)
2923 unsigned long flags;
2924 spin_lock_irqsave(&tty->buf.lock, flags);
2925 if (tty->buf.tail != NULL) {
2926 tty->buf.tail->active = 0;
2927 tty->buf.tail->commit = tty->buf.tail->used;
2929 spin_unlock_irqrestore(&tty->buf.lock, flags);
2931 if (tty->low_latency)
2932 flush_to_ldisc((void *) tty);
2934 schedule_delayed_work(&tty->buf.work, 1);
2937 EXPORT_SYMBOL(tty_flip_buffer_push);
2941 * This subroutine initializes a tty structure.
2943 static void initialize_tty_struct(struct tty_struct *tty)
2945 memset(tty, 0, sizeof(struct tty_struct));
2946 tty->magic = TTY_MAGIC;
2947 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2949 tty->overrun_time = jiffies;
2950 tty->buf.head = tty->buf.tail = NULL;
2951 tty_buffer_init(tty);
2952 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
2953 init_MUTEX(&tty->buf.pty_sem);
2954 init_MUTEX(&tty->termios_sem);
2955 init_waitqueue_head(&tty->write_wait);
2956 init_waitqueue_head(&tty->read_wait);
2957 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2958 mutex_init(&tty->atomic_read_lock);
2959 mutex_init(&tty->atomic_write_lock);
2960 spin_lock_init(&tty->read_lock);
2961 INIT_LIST_HEAD(&tty->tty_files);
2962 INIT_WORK(&tty->SAK_work, NULL, NULL);
2966 * The default put_char routine if the driver did not define one.
2968 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2970 tty->driver->write(tty, &ch, 1);
2973 static struct class *tty_class;
2976 * tty_register_device - register a tty device
2977 * @driver: the tty driver that describes the tty device
2978 * @index: the index in the tty driver for this tty device
2979 * @device: a struct device that is associated with this tty device.
2980 * This field is optional, if there is no known struct device for this
2981 * tty device it can be set to NULL safely.
2983 * This call is required to be made to register an individual tty device if
2984 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2985 * bit is not set, this function should not be called.
2987 void tty_register_device(struct tty_driver *driver, unsigned index,
2988 struct device *device)
2991 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2993 if (index >= driver->num) {
2994 printk(KERN_ERR "Attempt to register invalid tty line number "
2999 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
3000 "%s%d", driver->devfs_name, index + driver->name_base);
3002 if (driver->type == TTY_DRIVER_TYPE_PTY)
3003 pty_line_name(driver, index, name);
3005 tty_line_name(driver, index, name);
3006 class_device_create(tty_class, NULL, dev, device, "%s", name);
3010 * tty_unregister_device - unregister a tty device
3011 * @driver: the tty driver that describes the tty device
3012 * @index: the index in the tty driver for this tty device
3014 * If a tty device is registered with a call to tty_register_device() then
3015 * this function must be made when the tty device is gone.
3017 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3019 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
3020 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3023 EXPORT_SYMBOL(tty_register_device);
3024 EXPORT_SYMBOL(tty_unregister_device);
3026 struct tty_driver *alloc_tty_driver(int lines)
3028 struct tty_driver *driver;
3030 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3032 memset(driver, 0, sizeof(struct tty_driver));
3033 driver->magic = TTY_DRIVER_MAGIC;
3034 driver->num = lines;
3035 /* later we'll move allocation of tables here */
3040 void put_tty_driver(struct tty_driver *driver)
3045 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3047 driver->open = op->open;
3048 driver->close = op->close;
3049 driver->write = op->write;
3050 driver->put_char = op->put_char;
3051 driver->flush_chars = op->flush_chars;
3052 driver->write_room = op->write_room;
3053 driver->chars_in_buffer = op->chars_in_buffer;
3054 driver->ioctl = op->ioctl;
3055 driver->set_termios = op->set_termios;
3056 driver->throttle = op->throttle;
3057 driver->unthrottle = op->unthrottle;
3058 driver->stop = op->stop;
3059 driver->start = op->start;
3060 driver->hangup = op->hangup;
3061 driver->break_ctl = op->break_ctl;
3062 driver->flush_buffer = op->flush_buffer;
3063 driver->set_ldisc = op->set_ldisc;
3064 driver->wait_until_sent = op->wait_until_sent;
3065 driver->send_xchar = op->send_xchar;
3066 driver->read_proc = op->read_proc;
3067 driver->write_proc = op->write_proc;
3068 driver->tiocmget = op->tiocmget;
3069 driver->tiocmset = op->tiocmset;
3073 EXPORT_SYMBOL(alloc_tty_driver);
3074 EXPORT_SYMBOL(put_tty_driver);
3075 EXPORT_SYMBOL(tty_set_operations);
3078 * Called by a tty driver to register itself.
3080 int tty_register_driver(struct tty_driver *driver)
3087 if (driver->flags & TTY_DRIVER_INSTALLED)
3090 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3091 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3094 memset(p, 0, driver->num * 3 * sizeof(void *));
3097 if (!driver->major) {
3098 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3099 (char*)driver->name);
3101 driver->major = MAJOR(dev);
3102 driver->minor_start = MINOR(dev);
3105 dev = MKDEV(driver->major, driver->minor_start);
3106 error = register_chrdev_region(dev, driver->num,
3107 (char*)driver->name);
3115 driver->ttys = (struct tty_struct **)p;
3116 driver->termios = (struct termios **)(p + driver->num);
3117 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3119 driver->ttys = NULL;
3120 driver->termios = NULL;
3121 driver->termios_locked = NULL;
3124 cdev_init(&driver->cdev, &tty_fops);
3125 driver->cdev.owner = driver->owner;
3126 error = cdev_add(&driver->cdev, dev, driver->num);
3128 cdev_del(&driver->cdev);
3129 unregister_chrdev_region(dev, driver->num);
3130 driver->ttys = NULL;
3131 driver->termios = driver->termios_locked = NULL;
3136 if (!driver->put_char)
3137 driver->put_char = tty_default_put_char;
3139 list_add(&driver->tty_drivers, &tty_drivers);
3141 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
3142 for(i = 0; i < driver->num; i++)
3143 tty_register_device(driver, i, NULL);
3145 proc_tty_register_driver(driver);
3149 EXPORT_SYMBOL(tty_register_driver);
3152 * Called by a tty driver to unregister itself.
3154 int tty_unregister_driver(struct tty_driver *driver)
3160 if (driver->refcount)
3163 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3166 list_del(&driver->tty_drivers);
3169 * Free the termios and termios_locked structures because
3170 * we don't want to get memory leaks when modular tty
3171 * drivers are removed from the kernel.
3173 for (i = 0; i < driver->num; i++) {
3174 tp = driver->termios[i];
3176 driver->termios[i] = NULL;
3179 tp = driver->termios_locked[i];
3181 driver->termios_locked[i] = NULL;
3184 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
3185 tty_unregister_device(driver, i);
3188 proc_tty_unregister_driver(driver);
3189 driver->ttys = NULL;
3190 driver->termios = driver->termios_locked = NULL;
3192 cdev_del(&driver->cdev);
3196 EXPORT_SYMBOL(tty_unregister_driver);
3200 * Initialize the console device. This is called *early*, so
3201 * we can't necessarily depend on lots of kernel help here.
3202 * Just do some early initializations, and do the complex setup
3205 void __init console_init(void)
3209 /* Setup the default TTY line discipline. */
3210 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3213 * set up the console device so that later boot sequences can
3214 * inform about problems etc..
3216 #ifdef CONFIG_EARLY_PRINTK
3217 disable_early_printk();
3219 call = __con_initcall_start;
3220 while (call < __con_initcall_end) {
3227 extern int vty_init(void);
3230 static int __init tty_class_init(void)
3232 tty_class = class_create(THIS_MODULE, "tty");
3233 if (IS_ERR(tty_class))
3234 return PTR_ERR(tty_class);
3238 postcore_initcall(tty_class_init);
3240 /* 3/2004 jmc: why do these devices exist? */
3242 static struct cdev tty_cdev, console_cdev;
3243 #ifdef CONFIG_UNIX98_PTYS
3244 static struct cdev ptmx_cdev;
3247 static struct cdev vc0_cdev;
3251 * Ok, now we can initialize the rest of the tty devices and can count
3252 * on memory allocations, interrupts etc..
3254 static int __init tty_init(void)
3256 cdev_init(&tty_cdev, &tty_fops);
3257 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3258 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3259 panic("Couldn't register /dev/tty driver\n");
3260 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
3261 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3263 cdev_init(&console_cdev, &console_fops);
3264 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3265 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3266 panic("Couldn't register /dev/console driver\n");
3267 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
3268 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3270 #ifdef CONFIG_UNIX98_PTYS
3271 cdev_init(&ptmx_cdev, &ptmx_fops);
3272 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3273 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3274 panic("Couldn't register /dev/ptmx driver\n");
3275 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
3276 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3280 cdev_init(&vc0_cdev, &console_fops);
3281 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3282 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3283 panic("Couldn't register /dev/tty0 driver\n");
3284 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3285 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3291 module_init(tty_init);