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>
106 #include <linux/kmod.h>
108 #undef TTY_DEBUG_HANGUP
110 #define TTY_PARANOIA_CHECK 1
111 #define CHECK_TTY_COUNT 1
113 struct termios tty_std_termios = { /* for the benefit of tty drivers */
114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
122 EXPORT_SYMBOL(tty_std_termios);
124 /* This list gets poked at by procfs and various bits of boot up code. This
125 could do with some rationalisation such as pulling the tty proc function
128 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
130 /* Semaphore to protect creating and releasing a tty. This is shared with
131 vt.c for deeply disgusting hack reasons */
132 DEFINE_MUTEX(tty_mutex);
134 #ifdef CONFIG_UNIX98_PTYS
135 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
136 extern int pty_limit; /* Config limit on Unix98 ptys */
137 static DEFINE_IDR(allocated_ptys);
138 static DECLARE_MUTEX(allocated_ptys_lock);
139 static int ptmx_open(struct inode *, struct file *);
142 extern void disable_early_printk(void);
144 static void initialize_tty_struct(struct tty_struct *tty);
146 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149 static unsigned int tty_poll(struct file *, poll_table *);
150 static int tty_open(struct inode *, struct file *);
151 static int tty_release(struct inode *, struct file *);
152 int tty_ioctl(struct inode * inode, struct file * file,
153 unsigned int cmd, unsigned long arg);
154 static int tty_fasync(int fd, struct file * filp, int on);
155 static void release_mem(struct tty_struct *tty, int idx);
158 static struct tty_struct *alloc_tty_struct(void)
160 struct tty_struct *tty;
162 tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
164 memset(tty, 0, sizeof(struct tty_struct));
168 static void tty_buffer_free_all(struct tty_struct *);
170 static inline void free_tty_struct(struct tty_struct *tty)
172 kfree(tty->write_buf);
173 tty_buffer_free_all(tty);
177 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
179 char *tty_name(struct tty_struct *tty, char *buf)
181 if (!tty) /* Hmm. NULL pointer. That's fun. */
182 strcpy(buf, "NULL tty");
184 strcpy(buf, tty->name);
188 EXPORT_SYMBOL(tty_name);
190 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
193 #ifdef TTY_PARANOIA_CHECK
196 "null TTY for (%d:%d) in %s\n",
197 imajor(inode), iminor(inode), routine);
200 if (tty->magic != TTY_MAGIC) {
202 "bad magic number for tty struct (%d:%d) in %s\n",
203 imajor(inode), iminor(inode), routine);
210 static int check_tty_count(struct tty_struct *tty, const char *routine)
212 #ifdef CHECK_TTY_COUNT
217 list_for_each(p, &tty->tty_files) {
221 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
222 tty->driver->subtype == PTY_TYPE_SLAVE &&
223 tty->link && tty->link->count)
225 if (tty->count != count) {
226 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
227 "!= #fd's(%d) in %s\n",
228 tty->name, tty->count, count, routine);
236 * Tty buffer allocation management
239 static void tty_buffer_free_all(struct tty_struct *tty)
241 struct tty_buffer *thead;
242 while((thead = tty->buf.head) != NULL) {
243 tty->buf.head = thead->next;
246 while((thead = tty->buf.free) != NULL) {
247 tty->buf.free = thead->next;
250 tty->buf.tail = NULL;
253 static void tty_buffer_init(struct tty_struct *tty)
255 spin_lock_init(&tty->buf.lock);
256 tty->buf.head = NULL;
257 tty->buf.tail = NULL;
258 tty->buf.free = NULL;
261 static struct tty_buffer *tty_buffer_alloc(size_t size)
263 struct tty_buffer *p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
271 p->char_buf_ptr = (char *)(p->data);
272 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
273 /* printk("Flip create %p\n", p); */
277 /* Must be called with the tty_read lock held. This needs to acquire strategy
278 code to decide if we should kfree or relink a given expired buffer */
280 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
282 /* Dumb strategy for now - should keep some stats */
283 /* printk("Flip dispose %p\n", b); */
287 b->next = tty->buf.free;
292 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
294 struct tty_buffer **tbh = &tty->buf.free;
295 while((*tbh) != NULL) {
296 struct tty_buffer *t = *tbh;
297 if(t->size >= size) {
304 /* memset(t->data, '*', size); */
305 /* printk("Flip recycle %p\n", t); */
308 tbh = &((*tbh)->next);
310 /* Round the buffer size out */
311 size = (size + 0xFF) & ~ 0xFF;
312 return tty_buffer_alloc(size);
313 /* Should possibly check if this fails for the largest buffer we
314 have queued and recycle that ? */
317 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
319 struct tty_buffer *b, *n;
323 spin_lock_irqsave(&tty->buf.lock, flags);
325 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
326 remove this conditional if its worth it. This would be invisible
328 if ((b = tty->buf.tail) != NULL)
329 left = b->size - b->used;
334 /* This is the slow path - looking for new buffers to use */
335 if ((n = tty_buffer_find(tty, size)) != NULL) {
346 spin_unlock_irqrestore(&tty->buf.lock, flags);
349 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
351 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
356 int space = tty_buffer_request_room(tty, size - copied);
357 struct tty_buffer *tb = tty->buf.tail;
358 /* If there is no space then tb may be NULL */
359 if(unlikely(space == 0))
361 memcpy(tb->char_buf_ptr + tb->used, chars, space);
362 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
367 /* There is a small chance that we need to split the data over
368 several buffers. If this is the case we must loop */
369 while (unlikely(size > copied));
372 EXPORT_SYMBOL(tty_insert_flip_string);
374 int tty_insert_flip_string_flags(struct tty_struct *tty,
375 const unsigned char *chars, const char *flags, size_t size)
379 int space = tty_buffer_request_room(tty, size - copied);
380 struct tty_buffer *tb = tty->buf.tail;
381 /* If there is no space then tb may be NULL */
382 if(unlikely(space == 0))
384 memcpy(tb->char_buf_ptr + tb->used, chars, space);
385 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
391 /* There is a small chance that we need to split the data over
392 several buffers. If this is the case we must loop */
393 while (unlikely(size > copied));
396 EXPORT_SYMBOL(tty_insert_flip_string_flags);
398 void tty_schedule_flip(struct tty_struct *tty)
401 spin_lock_irqsave(&tty->buf.lock, flags);
402 if (tty->buf.tail != NULL)
403 tty->buf.tail->commit = tty->buf.tail->used;
404 spin_unlock_irqrestore(&tty->buf.lock, flags);
405 schedule_delayed_work(&tty->buf.work, 1);
407 EXPORT_SYMBOL(tty_schedule_flip);
410 * Prepare a block of space in the buffer for data. Returns the length
411 * available and buffer pointer to the space which is now allocated and
412 * accounted for as ready for normal characters. This is used for drivers
413 * that need their own block copy routines into the buffer. There is no
414 * guarantee the buffer is a DMA target!
417 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
419 int space = tty_buffer_request_room(tty, size);
421 struct tty_buffer *tb = tty->buf.tail;
422 *chars = tb->char_buf_ptr + tb->used;
423 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
429 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
432 * Prepare a block of space in the buffer for data. Returns the length
433 * available and buffer pointer to the space which is now allocated and
434 * accounted for as ready for characters. This is used for drivers
435 * that need their own block copy routines into the buffer. There is no
436 * guarantee the buffer is a DMA target!
439 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
441 int space = tty_buffer_request_room(tty, size);
443 struct tty_buffer *tb = tty->buf.tail;
444 *chars = tb->char_buf_ptr + tb->used;
445 *flags = tb->flag_buf_ptr + tb->used;
451 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
456 * This is probably overkill for real world processors but
457 * they are not on hot paths so a little discipline won't do
461 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
463 down(&tty->termios_sem);
464 tty->termios->c_line = num;
465 up(&tty->termios_sem);
469 * This guards the refcounted line discipline lists. The lock
470 * must be taken with irqs off because there are hangup path
471 * callers who will do ldisc lookups and cannot sleep.
474 static DEFINE_SPINLOCK(tty_ldisc_lock);
475 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
476 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
478 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
483 if (disc < N_TTY || disc >= NR_LDISCS)
486 spin_lock_irqsave(&tty_ldisc_lock, flags);
487 tty_ldiscs[disc] = *new_ldisc;
488 tty_ldiscs[disc].num = disc;
489 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
490 tty_ldiscs[disc].refcount = 0;
491 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
495 EXPORT_SYMBOL(tty_register_ldisc);
497 int tty_unregister_ldisc(int disc)
502 if (disc < N_TTY || disc >= NR_LDISCS)
505 spin_lock_irqsave(&tty_ldisc_lock, flags);
506 if (tty_ldiscs[disc].refcount)
509 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
510 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
514 EXPORT_SYMBOL(tty_unregister_ldisc);
516 struct tty_ldisc *tty_ldisc_get(int disc)
519 struct tty_ldisc *ld;
521 if (disc < N_TTY || disc >= NR_LDISCS)
524 spin_lock_irqsave(&tty_ldisc_lock, flags);
526 ld = &tty_ldiscs[disc];
527 /* Check the entry is defined */
528 if(ld->flags & LDISC_FLAG_DEFINED)
530 /* If the module is being unloaded we can't use it */
531 if (!try_module_get(ld->owner))
538 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
542 EXPORT_SYMBOL_GPL(tty_ldisc_get);
544 void tty_ldisc_put(int disc)
546 struct tty_ldisc *ld;
549 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
551 spin_lock_irqsave(&tty_ldisc_lock, flags);
552 ld = &tty_ldiscs[disc];
553 BUG_ON(ld->refcount == 0);
555 module_put(ld->owner);
556 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
559 EXPORT_SYMBOL_GPL(tty_ldisc_put);
561 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
564 tty->ldisc.refcount = 0;
568 * tty_ldisc_try - internal helper
571 * Make a single attempt to grab and bump the refcount on
572 * the tty ldisc. Return 0 on failure or 1 on success. This is
573 * used to implement both the waiting and non waiting versions
577 static int tty_ldisc_try(struct tty_struct *tty)
580 struct tty_ldisc *ld;
583 spin_lock_irqsave(&tty_ldisc_lock, flags);
585 if(test_bit(TTY_LDISC, &tty->flags))
590 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
595 * tty_ldisc_ref_wait - wait for the tty ldisc
598 * Dereference the line discipline for the terminal and take a
599 * reference to it. If the line discipline is in flux then
600 * wait patiently until it changes.
602 * Note: Must not be called from an IRQ/timer context. The caller
603 * must also be careful not to hold other locks that will deadlock
604 * against a discipline change, such as an existing ldisc reference
605 * (which we check for)
608 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
610 /* wait_event is a macro */
611 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
612 if(tty->ldisc.refcount == 0)
613 printk(KERN_ERR "tty_ldisc_ref_wait\n");
617 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
620 * tty_ldisc_ref - get the tty ldisc
623 * Dereference the line discipline for the terminal and take a
624 * reference to it. If the line discipline is in flux then
625 * return NULL. Can be called from IRQ and timer functions.
628 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
630 if(tty_ldisc_try(tty))
635 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
638 * tty_ldisc_deref - free a tty ldisc reference
639 * @ld: reference to free up
641 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
642 * be called in IRQ context.
645 void tty_ldisc_deref(struct tty_ldisc *ld)
651 spin_lock_irqsave(&tty_ldisc_lock, flags);
652 if(ld->refcount == 0)
653 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
656 if(ld->refcount == 0)
657 wake_up(&tty_ldisc_wait);
658 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
661 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
664 * tty_ldisc_enable - allow ldisc use
665 * @tty: terminal to activate ldisc on
667 * Set the TTY_LDISC flag when the line discipline can be called
668 * again. Do neccessary wakeups for existing sleepers.
670 * Note: nobody should set this bit except via this function. Clearing
671 * directly is allowed.
674 static void tty_ldisc_enable(struct tty_struct *tty)
676 set_bit(TTY_LDISC, &tty->flags);
677 wake_up(&tty_ldisc_wait);
681 * tty_set_ldisc - set line discipline
682 * @tty: the terminal to set
683 * @ldisc: the line discipline
685 * Set the discipline of a tty line. Must be called from a process
689 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
692 struct tty_ldisc o_ldisc;
696 struct tty_ldisc *ld;
697 struct tty_struct *o_tty;
699 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
704 ld = tty_ldisc_get(ldisc);
705 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
706 /* Cyrus Durgin <cider@speakeasy.org> */
708 request_module("tty-ldisc-%d", ldisc);
709 ld = tty_ldisc_get(ldisc);
715 * No more input please, we are switching. The new ldisc
716 * will update this value in the ldisc open function
719 tty->receive_room = 0;
722 * Problem: What do we do if this blocks ?
725 tty_wait_until_sent(tty, 0);
727 if (tty->ldisc.num == ldisc) {
728 tty_ldisc_put(ldisc);
732 o_ldisc = tty->ldisc;
736 * Make sure we don't change while someone holds a
737 * reference to the line discipline. The TTY_LDISC bit
738 * prevents anyone taking a reference once it is clear.
739 * We need the lock to avoid racing reference takers.
742 spin_lock_irqsave(&tty_ldisc_lock, flags);
743 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
744 if(tty->ldisc.refcount) {
745 /* Free the new ldisc we grabbed. Must drop the lock
747 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
748 tty_ldisc_put(ldisc);
750 * There are several reasons we may be busy, including
751 * random momentary I/O traffic. We must therefore
752 * retry. We could distinguish between blocking ops
753 * and retries if we made tty_ldisc_wait() smarter. That
754 * is up for discussion.
756 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
760 if(o_tty && o_tty->ldisc.refcount) {
761 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
762 tty_ldisc_put(ldisc);
763 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
769 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
771 if (!test_bit(TTY_LDISC, &tty->flags)) {
772 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
773 tty_ldisc_put(ldisc);
774 ld = tty_ldisc_ref_wait(tty);
779 clear_bit(TTY_LDISC, &tty->flags);
781 clear_bit(TTY_LDISC, &o_tty->flags);
782 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
785 * From this point on we know nobody has an ldisc
786 * usage reference, nor can they obtain one until
787 * we say so later on.
790 work = cancel_delayed_work(&tty->buf.work);
792 * Wait for ->hangup_work and ->buf.work handlers to terminate
795 flush_scheduled_work();
796 /* Shutdown the current discipline. */
797 if (tty->ldisc.close)
798 (tty->ldisc.close)(tty);
800 /* Now set up the new line discipline. */
801 tty_ldisc_assign(tty, ld);
802 tty_set_termios_ldisc(tty, ldisc);
804 retval = (tty->ldisc.open)(tty);
806 tty_ldisc_put(ldisc);
807 /* There is an outstanding reference here so this is safe */
808 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
809 tty_set_termios_ldisc(tty, tty->ldisc.num);
810 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
811 tty_ldisc_put(o_ldisc.num);
812 /* This driver is always present */
813 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
814 tty_set_termios_ldisc(tty, N_TTY);
815 if (tty->ldisc.open) {
816 int r = tty->ldisc.open(tty);
819 panic("Couldn't open N_TTY ldisc for "
821 tty_name(tty, buf), r);
825 /* At this point we hold a reference to the new ldisc and a
826 a reference to the old ldisc. If we ended up flipping back
827 to the existing ldisc we have two references to it */
829 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
830 tty->driver->set_ldisc(tty);
832 tty_ldisc_put(o_ldisc.num);
835 * Allow ldisc referencing to occur as soon as the driver
836 * ldisc callback completes.
839 tty_ldisc_enable(tty);
841 tty_ldisc_enable(o_tty);
843 /* Restart it in case no characters kick it off. Safe if
846 schedule_delayed_work(&tty->buf.work, 1);
851 * This routine returns a tty driver structure, given a device number
853 static struct tty_driver *get_tty_driver(dev_t device, int *index)
855 struct tty_driver *p;
857 list_for_each_entry(p, &tty_drivers, tty_drivers) {
858 dev_t base = MKDEV(p->major, p->minor_start);
859 if (device < base || device >= base + p->num)
861 *index = device - base;
868 * If we try to write to, or set the state of, a terminal and we're
869 * not in the foreground, send a SIGTTOU. If the signal is blocked or
870 * ignored, go ahead and perform the operation. (POSIX 7.2)
872 int tty_check_change(struct tty_struct * tty)
874 if (current->signal->tty != tty)
876 if (tty->pgrp <= 0) {
877 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
880 if (process_group(current) == tty->pgrp)
882 if (is_ignored(SIGTTOU))
884 if (is_orphaned_pgrp(process_group(current)))
886 (void) kill_pg(process_group(current), SIGTTOU, 1);
890 EXPORT_SYMBOL(tty_check_change);
892 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
893 size_t count, loff_t *ppos)
898 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
899 size_t count, loff_t *ppos)
904 /* No kernel lock held - none needed ;) */
905 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
907 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
910 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
911 unsigned int cmd, unsigned long arg)
913 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
916 static struct file_operations tty_fops = {
923 .release = tty_release,
924 .fasync = tty_fasync,
927 #ifdef CONFIG_UNIX98_PTYS
928 static struct file_operations ptmx_fops = {
935 .release = tty_release,
936 .fasync = tty_fasync,
940 static struct file_operations console_fops = {
943 .write = redirected_tty_write,
947 .release = tty_release,
948 .fasync = tty_fasync,
951 static struct file_operations hung_up_tty_fops = {
953 .read = hung_up_tty_read,
954 .write = hung_up_tty_write,
955 .poll = hung_up_tty_poll,
956 .ioctl = hung_up_tty_ioctl,
957 .release = tty_release,
960 static DEFINE_SPINLOCK(redirect_lock);
961 static struct file *redirect;
964 * tty_wakeup - request more data
967 * Internal and external helper for wakeups of tty. This function
968 * informs the line discipline if present that the driver is ready
969 * to receive more output data.
972 void tty_wakeup(struct tty_struct *tty)
974 struct tty_ldisc *ld;
976 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
977 ld = tty_ldisc_ref(tty);
980 ld->write_wakeup(tty);
984 wake_up_interruptible(&tty->write_wait);
987 EXPORT_SYMBOL_GPL(tty_wakeup);
990 * tty_ldisc_flush - flush line discipline queue
993 * Flush the line discipline queue (if any) for this tty. If there
994 * is no line discipline active this is a no-op.
997 void tty_ldisc_flush(struct tty_struct *tty)
999 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1001 if(ld->flush_buffer)
1002 ld->flush_buffer(tty);
1003 tty_ldisc_deref(ld);
1007 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1010 * This can be called by the "eventd" kernel thread. That is process synchronous,
1011 * but doesn't hold any locks, so we need to make sure we have the appropriate
1012 * locks for what we're doing..
1014 static void do_tty_hangup(void *data)
1016 struct tty_struct *tty = (struct tty_struct *) data;
1017 struct file * cons_filp = NULL;
1018 struct file *filp, *f = NULL;
1019 struct task_struct *p;
1020 struct tty_ldisc *ld;
1021 int closecount = 0, n;
1026 /* inuse_filps is protected by the single kernel lock */
1029 spin_lock(&redirect_lock);
1030 if (redirect && redirect->private_data == tty) {
1034 spin_unlock(&redirect_lock);
1036 check_tty_count(tty, "do_tty_hangup");
1038 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1039 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1040 if (filp->f_op->write == redirected_tty_write)
1042 if (filp->f_op->write != tty_write)
1045 tty_fasync(-1, filp, 0); /* can't block */
1046 filp->f_op = &hung_up_tty_fops;
1050 /* FIXME! What are the locking issues here? This may me overdoing things..
1051 * this question is especially important now that we've removed the irqlock. */
1053 ld = tty_ldisc_ref(tty);
1054 if(ld != NULL) /* We may have no line discipline at this point */
1056 if (ld->flush_buffer)
1057 ld->flush_buffer(tty);
1058 if (tty->driver->flush_buffer)
1059 tty->driver->flush_buffer(tty);
1060 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1062 ld->write_wakeup(tty);
1067 /* FIXME: Once we trust the LDISC code better we can wait here for
1068 ldisc completion and fix the driver call race */
1070 wake_up_interruptible(&tty->write_wait);
1071 wake_up_interruptible(&tty->read_wait);
1074 * Shutdown the current line discipline, and reset it to
1077 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1079 down(&tty->termios_sem);
1080 *tty->termios = tty->driver->init_termios;
1081 up(&tty->termios_sem);
1084 /* Defer ldisc switch */
1085 /* tty_deferred_ldisc_switch(N_TTY);
1087 This should get done automatically when the port closes and
1088 tty_release is called */
1090 read_lock(&tasklist_lock);
1091 if (tty->session > 0) {
1092 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1093 if (p->signal->tty == tty)
1094 p->signal->tty = NULL;
1095 if (!p->signal->leader)
1097 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1098 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1100 p->signal->tty_old_pgrp = tty->pgrp;
1101 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1103 read_unlock(&tasklist_lock);
1108 tty->ctrl_status = 0;
1110 * If one of the devices matches a console pointer, we
1111 * cannot just call hangup() because that will cause
1112 * tty->count and state->count to go out of sync.
1113 * So we just call close() the right number of times.
1116 if (tty->driver->close)
1117 for (n = 0; n < closecount; n++)
1118 tty->driver->close(tty, cons_filp);
1119 } else if (tty->driver->hangup)
1120 (tty->driver->hangup)(tty);
1122 /* We don't want to have driver/ldisc interactions beyond
1123 the ones we did here. The driver layer expects no
1124 calls after ->hangup() from the ldisc side. However we
1125 can't yet guarantee all that */
1127 set_bit(TTY_HUPPED, &tty->flags);
1129 tty_ldisc_enable(tty);
1130 tty_ldisc_deref(ld);
1137 void tty_hangup(struct tty_struct * tty)
1139 #ifdef TTY_DEBUG_HANGUP
1142 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1144 schedule_work(&tty->hangup_work);
1147 EXPORT_SYMBOL(tty_hangup);
1149 void tty_vhangup(struct tty_struct * tty)
1151 #ifdef TTY_DEBUG_HANGUP
1154 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1156 do_tty_hangup((void *) tty);
1158 EXPORT_SYMBOL(tty_vhangup);
1160 int tty_hung_up_p(struct file * filp)
1162 return (filp->f_op == &hung_up_tty_fops);
1165 EXPORT_SYMBOL(tty_hung_up_p);
1168 * This function is typically called only by the session leader, when
1169 * it wants to disassociate itself from its controlling tty.
1171 * It performs the following functions:
1172 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1173 * (2) Clears the tty from being controlling the session
1174 * (3) Clears the controlling tty for all processes in the
1177 * The argument on_exit is set to 1 if called when a process is
1178 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1180 void disassociate_ctty(int on_exit)
1182 struct tty_struct *tty;
1183 struct task_struct *p;
1188 mutex_lock(&tty_mutex);
1189 tty = current->signal->tty;
1191 tty_pgrp = tty->pgrp;
1192 mutex_unlock(&tty_mutex);
1193 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1196 if (current->signal->tty_old_pgrp) {
1197 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1198 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1200 mutex_unlock(&tty_mutex);
1205 kill_pg(tty_pgrp, SIGHUP, on_exit);
1207 kill_pg(tty_pgrp, SIGCONT, on_exit);
1210 /* Must lock changes to tty_old_pgrp */
1211 mutex_lock(&tty_mutex);
1212 current->signal->tty_old_pgrp = 0;
1216 /* Now clear signal->tty under the lock */
1217 read_lock(&tasklist_lock);
1218 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1219 p->signal->tty = NULL;
1220 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1221 read_unlock(&tasklist_lock);
1222 mutex_unlock(&tty_mutex);
1226 void stop_tty(struct tty_struct *tty)
1231 if (tty->link && tty->link->packet) {
1232 tty->ctrl_status &= ~TIOCPKT_START;
1233 tty->ctrl_status |= TIOCPKT_STOP;
1234 wake_up_interruptible(&tty->link->read_wait);
1236 if (tty->driver->stop)
1237 (tty->driver->stop)(tty);
1240 EXPORT_SYMBOL(stop_tty);
1242 void start_tty(struct tty_struct *tty)
1244 if (!tty->stopped || tty->flow_stopped)
1247 if (tty->link && tty->link->packet) {
1248 tty->ctrl_status &= ~TIOCPKT_STOP;
1249 tty->ctrl_status |= TIOCPKT_START;
1250 wake_up_interruptible(&tty->link->read_wait);
1252 if (tty->driver->start)
1253 (tty->driver->start)(tty);
1255 /* If we have a running line discipline it may need kicking */
1257 wake_up_interruptible(&tty->write_wait);
1260 EXPORT_SYMBOL(start_tty);
1262 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1266 struct tty_struct * tty;
1267 struct inode *inode;
1268 struct tty_ldisc *ld;
1270 tty = (struct tty_struct *)file->private_data;
1271 inode = file->f_dentry->d_inode;
1272 if (tty_paranoia_check(tty, inode, "tty_read"))
1274 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1277 /* We want to wait for the line discipline to sort out in this
1279 ld = tty_ldisc_ref_wait(tty);
1282 i = (ld->read)(tty,file,buf,count);
1285 tty_ldisc_deref(ld);
1288 inode->i_atime = current_fs_time(inode->i_sb);
1293 * Split writes up in sane blocksizes to avoid
1294 * denial-of-service type attacks
1296 static inline ssize_t do_tty_write(
1297 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1298 struct tty_struct *tty,
1300 const char __user *buf,
1303 ssize_t ret = 0, written = 0;
1306 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1307 return -ERESTARTSYS;
1311 * We chunk up writes into a temporary buffer. This
1312 * simplifies low-level drivers immensely, since they
1313 * don't have locking issues and user mode accesses.
1315 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1318 * The default chunk-size is 2kB, because the NTTY
1319 * layer has problems with bigger chunks. It will
1320 * claim to be able to handle more characters than
1324 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1329 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1330 if (tty->write_cnt < chunk) {
1336 buf = kmalloc(chunk, GFP_KERNEL);
1338 mutex_unlock(&tty->atomic_write_lock);
1341 kfree(tty->write_buf);
1342 tty->write_cnt = chunk;
1343 tty->write_buf = buf;
1346 /* Do the write .. */
1348 size_t size = count;
1352 if (copy_from_user(tty->write_buf, buf, size))
1355 ret = write(tty, file, tty->write_buf, size);
1365 if (signal_pending(current))
1370 struct inode *inode = file->f_dentry->d_inode;
1371 inode->i_mtime = current_fs_time(inode->i_sb);
1374 mutex_unlock(&tty->atomic_write_lock);
1379 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1382 struct tty_struct * tty;
1383 struct inode *inode = file->f_dentry->d_inode;
1385 struct tty_ldisc *ld;
1387 tty = (struct tty_struct *)file->private_data;
1388 if (tty_paranoia_check(tty, inode, "tty_write"))
1390 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1393 ld = tty_ldisc_ref_wait(tty);
1397 ret = do_tty_write(ld->write, tty, file, buf, count);
1398 tty_ldisc_deref(ld);
1402 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1405 struct file *p = NULL;
1407 spin_lock(&redirect_lock);
1412 spin_unlock(&redirect_lock);
1416 res = vfs_write(p, buf, count, &p->f_pos);
1421 return tty_write(file, buf, count, ppos);
1424 static char ptychar[] = "pqrstuvwxyzabcde";
1426 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1428 int i = index + driver->name_base;
1429 /* ->name is initialized to "ttyp", but "tty" is expected */
1430 sprintf(p, "%s%c%x",
1431 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1432 ptychar[i >> 4 & 0xf], i & 0xf);
1435 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1437 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1441 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1442 * failed open. The new code protects the open with a mutex, so it's
1443 * really quite straightforward. The mutex locking can probably be
1444 * relaxed for the (most common) case of reopening a tty.
1446 static int init_dev(struct tty_driver *driver, int idx,
1447 struct tty_struct **ret_tty)
1449 struct tty_struct *tty, *o_tty;
1450 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1451 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1454 /* check whether we're reopening an existing tty */
1455 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1456 tty = devpts_get_tty(idx);
1457 if (tty && driver->subtype == PTY_TYPE_MASTER)
1460 tty = driver->ttys[idx];
1462 if (tty) goto fast_track;
1465 * First time open is complex, especially for PTY devices.
1466 * This code guarantees that either everything succeeds and the
1467 * TTY is ready for operation, or else the table slots are vacated
1468 * and the allocated memory released. (Except that the termios
1469 * and locked termios may be retained.)
1472 if (!try_module_get(driver->owner)) {
1481 tty = alloc_tty_struct();
1484 initialize_tty_struct(tty);
1485 tty->driver = driver;
1487 tty_line_name(driver, idx, tty->name);
1489 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1490 tp_loc = &tty->termios;
1491 ltp_loc = &tty->termios_locked;
1493 tp_loc = &driver->termios[idx];
1494 ltp_loc = &driver->termios_locked[idx];
1498 tp = (struct termios *) kmalloc(sizeof(struct termios),
1502 *tp = driver->init_termios;
1506 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1510 memset(ltp, 0, sizeof(struct termios));
1513 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1514 o_tty = alloc_tty_struct();
1517 initialize_tty_struct(o_tty);
1518 o_tty->driver = driver->other;
1520 tty_line_name(driver->other, idx, o_tty->name);
1522 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1523 o_tp_loc = &o_tty->termios;
1524 o_ltp_loc = &o_tty->termios_locked;
1526 o_tp_loc = &driver->other->termios[idx];
1527 o_ltp_loc = &driver->other->termios_locked[idx];
1531 o_tp = (struct termios *)
1532 kmalloc(sizeof(struct termios), GFP_KERNEL);
1535 *o_tp = driver->other->init_termios;
1539 o_ltp = (struct termios *)
1540 kmalloc(sizeof(struct termios), GFP_KERNEL);
1543 memset(o_ltp, 0, sizeof(struct termios));
1547 * Everything allocated ... set up the o_tty structure.
1549 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1550 driver->other->ttys[idx] = o_tty;
1556 o_tty->termios = *o_tp_loc;
1557 o_tty->termios_locked = *o_ltp_loc;
1558 driver->other->refcount++;
1559 if (driver->subtype == PTY_TYPE_MASTER)
1562 /* Establish the links in both directions */
1568 * All structures have been allocated, so now we install them.
1569 * Failures after this point use release_mem to clean up, so
1570 * there's no need to null out the local pointers.
1572 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1573 driver->ttys[idx] = tty;
1580 tty->termios = *tp_loc;
1581 tty->termios_locked = *ltp_loc;
1586 * Structures all installed ... call the ldisc open routines.
1587 * If we fail here just call release_mem to clean up. No need
1588 * to decrement the use counts, as release_mem doesn't care.
1591 if (tty->ldisc.open) {
1592 retval = (tty->ldisc.open)(tty);
1594 goto release_mem_out;
1596 if (o_tty && o_tty->ldisc.open) {
1597 retval = (o_tty->ldisc.open)(o_tty);
1599 if (tty->ldisc.close)
1600 (tty->ldisc.close)(tty);
1601 goto release_mem_out;
1603 tty_ldisc_enable(o_tty);
1605 tty_ldisc_enable(tty);
1609 * This fast open can be used if the tty is already open.
1610 * No memory is allocated, and the only failures are from
1611 * attempting to open a closing tty or attempting multiple
1612 * opens on a pty master.
1615 if (test_bit(TTY_CLOSING, &tty->flags)) {
1619 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1620 driver->subtype == PTY_TYPE_MASTER) {
1622 * special case for PTY masters: only one open permitted,
1623 * and the slave side open count is incremented as well.
1632 tty->driver = driver; /* N.B. why do this every time?? */
1635 if(!test_bit(TTY_LDISC, &tty->flags))
1636 printk(KERN_ERR "init_dev but no ldisc\n");
1640 /* All paths come through here to release the mutex */
1644 /* Release locally allocated memory ... nothing placed in slots */
1648 free_tty_struct(o_tty);
1651 free_tty_struct(tty);
1654 module_put(driver->owner);
1658 /* call the tty release_mem routine to clean out this slot */
1660 printk(KERN_INFO "init_dev: ldisc open failed, "
1661 "clearing slot %d\n", idx);
1662 release_mem(tty, idx);
1667 * Releases memory associated with a tty structure, and clears out the
1668 * driver table slots.
1670 static void release_mem(struct tty_struct *tty, int idx)
1672 struct tty_struct *o_tty;
1674 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1676 if ((o_tty = tty->link) != NULL) {
1678 o_tty->driver->ttys[idx] = NULL;
1679 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1680 tp = o_tty->termios;
1682 o_tty->driver->termios[idx] = NULL;
1685 tp = o_tty->termios_locked;
1687 o_tty->driver->termios_locked[idx] = NULL;
1691 o_tty->driver->refcount--;
1693 list_del_init(&o_tty->tty_files);
1695 free_tty_struct(o_tty);
1699 tty->driver->ttys[idx] = NULL;
1700 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1703 tty->driver->termios[idx] = NULL;
1706 tp = tty->termios_locked;
1708 tty->driver->termios_locked[idx] = NULL;
1713 tty->driver->refcount--;
1715 list_del_init(&tty->tty_files);
1717 module_put(tty->driver->owner);
1718 free_tty_struct(tty);
1722 * Even releasing the tty structures is a tricky business.. We have
1723 * to be very careful that the structures are all released at the
1724 * same time, as interrupts might otherwise get the wrong pointers.
1726 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1727 * lead to double frees or releasing memory still in use.
1729 static void release_dev(struct file * filp)
1731 struct tty_struct *tty, *o_tty;
1732 int pty_master, tty_closing, o_tty_closing, do_sleep;
1736 unsigned long flags;
1738 tty = (struct tty_struct *)filp->private_data;
1739 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1742 check_tty_count(tty, "release_dev");
1744 tty_fasync(-1, filp, 0);
1747 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1748 tty->driver->subtype == PTY_TYPE_MASTER);
1749 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1752 #ifdef TTY_PARANOIA_CHECK
1753 if (idx < 0 || idx >= tty->driver->num) {
1754 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1755 "free (%s)\n", tty->name);
1758 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1759 if (tty != tty->driver->ttys[idx]) {
1760 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1761 "for (%s)\n", idx, tty->name);
1764 if (tty->termios != tty->driver->termios[idx]) {
1765 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1770 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1771 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1772 "termios_locked for (%s)\n",
1779 #ifdef TTY_DEBUG_HANGUP
1780 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1781 tty_name(tty, buf), tty->count);
1784 #ifdef TTY_PARANOIA_CHECK
1785 if (tty->driver->other &&
1786 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1787 if (o_tty != tty->driver->other->ttys[idx]) {
1788 printk(KERN_DEBUG "release_dev: other->table[%d] "
1789 "not o_tty for (%s)\n",
1793 if (o_tty->termios != tty->driver->other->termios[idx]) {
1794 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1795 "not o_termios for (%s)\n",
1799 if (o_tty->termios_locked !=
1800 tty->driver->other->termios_locked[idx]) {
1801 printk(KERN_DEBUG "release_dev: other->termios_locked["
1802 "%d] not o_termios_locked for (%s)\n",
1806 if (o_tty->link != tty) {
1807 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1812 if (tty->driver->close)
1813 tty->driver->close(tty, filp);
1816 * Sanity check: if tty->count is going to zero, there shouldn't be
1817 * any waiters on tty->read_wait or tty->write_wait. We test the
1818 * wait queues and kick everyone out _before_ actually starting to
1819 * close. This ensures that we won't block while releasing the tty
1822 * The test for the o_tty closing is necessary, since the master and
1823 * slave sides may close in any order. If the slave side closes out
1824 * first, its count will be one, since the master side holds an open.
1825 * Thus this test wouldn't be triggered at the time the slave closes,
1828 * Note that it's possible for the tty to be opened again while we're
1829 * flushing out waiters. By recalculating the closing flags before
1830 * each iteration we avoid any problems.
1833 /* Guard against races with tty->count changes elsewhere and
1834 opens on /dev/tty */
1836 mutex_lock(&tty_mutex);
1837 tty_closing = tty->count <= 1;
1838 o_tty_closing = o_tty &&
1839 (o_tty->count <= (pty_master ? 1 : 0));
1843 if (waitqueue_active(&tty->read_wait)) {
1844 wake_up(&tty->read_wait);
1847 if (waitqueue_active(&tty->write_wait)) {
1848 wake_up(&tty->write_wait);
1852 if (o_tty_closing) {
1853 if (waitqueue_active(&o_tty->read_wait)) {
1854 wake_up(&o_tty->read_wait);
1857 if (waitqueue_active(&o_tty->write_wait)) {
1858 wake_up(&o_tty->write_wait);
1865 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1866 "active!\n", tty_name(tty, buf));
1867 mutex_unlock(&tty_mutex);
1872 * The closing flags are now consistent with the open counts on
1873 * both sides, and we've completed the last operation that could
1874 * block, so it's safe to proceed with closing.
1877 if (--o_tty->count < 0) {
1878 printk(KERN_WARNING "release_dev: bad pty slave count "
1880 o_tty->count, tty_name(o_tty, buf));
1884 if (--tty->count < 0) {
1885 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1886 tty->count, tty_name(tty, buf));
1891 * We've decremented tty->count, so we need to remove this file
1892 * descriptor off the tty->tty_files list; this serves two
1894 * - check_tty_count sees the correct number of file descriptors
1895 * associated with this tty.
1896 * - do_tty_hangup no longer sees this file descriptor as
1897 * something that needs to be handled for hangups.
1900 filp->private_data = NULL;
1903 * Perform some housekeeping before deciding whether to return.
1905 * Set the TTY_CLOSING flag if this was the last open. In the
1906 * case of a pty we may have to wait around for the other side
1907 * to close, and TTY_CLOSING makes sure we can't be reopened.
1910 set_bit(TTY_CLOSING, &tty->flags);
1912 set_bit(TTY_CLOSING, &o_tty->flags);
1915 * If _either_ side is closing, make sure there aren't any
1916 * processes that still think tty or o_tty is their controlling
1919 if (tty_closing || o_tty_closing) {
1920 struct task_struct *p;
1922 read_lock(&tasklist_lock);
1923 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1924 p->signal->tty = NULL;
1925 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1927 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1928 p->signal->tty = NULL;
1929 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1930 read_unlock(&tasklist_lock);
1933 mutex_unlock(&tty_mutex);
1935 /* check whether both sides are closing ... */
1936 if (!tty_closing || (o_tty && !o_tty_closing))
1939 #ifdef TTY_DEBUG_HANGUP
1940 printk(KERN_DEBUG "freeing tty structure...");
1943 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1944 * kill any delayed work. As this is the final close it does not
1945 * race with the set_ldisc code path.
1947 clear_bit(TTY_LDISC, &tty->flags);
1948 cancel_delayed_work(&tty->buf.work);
1951 * Wait for ->hangup_work and ->buf.work handlers to terminate
1954 flush_scheduled_work();
1957 * Wait for any short term users (we know they are just driver
1958 * side waiters as the file is closing so user count on the file
1961 spin_lock_irqsave(&tty_ldisc_lock, flags);
1962 while(tty->ldisc.refcount)
1964 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1965 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1966 spin_lock_irqsave(&tty_ldisc_lock, flags);
1968 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1970 * Shutdown the current line discipline, and reset it to N_TTY.
1971 * N.B. why reset ldisc when we're releasing the memory??
1973 * FIXME: this MUST get fixed for the new reflocking
1975 if (tty->ldisc.close)
1976 (tty->ldisc.close)(tty);
1977 tty_ldisc_put(tty->ldisc.num);
1980 * Switch the line discipline back
1982 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1983 tty_set_termios_ldisc(tty,N_TTY);
1985 /* FIXME: could o_tty be in setldisc here ? */
1986 clear_bit(TTY_LDISC, &o_tty->flags);
1987 if (o_tty->ldisc.close)
1988 (o_tty->ldisc.close)(o_tty);
1989 tty_ldisc_put(o_tty->ldisc.num);
1990 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1991 tty_set_termios_ldisc(o_tty,N_TTY);
1994 * The release_mem function takes care of the details of clearing
1995 * the slots and preserving the termios structure.
1997 release_mem(tty, idx);
1999 #ifdef CONFIG_UNIX98_PTYS
2000 /* Make this pty number available for reallocation */
2002 down(&allocated_ptys_lock);
2003 idr_remove(&allocated_ptys, idx);
2004 up(&allocated_ptys_lock);
2011 * tty_open and tty_release keep up the tty count that contains the
2012 * number of opens done on a tty. We cannot use the inode-count, as
2013 * different inodes might point to the same tty.
2015 * Open-counting is needed for pty masters, as well as for keeping
2016 * track of serial lines: DTR is dropped when the last close happens.
2017 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2019 * The termios state of a pty is reset on first open so that
2020 * settings don't persist across reuse.
2022 static int tty_open(struct inode * inode, struct file * filp)
2024 struct tty_struct *tty;
2026 struct tty_driver *driver;
2028 dev_t device = inode->i_rdev;
2029 unsigned short saved_flags = filp->f_flags;
2031 nonseekable_open(inode, filp);
2034 noctty = filp->f_flags & O_NOCTTY;
2038 mutex_lock(&tty_mutex);
2040 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2041 if (!current->signal->tty) {
2042 mutex_unlock(&tty_mutex);
2045 driver = current->signal->tty->driver;
2046 index = current->signal->tty->index;
2047 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2052 if (device == MKDEV(TTY_MAJOR,0)) {
2053 extern struct tty_driver *console_driver;
2054 driver = console_driver;
2060 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2061 driver = console_device(&index);
2063 /* Don't let /dev/console block */
2064 filp->f_flags |= O_NONBLOCK;
2068 mutex_unlock(&tty_mutex);
2072 driver = get_tty_driver(device, &index);
2074 mutex_unlock(&tty_mutex);
2078 retval = init_dev(driver, index, &tty);
2079 mutex_unlock(&tty_mutex);
2083 filp->private_data = tty;
2084 file_move(filp, &tty->tty_files);
2085 check_tty_count(tty, "tty_open");
2086 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2087 tty->driver->subtype == PTY_TYPE_MASTER)
2089 #ifdef TTY_DEBUG_HANGUP
2090 printk(KERN_DEBUG "opening %s...", tty->name);
2093 if (tty->driver->open)
2094 retval = tty->driver->open(tty, filp);
2098 filp->f_flags = saved_flags;
2100 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2104 #ifdef TTY_DEBUG_HANGUP
2105 printk(KERN_DEBUG "error %d in opening %s...", retval,
2109 if (retval != -ERESTARTSYS)
2111 if (signal_pending(current))
2115 * Need to reset f_op in case a hangup happened.
2117 if (filp->f_op == &hung_up_tty_fops)
2118 filp->f_op = &tty_fops;
2122 current->signal->leader &&
2123 !current->signal->tty &&
2124 tty->session == 0) {
2126 current->signal->tty = tty;
2127 task_unlock(current);
2128 current->signal->tty_old_pgrp = 0;
2129 tty->session = current->signal->session;
2130 tty->pgrp = process_group(current);
2135 #ifdef CONFIG_UNIX98_PTYS
2136 static int ptmx_open(struct inode * inode, struct file * filp)
2138 struct tty_struct *tty;
2143 nonseekable_open(inode, filp);
2145 /* find a device that is not in use. */
2146 down(&allocated_ptys_lock);
2147 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2148 up(&allocated_ptys_lock);
2151 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2153 up(&allocated_ptys_lock);
2154 if (idr_ret == -EAGAIN)
2158 if (index >= pty_limit) {
2159 idr_remove(&allocated_ptys, index);
2160 up(&allocated_ptys_lock);
2163 up(&allocated_ptys_lock);
2165 mutex_lock(&tty_mutex);
2166 retval = init_dev(ptm_driver, index, &tty);
2167 mutex_unlock(&tty_mutex);
2172 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2173 filp->private_data = tty;
2174 file_move(filp, &tty->tty_files);
2177 if (devpts_pty_new(tty->link))
2180 check_tty_count(tty, "tty_open");
2181 retval = ptm_driver->open(tty, filp);
2188 down(&allocated_ptys_lock);
2189 idr_remove(&allocated_ptys, index);
2190 up(&allocated_ptys_lock);
2195 static int tty_release(struct inode * inode, struct file * filp)
2203 /* No kernel lock held - fine */
2204 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2206 struct tty_struct * tty;
2207 struct tty_ldisc *ld;
2210 tty = (struct tty_struct *)filp->private_data;
2211 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2214 ld = tty_ldisc_ref_wait(tty);
2216 ret = (ld->poll)(tty, filp, wait);
2217 tty_ldisc_deref(ld);
2221 static int tty_fasync(int fd, struct file * filp, int on)
2223 struct tty_struct * tty;
2226 tty = (struct tty_struct *)filp->private_data;
2227 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2230 retval = fasync_helper(fd, filp, on, &tty->fasync);
2235 if (!waitqueue_active(&tty->read_wait))
2236 tty->minimum_to_wake = 1;
2237 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2241 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2242 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2247 static int tiocsti(struct tty_struct *tty, char __user *p)
2250 struct tty_ldisc *ld;
2252 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2254 if (get_user(ch, p))
2256 ld = tty_ldisc_ref_wait(tty);
2257 ld->receive_buf(tty, &ch, &mbz, 1);
2258 tty_ldisc_deref(ld);
2262 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2264 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2269 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2270 struct winsize __user * arg)
2272 struct winsize tmp_ws;
2274 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2276 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2279 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2282 acquire_console_sem();
2283 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2284 release_console_sem();
2290 kill_pg(tty->pgrp, SIGWINCH, 1);
2291 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2292 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2293 tty->winsize = tmp_ws;
2294 real_tty->winsize = tmp_ws;
2298 static int tioccons(struct file *file)
2300 if (!capable(CAP_SYS_ADMIN))
2302 if (file->f_op->write == redirected_tty_write) {
2304 spin_lock(&redirect_lock);
2307 spin_unlock(&redirect_lock);
2312 spin_lock(&redirect_lock);
2314 spin_unlock(&redirect_lock);
2319 spin_unlock(&redirect_lock);
2324 static int fionbio(struct file *file, int __user *p)
2328 if (get_user(nonblock, p))
2332 file->f_flags |= O_NONBLOCK;
2334 file->f_flags &= ~O_NONBLOCK;
2338 static int tiocsctty(struct tty_struct *tty, int arg)
2342 if (current->signal->leader &&
2343 (current->signal->session == tty->session))
2346 * The process must be a session leader and
2347 * not have a controlling tty already.
2349 if (!current->signal->leader || current->signal->tty)
2351 if (tty->session > 0) {
2353 * This tty is already the controlling
2354 * tty for another session group!
2356 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2361 read_lock(&tasklist_lock);
2362 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2363 p->signal->tty = NULL;
2364 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2365 read_unlock(&tasklist_lock);
2370 current->signal->tty = tty;
2371 task_unlock(current);
2372 current->signal->tty_old_pgrp = 0;
2373 tty->session = current->signal->session;
2374 tty->pgrp = process_group(current);
2378 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2381 * (tty == real_tty) is a cheap way of
2382 * testing if the tty is NOT a master pty.
2384 if (tty == real_tty && current->signal->tty != real_tty)
2386 return put_user(real_tty->pgrp, p);
2389 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2392 int retval = tty_check_change(real_tty);
2398 if (!current->signal->tty ||
2399 (current->signal->tty != real_tty) ||
2400 (real_tty->session != current->signal->session))
2402 if (get_user(pgrp, p))
2406 if (session_of_pgrp(pgrp) != current->signal->session)
2408 real_tty->pgrp = pgrp;
2412 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2415 * (tty == real_tty) is a cheap way of
2416 * testing if the tty is NOT a master pty.
2418 if (tty == real_tty && current->signal->tty != real_tty)
2420 if (real_tty->session <= 0)
2422 return put_user(real_tty->session, p);
2425 static int tiocsetd(struct tty_struct *tty, int __user *p)
2429 if (get_user(ldisc, p))
2431 return tty_set_ldisc(tty, ldisc);
2434 static int send_break(struct tty_struct *tty, unsigned int duration)
2436 tty->driver->break_ctl(tty, -1);
2437 if (!signal_pending(current)) {
2438 msleep_interruptible(duration);
2440 tty->driver->break_ctl(tty, 0);
2441 if (signal_pending(current))
2447 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2449 int retval = -EINVAL;
2451 if (tty->driver->tiocmget) {
2452 retval = tty->driver->tiocmget(tty, file);
2455 retval = put_user(retval, p);
2461 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2464 int retval = -EINVAL;
2466 if (tty->driver->tiocmset) {
2467 unsigned int set, clear, val;
2469 retval = get_user(val, p);
2487 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2488 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2490 retval = tty->driver->tiocmset(tty, file, set, clear);
2496 * Split this up, as gcc can choke on it otherwise..
2498 int tty_ioctl(struct inode * inode, struct file * file,
2499 unsigned int cmd, unsigned long arg)
2501 struct tty_struct *tty, *real_tty;
2502 void __user *p = (void __user *)arg;
2504 struct tty_ldisc *ld;
2506 tty = (struct tty_struct *)file->private_data;
2507 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2511 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2512 tty->driver->subtype == PTY_TYPE_MASTER)
2513 real_tty = tty->link;
2516 * Break handling by driver
2518 if (!tty->driver->break_ctl) {
2522 if (tty->driver->ioctl)
2523 return tty->driver->ioctl(tty, file, cmd, arg);
2526 /* These two ioctl's always return success; even if */
2527 /* the driver doesn't support them. */
2530 if (!tty->driver->ioctl)
2532 retval = tty->driver->ioctl(tty, file, cmd, arg);
2533 if (retval == -ENOIOCTLCMD)
2540 * Factor out some common prep work
2548 retval = tty_check_change(tty);
2551 if (cmd != TIOCCBRK) {
2552 tty_wait_until_sent(tty, 0);
2553 if (signal_pending(current))
2561 return tiocsti(tty, p);
2563 return tiocgwinsz(tty, p);
2565 return tiocswinsz(tty, real_tty, p);
2567 return real_tty!=tty ? -EINVAL : tioccons(file);
2569 return fionbio(file, p);
2571 set_bit(TTY_EXCLUSIVE, &tty->flags);
2574 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2577 if (current->signal->tty != tty)
2579 if (current->signal->leader)
2580 disassociate_ctty(0);
2582 current->signal->tty = NULL;
2583 task_unlock(current);
2586 return tiocsctty(tty, arg);
2588 return tiocgpgrp(tty, real_tty, p);
2590 return tiocspgrp(tty, real_tty, p);
2592 return tiocgsid(tty, real_tty, p);
2594 /* FIXME: check this is ok */
2595 return put_user(tty->ldisc.num, (int __user *)p);
2597 return tiocsetd(tty, p);
2600 return tioclinux(tty, arg);
2605 case TIOCSBRK: /* Turn break on, unconditionally */
2606 tty->driver->break_ctl(tty, -1);
2609 case TIOCCBRK: /* Turn break off, unconditionally */
2610 tty->driver->break_ctl(tty, 0);
2612 case TCSBRK: /* SVID version: non-zero arg --> no break */
2613 /* non-zero arg means wait for all output data
2614 * to be sent (performed above) but don't send break.
2615 * This is used by the tcdrain() termios function.
2618 return send_break(tty, 250);
2620 case TCSBRKP: /* support for POSIX tcsendbreak() */
2621 return send_break(tty, arg ? arg*100 : 250);
2624 return tty_tiocmget(tty, file, p);
2629 return tty_tiocmset(tty, file, cmd, p);
2631 if (tty->driver->ioctl) {
2632 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2633 if (retval != -ENOIOCTLCMD)
2636 ld = tty_ldisc_ref_wait(tty);
2639 retval = ld->ioctl(tty, file, cmd, arg);
2640 if (retval == -ENOIOCTLCMD)
2643 tty_ldisc_deref(ld);
2649 * This implements the "Secure Attention Key" --- the idea is to
2650 * prevent trojan horses by killing all processes associated with this
2651 * tty when the user hits the "Secure Attention Key". Required for
2652 * super-paranoid applications --- see the Orange Book for more details.
2654 * This code could be nicer; ideally it should send a HUP, wait a few
2655 * seconds, then send a INT, and then a KILL signal. But you then
2656 * have to coordinate with the init process, since all processes associated
2657 * with the current tty must be dead before the new getty is allowed
2660 * Now, if it would be correct ;-/ The current code has a nasty hole -
2661 * it doesn't catch files in flight. We may send the descriptor to ourselves
2662 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2664 * Nasty bug: do_SAK is being called in interrupt context. This can
2665 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2667 static void __do_SAK(void *arg)
2672 struct tty_struct *tty = arg;
2673 struct task_struct *g, *p;
2677 struct tty_ldisc *disc;
2678 struct fdtable *fdt;
2682 session = tty->session;
2684 /* We don't want an ldisc switch during this */
2685 disc = tty_ldisc_ref(tty);
2686 if (disc && disc->flush_buffer)
2687 disc->flush_buffer(tty);
2688 tty_ldisc_deref(disc);
2690 if (tty->driver->flush_buffer)
2691 tty->driver->flush_buffer(tty);
2693 read_lock(&tasklist_lock);
2694 /* Kill the entire session */
2695 do_each_task_pid(session, PIDTYPE_SID, p) {
2696 printk(KERN_NOTICE "SAK: killed process %d"
2697 " (%s): p->signal->session==tty->session\n",
2699 send_sig(SIGKILL, p, 1);
2700 } while_each_task_pid(session, PIDTYPE_SID, p);
2701 /* Now kill any processes that happen to have the
2704 do_each_thread(g, p) {
2705 if (p->signal->tty == tty) {
2706 printk(KERN_NOTICE "SAK: killed process %d"
2707 " (%s): p->signal->session==tty->session\n",
2709 send_sig(SIGKILL, p, 1);
2715 * We don't take a ref to the file, so we must
2716 * hold ->file_lock instead.
2718 spin_lock(&p->files->file_lock);
2719 fdt = files_fdtable(p->files);
2720 for (i=0; i < fdt->max_fds; i++) {
2721 filp = fcheck_files(p->files, i);
2724 if (filp->f_op->read == tty_read &&
2725 filp->private_data == tty) {
2726 printk(KERN_NOTICE "SAK: killed process %d"
2727 " (%s): fd#%d opened to the tty\n",
2728 p->pid, p->comm, i);
2729 force_sig(SIGKILL, p);
2733 spin_unlock(&p->files->file_lock);
2736 } while_each_thread(g, p);
2737 read_unlock(&tasklist_lock);
2742 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2743 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2744 * the values which we write to it will be identical to the values which it
2745 * already has. --akpm
2747 void do_SAK(struct tty_struct *tty)
2751 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2752 schedule_work(&tty->SAK_work);
2755 EXPORT_SYMBOL(do_SAK);
2758 * This routine is called out of the software interrupt to flush data
2759 * from the buffer chain to the line discipline.
2762 static void flush_to_ldisc(void *private_)
2764 struct tty_struct *tty = (struct tty_struct *) private_;
2765 unsigned long flags;
2766 struct tty_ldisc *disc;
2767 struct tty_buffer *tbuf, *head;
2769 unsigned char *flag_buf;
2771 disc = tty_ldisc_ref(tty);
2772 if (disc == NULL) /* !TTY_LDISC */
2775 spin_lock_irqsave(&tty->buf.lock, flags);
2776 head = tty->buf.head;
2778 tty->buf.head = NULL;
2780 int count = head->commit - head->read;
2782 if (head->next == NULL)
2786 tty_buffer_free(tty, tbuf);
2789 if (!tty->receive_room) {
2790 schedule_delayed_work(&tty->buf.work, 1);
2793 if (count > tty->receive_room)
2794 count = tty->receive_room;
2795 char_buf = head->char_buf_ptr + head->read;
2796 flag_buf = head->flag_buf_ptr + head->read;
2797 head->read += count;
2798 spin_unlock_irqrestore(&tty->buf.lock, flags);
2799 disc->receive_buf(tty, char_buf, flag_buf, count);
2800 spin_lock_irqsave(&tty->buf.lock, flags);
2802 tty->buf.head = head;
2804 spin_unlock_irqrestore(&tty->buf.lock, flags);
2806 tty_ldisc_deref(disc);
2810 * Routine which returns the baud rate of the tty
2812 * Note that the baud_table needs to be kept in sync with the
2813 * include/asm/termbits.h file.
2815 static int baud_table[] = {
2816 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2817 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2819 76800, 153600, 307200, 614400, 921600
2821 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2822 2500000, 3000000, 3500000, 4000000
2826 static int n_baud_table = ARRAY_SIZE(baud_table);
2829 * tty_termios_baud_rate
2830 * @termios: termios structure
2832 * Convert termios baud rate data into a speed. This should be called
2833 * with the termios lock held if this termios is a terminal termios
2834 * structure. May change the termios data.
2837 int tty_termios_baud_rate(struct termios *termios)
2841 cbaud = termios->c_cflag & CBAUD;
2843 if (cbaud & CBAUDEX) {
2846 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2847 termios->c_cflag &= ~CBAUDEX;
2851 return baud_table[cbaud];
2854 EXPORT_SYMBOL(tty_termios_baud_rate);
2857 * tty_get_baud_rate - get tty bit rates
2858 * @tty: tty to query
2860 * Returns the baud rate as an integer for this terminal. The
2861 * termios lock must be held by the caller and the terminal bit
2862 * flags may be updated.
2865 int tty_get_baud_rate(struct tty_struct *tty)
2867 int baud = tty_termios_baud_rate(tty->termios);
2869 if (baud == 38400 && tty->alt_speed) {
2871 printk(KERN_WARNING "Use of setserial/setrocket to "
2872 "set SPD_* flags is deprecated\n");
2875 baud = tty->alt_speed;
2881 EXPORT_SYMBOL(tty_get_baud_rate);
2884 * tty_flip_buffer_push - terminal
2887 * Queue a push of the terminal flip buffers to the line discipline. This
2888 * function must not be called from IRQ context if tty->low_latency is set.
2890 * In the event of the queue being busy for flipping the work will be
2891 * held off and retried later.
2894 void tty_flip_buffer_push(struct tty_struct *tty)
2896 unsigned long flags;
2897 spin_lock_irqsave(&tty->buf.lock, flags);
2898 if (tty->buf.tail != NULL)
2899 tty->buf.tail->commit = tty->buf.tail->used;
2900 spin_unlock_irqrestore(&tty->buf.lock, flags);
2902 if (tty->low_latency)
2903 flush_to_ldisc((void *) tty);
2905 schedule_delayed_work(&tty->buf.work, 1);
2908 EXPORT_SYMBOL(tty_flip_buffer_push);
2912 * This subroutine initializes a tty structure.
2914 static void initialize_tty_struct(struct tty_struct *tty)
2916 memset(tty, 0, sizeof(struct tty_struct));
2917 tty->magic = TTY_MAGIC;
2918 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2920 tty->overrun_time = jiffies;
2921 tty->buf.head = tty->buf.tail = NULL;
2922 tty_buffer_init(tty);
2923 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
2924 init_MUTEX(&tty->buf.pty_sem);
2925 init_MUTEX(&tty->termios_sem);
2926 init_waitqueue_head(&tty->write_wait);
2927 init_waitqueue_head(&tty->read_wait);
2928 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2929 mutex_init(&tty->atomic_read_lock);
2930 mutex_init(&tty->atomic_write_lock);
2931 spin_lock_init(&tty->read_lock);
2932 INIT_LIST_HEAD(&tty->tty_files);
2933 INIT_WORK(&tty->SAK_work, NULL, NULL);
2937 * The default put_char routine if the driver did not define one.
2939 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2941 tty->driver->write(tty, &ch, 1);
2944 static struct class *tty_class;
2947 * tty_register_device - register a tty device
2948 * @driver: the tty driver that describes the tty device
2949 * @index: the index in the tty driver for this tty device
2950 * @device: a struct device that is associated with this tty device.
2951 * This field is optional, if there is no known struct device for this
2952 * tty device it can be set to NULL safely.
2954 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
2956 * This call is required to be made to register an individual tty device if
2957 * the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If that
2958 * bit is not set, this function should not be called by a tty driver.
2960 struct class_device *tty_register_device(struct tty_driver *driver,
2961 unsigned index, struct device *device)
2964 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2966 if (index >= driver->num) {
2967 printk(KERN_ERR "Attempt to register invalid tty line number "
2969 return ERR_PTR(-EINVAL);
2972 if (driver->type == TTY_DRIVER_TYPE_PTY)
2973 pty_line_name(driver, index, name);
2975 tty_line_name(driver, index, name);
2977 return class_device_create(tty_class, NULL, dev, device, "%s", name);
2981 * tty_unregister_device - unregister a tty device
2982 * @driver: the tty driver that describes the tty device
2983 * @index: the index in the tty driver for this tty device
2985 * If a tty device is registered with a call to tty_register_device() then
2986 * this function must be made when the tty device is gone.
2988 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2990 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
2993 EXPORT_SYMBOL(tty_register_device);
2994 EXPORT_SYMBOL(tty_unregister_device);
2996 struct tty_driver *alloc_tty_driver(int lines)
2998 struct tty_driver *driver;
3000 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3002 memset(driver, 0, sizeof(struct tty_driver));
3003 driver->magic = TTY_DRIVER_MAGIC;
3004 driver->num = lines;
3005 /* later we'll move allocation of tables here */
3010 void put_tty_driver(struct tty_driver *driver)
3015 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3017 driver->open = op->open;
3018 driver->close = op->close;
3019 driver->write = op->write;
3020 driver->put_char = op->put_char;
3021 driver->flush_chars = op->flush_chars;
3022 driver->write_room = op->write_room;
3023 driver->chars_in_buffer = op->chars_in_buffer;
3024 driver->ioctl = op->ioctl;
3025 driver->set_termios = op->set_termios;
3026 driver->throttle = op->throttle;
3027 driver->unthrottle = op->unthrottle;
3028 driver->stop = op->stop;
3029 driver->start = op->start;
3030 driver->hangup = op->hangup;
3031 driver->break_ctl = op->break_ctl;
3032 driver->flush_buffer = op->flush_buffer;
3033 driver->set_ldisc = op->set_ldisc;
3034 driver->wait_until_sent = op->wait_until_sent;
3035 driver->send_xchar = op->send_xchar;
3036 driver->read_proc = op->read_proc;
3037 driver->write_proc = op->write_proc;
3038 driver->tiocmget = op->tiocmget;
3039 driver->tiocmset = op->tiocmset;
3043 EXPORT_SYMBOL(alloc_tty_driver);
3044 EXPORT_SYMBOL(put_tty_driver);
3045 EXPORT_SYMBOL(tty_set_operations);
3048 * Called by a tty driver to register itself.
3050 int tty_register_driver(struct tty_driver *driver)
3057 if (driver->flags & TTY_DRIVER_INSTALLED)
3060 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3061 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3064 memset(p, 0, driver->num * 3 * sizeof(void *));
3067 if (!driver->major) {
3068 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3069 (char*)driver->name);
3071 driver->major = MAJOR(dev);
3072 driver->minor_start = MINOR(dev);
3075 dev = MKDEV(driver->major, driver->minor_start);
3076 error = register_chrdev_region(dev, driver->num,
3077 (char*)driver->name);
3085 driver->ttys = (struct tty_struct **)p;
3086 driver->termios = (struct termios **)(p + driver->num);
3087 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3089 driver->ttys = NULL;
3090 driver->termios = NULL;
3091 driver->termios_locked = NULL;
3094 cdev_init(&driver->cdev, &tty_fops);
3095 driver->cdev.owner = driver->owner;
3096 error = cdev_add(&driver->cdev, dev, driver->num);
3098 cdev_del(&driver->cdev);
3099 unregister_chrdev_region(dev, driver->num);
3100 driver->ttys = NULL;
3101 driver->termios = driver->termios_locked = NULL;
3106 if (!driver->put_char)
3107 driver->put_char = tty_default_put_char;
3109 list_add(&driver->tty_drivers, &tty_drivers);
3111 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3112 for(i = 0; i < driver->num; i++)
3113 tty_register_device(driver, i, NULL);
3115 proc_tty_register_driver(driver);
3119 EXPORT_SYMBOL(tty_register_driver);
3122 * Called by a tty driver to unregister itself.
3124 int tty_unregister_driver(struct tty_driver *driver)
3130 if (driver->refcount)
3133 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3136 list_del(&driver->tty_drivers);
3139 * Free the termios and termios_locked structures because
3140 * we don't want to get memory leaks when modular tty
3141 * drivers are removed from the kernel.
3143 for (i = 0; i < driver->num; i++) {
3144 tp = driver->termios[i];
3146 driver->termios[i] = NULL;
3149 tp = driver->termios_locked[i];
3151 driver->termios_locked[i] = NULL;
3154 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3155 tty_unregister_device(driver, i);
3158 proc_tty_unregister_driver(driver);
3159 driver->ttys = NULL;
3160 driver->termios = driver->termios_locked = NULL;
3162 cdev_del(&driver->cdev);
3166 EXPORT_SYMBOL(tty_unregister_driver);
3170 * Initialize the console device. This is called *early*, so
3171 * we can't necessarily depend on lots of kernel help here.
3172 * Just do some early initializations, and do the complex setup
3175 void __init console_init(void)
3179 /* Setup the default TTY line discipline. */
3180 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3183 * set up the console device so that later boot sequences can
3184 * inform about problems etc..
3186 #ifdef CONFIG_EARLY_PRINTK
3187 disable_early_printk();
3189 call = __con_initcall_start;
3190 while (call < __con_initcall_end) {
3197 extern int vty_init(void);
3200 static int __init tty_class_init(void)
3202 tty_class = class_create(THIS_MODULE, "tty");
3203 if (IS_ERR(tty_class))
3204 return PTR_ERR(tty_class);
3208 postcore_initcall(tty_class_init);
3210 /* 3/2004 jmc: why do these devices exist? */
3212 static struct cdev tty_cdev, console_cdev;
3213 #ifdef CONFIG_UNIX98_PTYS
3214 static struct cdev ptmx_cdev;
3217 static struct cdev vc0_cdev;
3221 * Ok, now we can initialize the rest of the tty devices and can count
3222 * on memory allocations, interrupts etc..
3224 static int __init tty_init(void)
3226 cdev_init(&tty_cdev, &tty_fops);
3227 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3228 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3229 panic("Couldn't register /dev/tty driver\n");
3230 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3232 cdev_init(&console_cdev, &console_fops);
3233 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3234 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3235 panic("Couldn't register /dev/console driver\n");
3236 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3238 #ifdef CONFIG_UNIX98_PTYS
3239 cdev_init(&ptmx_cdev, &ptmx_fops);
3240 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3241 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3242 panic("Couldn't register /dev/ptmx driver\n");
3243 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3247 cdev_init(&vc0_cdev, &console_fops);
3248 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3249 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3250 panic("Couldn't register /dev/tty0 driver\n");
3251 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3257 module_init(tty_init);