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 DECLARE_MUTEX(tty_sem);
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);
356 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
358 int tty_insert_flip_string(struct tty_struct *tty, unsigned char *chars, size_t size)
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);
372 /* printk("Flip insert %d.\n", space); */
374 /* There is a small chance that we need to split the data over
375 several buffers. If this is the case we must loop */
376 while (unlikely(size > copied));
380 EXPORT_SYMBOL_GPL(tty_insert_flip_string);
382 int tty_insert_flip_string_flags(struct tty_struct *tty, unsigned char *chars, char *flags, size_t size)
386 int space = tty_buffer_request_room(tty, size - copied);
387 struct tty_buffer *tb = tty->buf.tail;
388 /* If there is no space then tb may be NULL */
389 if(unlikely(space == 0))
391 memcpy(tb->char_buf_ptr + tb->used, chars, space);
392 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
398 /* There is a small chance that we need to split the data over
399 several buffers. If this is the case we must loop */
400 while (unlikely(size > copied));
404 EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags);
408 * Prepare a block of space in the buffer for data. Returns the length
409 * available and buffer pointer to the space which is now allocated and
410 * accounted for as ready for normal characters. This is used for drivers
411 * that need their own block copy routines into the buffer. There is no
412 * guarantee the buffer is a DMA target!
415 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
417 int space = tty_buffer_request_room(tty, size);
419 struct tty_buffer *tb = tty->buf.tail;
420 *chars = tb->char_buf_ptr + tb->used;
421 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
427 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
430 * Prepare a block of space in the buffer for data. Returns the length
431 * available and buffer pointer to the space which is now allocated and
432 * accounted for as ready for characters. This is used for drivers
433 * that need their own block copy routines into the buffer. There is no
434 * guarantee the buffer is a DMA target!
437 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
439 int space = tty_buffer_request_room(tty, size);
441 struct tty_buffer *tb = tty->buf.tail;
442 *chars = tb->char_buf_ptr + tb->used;
443 *flags = tb->flag_buf_ptr + tb->used;
449 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
454 * This is probably overkill for real world processors but
455 * they are not on hot paths so a little discipline won't do
459 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
461 down(&tty->termios_sem);
462 tty->termios->c_line = num;
463 up(&tty->termios_sem);
467 * This guards the refcounted line discipline lists. The lock
468 * must be taken with irqs off because there are hangup path
469 * callers who will do ldisc lookups and cannot sleep.
472 static DEFINE_SPINLOCK(tty_ldisc_lock);
473 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
474 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
476 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
481 if (disc < N_TTY || disc >= NR_LDISCS)
484 spin_lock_irqsave(&tty_ldisc_lock, flags);
485 tty_ldiscs[disc] = *new_ldisc;
486 tty_ldiscs[disc].num = disc;
487 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
488 tty_ldiscs[disc].refcount = 0;
489 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
493 EXPORT_SYMBOL(tty_register_ldisc);
495 int tty_unregister_ldisc(int disc)
500 if (disc < N_TTY || disc >= NR_LDISCS)
503 spin_lock_irqsave(&tty_ldisc_lock, flags);
504 if (tty_ldiscs[disc].refcount)
507 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
508 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
512 EXPORT_SYMBOL(tty_unregister_ldisc);
514 struct tty_ldisc *tty_ldisc_get(int disc)
517 struct tty_ldisc *ld;
519 if (disc < N_TTY || disc >= NR_LDISCS)
522 spin_lock_irqsave(&tty_ldisc_lock, flags);
524 ld = &tty_ldiscs[disc];
525 /* Check the entry is defined */
526 if(ld->flags & LDISC_FLAG_DEFINED)
528 /* If the module is being unloaded we can't use it */
529 if (!try_module_get(ld->owner))
536 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
540 EXPORT_SYMBOL_GPL(tty_ldisc_get);
542 void tty_ldisc_put(int disc)
544 struct tty_ldisc *ld;
547 if (disc < N_TTY || disc >= NR_LDISCS)
550 spin_lock_irqsave(&tty_ldisc_lock, flags);
551 ld = &tty_ldiscs[disc];
552 if(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)
652 spin_lock_irqsave(&tty_ldisc_lock, flags);
653 if(ld->refcount == 0)
654 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
657 if(ld->refcount == 0)
658 wake_up(&tty_ldisc_wait);
659 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
662 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
665 * tty_ldisc_enable - allow ldisc use
666 * @tty: terminal to activate ldisc on
668 * Set the TTY_LDISC flag when the line discipline can be called
669 * again. Do neccessary wakeups for existing sleepers.
671 * Note: nobody should set this bit except via this function. Clearing
672 * directly is allowed.
675 static void tty_ldisc_enable(struct tty_struct *tty)
677 set_bit(TTY_LDISC, &tty->flags);
678 wake_up(&tty_ldisc_wait);
682 * tty_set_ldisc - set line discipline
683 * @tty: the terminal to set
684 * @ldisc: the line discipline
686 * Set the discipline of a tty line. Must be called from a process
690 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
693 struct tty_ldisc o_ldisc;
697 struct tty_ldisc *ld;
698 struct tty_struct *o_tty;
700 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
705 ld = tty_ldisc_get(ldisc);
706 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
707 /* Cyrus Durgin <cider@speakeasy.org> */
709 request_module("tty-ldisc-%d", ldisc);
710 ld = tty_ldisc_get(ldisc);
716 * No more input please, we are switching. The new ldisc
717 * will update this value in the ldisc open function
720 tty->receive_room = 0;
723 * Problem: What do we do if this blocks ?
726 tty_wait_until_sent(tty, 0);
728 if (tty->ldisc.num == ldisc) {
729 tty_ldisc_put(ldisc);
733 o_ldisc = tty->ldisc;
737 * Make sure we don't change while someone holds a
738 * reference to the line discipline. The TTY_LDISC bit
739 * prevents anyone taking a reference once it is clear.
740 * We need the lock to avoid racing reference takers.
743 spin_lock_irqsave(&tty_ldisc_lock, flags);
744 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
745 if(tty->ldisc.refcount) {
746 /* Free the new ldisc we grabbed. Must drop the lock
748 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
749 tty_ldisc_put(ldisc);
751 * There are several reasons we may be busy, including
752 * random momentary I/O traffic. We must therefore
753 * retry. We could distinguish between blocking ops
754 * and retries if we made tty_ldisc_wait() smarter. That
755 * is up for discussion.
757 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
761 if(o_tty && o_tty->ldisc.refcount) {
762 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
763 tty_ldisc_put(ldisc);
764 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
770 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
772 if (!test_bit(TTY_LDISC, &tty->flags)) {
773 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
774 tty_ldisc_put(ldisc);
775 ld = tty_ldisc_ref_wait(tty);
780 clear_bit(TTY_LDISC, &tty->flags);
781 clear_bit(TTY_DONT_FLIP, &tty->flags);
783 clear_bit(TTY_LDISC, &o_tty->flags);
784 clear_bit(TTY_DONT_FLIP, &o_tty->flags);
786 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
789 * From this point on we know nobody has an ldisc
790 * usage reference, nor can they obtain one until
791 * we say so later on.
794 work = cancel_delayed_work(&tty->buf.work);
796 * Wait for ->hangup_work and ->buf.work handlers to terminate
799 flush_scheduled_work();
800 /* Shutdown the current discipline. */
801 if (tty->ldisc.close)
802 (tty->ldisc.close)(tty);
804 /* Now set up the new line discipline. */
805 tty_ldisc_assign(tty, ld);
806 tty_set_termios_ldisc(tty, ldisc);
808 retval = (tty->ldisc.open)(tty);
810 tty_ldisc_put(ldisc);
811 /* There is an outstanding reference here so this is safe */
812 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
813 tty_set_termios_ldisc(tty, tty->ldisc.num);
814 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
815 tty_ldisc_put(o_ldisc.num);
816 /* This driver is always present */
817 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
818 tty_set_termios_ldisc(tty, N_TTY);
819 if (tty->ldisc.open) {
820 int r = tty->ldisc.open(tty);
823 panic("Couldn't open N_TTY ldisc for "
825 tty_name(tty, buf), r);
829 /* At this point we hold a reference to the new ldisc and a
830 a reference to the old ldisc. If we ended up flipping back
831 to the existing ldisc we have two references to it */
833 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
834 tty->driver->set_ldisc(tty);
836 tty_ldisc_put(o_ldisc.num);
839 * Allow ldisc referencing to occur as soon as the driver
840 * ldisc callback completes.
843 tty_ldisc_enable(tty);
845 tty_ldisc_enable(o_tty);
847 /* Restart it in case no characters kick it off. Safe if
850 schedule_delayed_work(&tty->buf.work, 1);
855 * This routine returns a tty driver structure, given a device number
857 static struct tty_driver *get_tty_driver(dev_t device, int *index)
859 struct tty_driver *p;
861 list_for_each_entry(p, &tty_drivers, tty_drivers) {
862 dev_t base = MKDEV(p->major, p->minor_start);
863 if (device < base || device >= base + p->num)
865 *index = device - base;
872 * If we try to write to, or set the state of, a terminal and we're
873 * not in the foreground, send a SIGTTOU. If the signal is blocked or
874 * ignored, go ahead and perform the operation. (POSIX 7.2)
876 int tty_check_change(struct tty_struct * tty)
878 if (current->signal->tty != tty)
880 if (tty->pgrp <= 0) {
881 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
884 if (process_group(current) == tty->pgrp)
886 if (is_ignored(SIGTTOU))
888 if (is_orphaned_pgrp(process_group(current)))
890 (void) kill_pg(process_group(current), SIGTTOU, 1);
894 EXPORT_SYMBOL(tty_check_change);
896 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
897 size_t count, loff_t *ppos)
902 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
903 size_t count, loff_t *ppos)
908 /* No kernel lock held - none needed ;) */
909 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
911 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
914 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
915 unsigned int cmd, unsigned long arg)
917 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
920 static struct file_operations tty_fops = {
927 .release = tty_release,
928 .fasync = tty_fasync,
931 #ifdef CONFIG_UNIX98_PTYS
932 static struct file_operations ptmx_fops = {
939 .release = tty_release,
940 .fasync = tty_fasync,
944 static struct file_operations console_fops = {
947 .write = redirected_tty_write,
951 .release = tty_release,
952 .fasync = tty_fasync,
955 static struct file_operations hung_up_tty_fops = {
957 .read = hung_up_tty_read,
958 .write = hung_up_tty_write,
959 .poll = hung_up_tty_poll,
960 .ioctl = hung_up_tty_ioctl,
961 .release = tty_release,
964 static DEFINE_SPINLOCK(redirect_lock);
965 static struct file *redirect;
968 * tty_wakeup - request more data
971 * Internal and external helper for wakeups of tty. This function
972 * informs the line discipline if present that the driver is ready
973 * to receive more output data.
976 void tty_wakeup(struct tty_struct *tty)
978 struct tty_ldisc *ld;
980 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
981 ld = tty_ldisc_ref(tty);
984 ld->write_wakeup(tty);
988 wake_up_interruptible(&tty->write_wait);
991 EXPORT_SYMBOL_GPL(tty_wakeup);
994 * tty_ldisc_flush - flush line discipline queue
997 * Flush the line discipline queue (if any) for this tty. If there
998 * is no line discipline active this is a no-op.
1001 void tty_ldisc_flush(struct tty_struct *tty)
1003 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1005 if(ld->flush_buffer)
1006 ld->flush_buffer(tty);
1007 tty_ldisc_deref(ld);
1011 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1014 * This can be called by the "eventd" kernel thread. That is process synchronous,
1015 * but doesn't hold any locks, so we need to make sure we have the appropriate
1016 * locks for what we're doing..
1018 static void do_tty_hangup(void *data)
1020 struct tty_struct *tty = (struct tty_struct *) data;
1021 struct file * cons_filp = NULL;
1022 struct file *filp, *f = NULL;
1023 struct task_struct *p;
1024 struct tty_ldisc *ld;
1025 int closecount = 0, n;
1030 /* inuse_filps is protected by the single kernel lock */
1033 spin_lock(&redirect_lock);
1034 if (redirect && redirect->private_data == tty) {
1038 spin_unlock(&redirect_lock);
1040 check_tty_count(tty, "do_tty_hangup");
1042 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1043 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1044 if (filp->f_op->write == redirected_tty_write)
1046 if (filp->f_op->write != tty_write)
1049 tty_fasync(-1, filp, 0); /* can't block */
1050 filp->f_op = &hung_up_tty_fops;
1054 /* FIXME! What are the locking issues here? This may me overdoing things..
1055 * this question is especially important now that we've removed the irqlock. */
1057 ld = tty_ldisc_ref(tty);
1058 if(ld != NULL) /* We may have no line discipline at this point */
1060 if (ld->flush_buffer)
1061 ld->flush_buffer(tty);
1062 if (tty->driver->flush_buffer)
1063 tty->driver->flush_buffer(tty);
1064 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1066 ld->write_wakeup(tty);
1071 /* FIXME: Once we trust the LDISC code better we can wait here for
1072 ldisc completion and fix the driver call race */
1074 wake_up_interruptible(&tty->write_wait);
1075 wake_up_interruptible(&tty->read_wait);
1078 * Shutdown the current line discipline, and reset it to
1081 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1083 down(&tty->termios_sem);
1084 *tty->termios = tty->driver->init_termios;
1085 up(&tty->termios_sem);
1088 /* Defer ldisc switch */
1089 /* tty_deferred_ldisc_switch(N_TTY);
1091 This should get done automatically when the port closes and
1092 tty_release is called */
1094 read_lock(&tasklist_lock);
1095 if (tty->session > 0) {
1096 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1097 if (p->signal->tty == tty)
1098 p->signal->tty = NULL;
1099 if (!p->signal->leader)
1101 send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1102 send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1104 p->signal->tty_old_pgrp = tty->pgrp;
1105 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1107 read_unlock(&tasklist_lock);
1112 tty->ctrl_status = 0;
1114 * If one of the devices matches a console pointer, we
1115 * cannot just call hangup() because that will cause
1116 * tty->count and state->count to go out of sync.
1117 * So we just call close() the right number of times.
1120 if (tty->driver->close)
1121 for (n = 0; n < closecount; n++)
1122 tty->driver->close(tty, cons_filp);
1123 } else if (tty->driver->hangup)
1124 (tty->driver->hangup)(tty);
1126 /* We don't want to have driver/ldisc interactions beyond
1127 the ones we did here. The driver layer expects no
1128 calls after ->hangup() from the ldisc side. However we
1129 can't yet guarantee all that */
1131 set_bit(TTY_HUPPED, &tty->flags);
1133 tty_ldisc_enable(tty);
1134 tty_ldisc_deref(ld);
1141 void tty_hangup(struct tty_struct * tty)
1143 #ifdef TTY_DEBUG_HANGUP
1146 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1148 schedule_work(&tty->hangup_work);
1151 EXPORT_SYMBOL(tty_hangup);
1153 void tty_vhangup(struct tty_struct * tty)
1155 #ifdef TTY_DEBUG_HANGUP
1158 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1160 do_tty_hangup((void *) tty);
1162 EXPORT_SYMBOL(tty_vhangup);
1164 int tty_hung_up_p(struct file * filp)
1166 return (filp->f_op == &hung_up_tty_fops);
1169 EXPORT_SYMBOL(tty_hung_up_p);
1172 * This function is typically called only by the session leader, when
1173 * it wants to disassociate itself from its controlling tty.
1175 * It performs the following functions:
1176 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1177 * (2) Clears the tty from being controlling the session
1178 * (3) Clears the controlling tty for all processes in the
1181 * The argument on_exit is set to 1 if called when a process is
1182 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1184 void disassociate_ctty(int on_exit)
1186 struct tty_struct *tty;
1187 struct task_struct *p;
1193 tty = current->signal->tty;
1195 tty_pgrp = tty->pgrp;
1197 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1200 if (current->signal->tty_old_pgrp) {
1201 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1202 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1209 kill_pg(tty_pgrp, SIGHUP, on_exit);
1211 kill_pg(tty_pgrp, SIGCONT, on_exit);
1214 /* Must lock changes to tty_old_pgrp */
1216 current->signal->tty_old_pgrp = 0;
1220 /* Now clear signal->tty under the lock */
1221 read_lock(&tasklist_lock);
1222 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1223 p->signal->tty = NULL;
1224 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1225 read_unlock(&tasklist_lock);
1230 void stop_tty(struct tty_struct *tty)
1235 if (tty->link && tty->link->packet) {
1236 tty->ctrl_status &= ~TIOCPKT_START;
1237 tty->ctrl_status |= TIOCPKT_STOP;
1238 wake_up_interruptible(&tty->link->read_wait);
1240 if (tty->driver->stop)
1241 (tty->driver->stop)(tty);
1244 EXPORT_SYMBOL(stop_tty);
1246 void start_tty(struct tty_struct *tty)
1248 if (!tty->stopped || tty->flow_stopped)
1251 if (tty->link && tty->link->packet) {
1252 tty->ctrl_status &= ~TIOCPKT_STOP;
1253 tty->ctrl_status |= TIOCPKT_START;
1254 wake_up_interruptible(&tty->link->read_wait);
1256 if (tty->driver->start)
1257 (tty->driver->start)(tty);
1259 /* If we have a running line discipline it may need kicking */
1261 wake_up_interruptible(&tty->write_wait);
1264 EXPORT_SYMBOL(start_tty);
1266 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1270 struct tty_struct * tty;
1271 struct inode *inode;
1272 struct tty_ldisc *ld;
1274 tty = (struct tty_struct *)file->private_data;
1275 inode = file->f_dentry->d_inode;
1276 if (tty_paranoia_check(tty, inode, "tty_read"))
1278 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1281 /* We want to wait for the line discipline to sort out in this
1283 ld = tty_ldisc_ref_wait(tty);
1286 i = (ld->read)(tty,file,buf,count);
1289 tty_ldisc_deref(ld);
1292 inode->i_atime = current_fs_time(inode->i_sb);
1297 * Split writes up in sane blocksizes to avoid
1298 * denial-of-service type attacks
1300 static inline ssize_t do_tty_write(
1301 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1302 struct tty_struct *tty,
1304 const char __user *buf,
1307 ssize_t ret = 0, written = 0;
1310 if (down_interruptible(&tty->atomic_write)) {
1311 return -ERESTARTSYS;
1315 * We chunk up writes into a temporary buffer. This
1316 * simplifies low-level drivers immensely, since they
1317 * don't have locking issues and user mode accesses.
1319 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1322 * The default chunk-size is 2kB, because the NTTY
1323 * layer has problems with bigger chunks. It will
1324 * claim to be able to handle more characters than
1328 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1333 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1334 if (tty->write_cnt < chunk) {
1340 buf = kmalloc(chunk, GFP_KERNEL);
1342 up(&tty->atomic_write);
1345 kfree(tty->write_buf);
1346 tty->write_cnt = chunk;
1347 tty->write_buf = buf;
1350 /* Do the write .. */
1352 size_t size = count;
1356 if (copy_from_user(tty->write_buf, buf, size))
1359 ret = write(tty, file, tty->write_buf, size);
1369 if (signal_pending(current))
1374 struct inode *inode = file->f_dentry->d_inode;
1375 inode->i_mtime = current_fs_time(inode->i_sb);
1378 up(&tty->atomic_write);
1383 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1386 struct tty_struct * tty;
1387 struct inode *inode = file->f_dentry->d_inode;
1389 struct tty_ldisc *ld;
1391 tty = (struct tty_struct *)file->private_data;
1392 if (tty_paranoia_check(tty, inode, "tty_write"))
1394 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1397 ld = tty_ldisc_ref_wait(tty);
1401 ret = do_tty_write(ld->write, tty, file, buf, count);
1402 tty_ldisc_deref(ld);
1406 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1409 struct file *p = NULL;
1411 spin_lock(&redirect_lock);
1416 spin_unlock(&redirect_lock);
1420 res = vfs_write(p, buf, count, &p->f_pos);
1425 return tty_write(file, buf, count, ppos);
1428 static char ptychar[] = "pqrstuvwxyzabcde";
1430 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1432 int i = index + driver->name_base;
1433 /* ->name is initialized to "ttyp", but "tty" is expected */
1434 sprintf(p, "%s%c%x",
1435 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1436 ptychar[i >> 4 & 0xf], i & 0xf);
1439 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1441 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1445 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1446 * failed open. The new code protects the open with a semaphore, so it's
1447 * really quite straightforward. The semaphore locking can probably be
1448 * relaxed for the (most common) case of reopening a tty.
1450 static int init_dev(struct tty_driver *driver, int idx,
1451 struct tty_struct **ret_tty)
1453 struct tty_struct *tty, *o_tty;
1454 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1455 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1458 /* check whether we're reopening an existing tty */
1459 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1460 tty = devpts_get_tty(idx);
1461 if (tty && driver->subtype == PTY_TYPE_MASTER)
1464 tty = driver->ttys[idx];
1466 if (tty) goto fast_track;
1469 * First time open is complex, especially for PTY devices.
1470 * This code guarantees that either everything succeeds and the
1471 * TTY is ready for operation, or else the table slots are vacated
1472 * and the allocated memory released. (Except that the termios
1473 * and locked termios may be retained.)
1476 if (!try_module_get(driver->owner)) {
1485 tty = alloc_tty_struct();
1488 initialize_tty_struct(tty);
1489 tty->driver = driver;
1491 tty_line_name(driver, idx, tty->name);
1493 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1494 tp_loc = &tty->termios;
1495 ltp_loc = &tty->termios_locked;
1497 tp_loc = &driver->termios[idx];
1498 ltp_loc = &driver->termios_locked[idx];
1502 tp = (struct termios *) kmalloc(sizeof(struct termios),
1506 *tp = driver->init_termios;
1510 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1514 memset(ltp, 0, sizeof(struct termios));
1517 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1518 o_tty = alloc_tty_struct();
1521 initialize_tty_struct(o_tty);
1522 o_tty->driver = driver->other;
1524 tty_line_name(driver->other, idx, o_tty->name);
1526 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1527 o_tp_loc = &o_tty->termios;
1528 o_ltp_loc = &o_tty->termios_locked;
1530 o_tp_loc = &driver->other->termios[idx];
1531 o_ltp_loc = &driver->other->termios_locked[idx];
1535 o_tp = (struct termios *)
1536 kmalloc(sizeof(struct termios), GFP_KERNEL);
1539 *o_tp = driver->other->init_termios;
1543 o_ltp = (struct termios *)
1544 kmalloc(sizeof(struct termios), GFP_KERNEL);
1547 memset(o_ltp, 0, sizeof(struct termios));
1551 * Everything allocated ... set up the o_tty structure.
1553 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1554 driver->other->ttys[idx] = o_tty;
1560 o_tty->termios = *o_tp_loc;
1561 o_tty->termios_locked = *o_ltp_loc;
1562 driver->other->refcount++;
1563 if (driver->subtype == PTY_TYPE_MASTER)
1566 /* Establish the links in both directions */
1572 * All structures have been allocated, so now we install them.
1573 * Failures after this point use release_mem to clean up, so
1574 * there's no need to null out the local pointers.
1576 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1577 driver->ttys[idx] = tty;
1584 tty->termios = *tp_loc;
1585 tty->termios_locked = *ltp_loc;
1590 * Structures all installed ... call the ldisc open routines.
1591 * If we fail here just call release_mem to clean up. No need
1592 * to decrement the use counts, as release_mem doesn't care.
1595 if (tty->ldisc.open) {
1596 retval = (tty->ldisc.open)(tty);
1598 goto release_mem_out;
1600 if (o_tty && o_tty->ldisc.open) {
1601 retval = (o_tty->ldisc.open)(o_tty);
1603 if (tty->ldisc.close)
1604 (tty->ldisc.close)(tty);
1605 goto release_mem_out;
1607 tty_ldisc_enable(o_tty);
1609 tty_ldisc_enable(tty);
1613 * This fast open can be used if the tty is already open.
1614 * No memory is allocated, and the only failures are from
1615 * attempting to open a closing tty or attempting multiple
1616 * opens on a pty master.
1619 if (test_bit(TTY_CLOSING, &tty->flags)) {
1623 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1624 driver->subtype == PTY_TYPE_MASTER) {
1626 * special case for PTY masters: only one open permitted,
1627 * and the slave side open count is incremented as well.
1636 tty->driver = driver; /* N.B. why do this every time?? */
1639 if(!test_bit(TTY_LDISC, &tty->flags))
1640 printk(KERN_ERR "init_dev but no ldisc\n");
1644 /* All paths come through here to release the semaphore */
1648 /* Release locally allocated memory ... nothing placed in slots */
1652 free_tty_struct(o_tty);
1655 free_tty_struct(tty);
1658 module_put(driver->owner);
1662 /* call the tty release_mem routine to clean out this slot */
1664 printk(KERN_INFO "init_dev: ldisc open failed, "
1665 "clearing slot %d\n", idx);
1666 release_mem(tty, idx);
1671 * Releases memory associated with a tty structure, and clears out the
1672 * driver table slots.
1674 static void release_mem(struct tty_struct *tty, int idx)
1676 struct tty_struct *o_tty;
1678 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1680 if ((o_tty = tty->link) != NULL) {
1682 o_tty->driver->ttys[idx] = NULL;
1683 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1684 tp = o_tty->termios;
1686 o_tty->driver->termios[idx] = NULL;
1689 tp = o_tty->termios_locked;
1691 o_tty->driver->termios_locked[idx] = NULL;
1695 o_tty->driver->refcount--;
1697 list_del_init(&o_tty->tty_files);
1699 free_tty_struct(o_tty);
1703 tty->driver->ttys[idx] = NULL;
1704 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1707 tty->driver->termios[idx] = NULL;
1710 tp = tty->termios_locked;
1712 tty->driver->termios_locked[idx] = NULL;
1717 tty->driver->refcount--;
1719 list_del_init(&tty->tty_files);
1721 module_put(tty->driver->owner);
1722 free_tty_struct(tty);
1726 * Even releasing the tty structures is a tricky business.. We have
1727 * to be very careful that the structures are all released at the
1728 * same time, as interrupts might otherwise get the wrong pointers.
1730 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1731 * lead to double frees or releasing memory still in use.
1733 static void release_dev(struct file * filp)
1735 struct tty_struct *tty, *o_tty;
1736 int pty_master, tty_closing, o_tty_closing, do_sleep;
1737 int devpts_master, devpts;
1740 unsigned long flags;
1742 tty = (struct tty_struct *)filp->private_data;
1743 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1746 check_tty_count(tty, "release_dev");
1748 tty_fasync(-1, filp, 0);
1751 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1752 tty->driver->subtype == PTY_TYPE_MASTER);
1753 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1754 devpts_master = pty_master && devpts;
1757 #ifdef TTY_PARANOIA_CHECK
1758 if (idx < 0 || idx >= tty->driver->num) {
1759 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1760 "free (%s)\n", tty->name);
1763 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1764 if (tty != tty->driver->ttys[idx]) {
1765 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1766 "for (%s)\n", idx, tty->name);
1769 if (tty->termios != tty->driver->termios[idx]) {
1770 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1775 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1776 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1777 "termios_locked for (%s)\n",
1784 #ifdef TTY_DEBUG_HANGUP
1785 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1786 tty_name(tty, buf), tty->count);
1789 #ifdef TTY_PARANOIA_CHECK
1790 if (tty->driver->other &&
1791 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1792 if (o_tty != tty->driver->other->ttys[idx]) {
1793 printk(KERN_DEBUG "release_dev: other->table[%d] "
1794 "not o_tty for (%s)\n",
1798 if (o_tty->termios != tty->driver->other->termios[idx]) {
1799 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1800 "not o_termios for (%s)\n",
1804 if (o_tty->termios_locked !=
1805 tty->driver->other->termios_locked[idx]) {
1806 printk(KERN_DEBUG "release_dev: other->termios_locked["
1807 "%d] not o_termios_locked for (%s)\n",
1811 if (o_tty->link != tty) {
1812 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1817 if (tty->driver->close)
1818 tty->driver->close(tty, filp);
1821 * Sanity check: if tty->count is going to zero, there shouldn't be
1822 * any waiters on tty->read_wait or tty->write_wait. We test the
1823 * wait queues and kick everyone out _before_ actually starting to
1824 * close. This ensures that we won't block while releasing the tty
1827 * The test for the o_tty closing is necessary, since the master and
1828 * slave sides may close in any order. If the slave side closes out
1829 * first, its count will be one, since the master side holds an open.
1830 * Thus this test wouldn't be triggered at the time the slave closes,
1833 * Note that it's possible for the tty to be opened again while we're
1834 * flushing out waiters. By recalculating the closing flags before
1835 * each iteration we avoid any problems.
1838 /* Guard against races with tty->count changes elsewhere and
1839 opens on /dev/tty */
1842 tty_closing = tty->count <= 1;
1843 o_tty_closing = o_tty &&
1844 (o_tty->count <= (pty_master ? 1 : 0));
1848 if (waitqueue_active(&tty->read_wait)) {
1849 wake_up(&tty->read_wait);
1852 if (waitqueue_active(&tty->write_wait)) {
1853 wake_up(&tty->write_wait);
1857 if (o_tty_closing) {
1858 if (waitqueue_active(&o_tty->read_wait)) {
1859 wake_up(&o_tty->read_wait);
1862 if (waitqueue_active(&o_tty->write_wait)) {
1863 wake_up(&o_tty->write_wait);
1870 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1871 "active!\n", tty_name(tty, buf));
1877 * The closing flags are now consistent with the open counts on
1878 * both sides, and we've completed the last operation that could
1879 * block, so it's safe to proceed with closing.
1882 if (--o_tty->count < 0) {
1883 printk(KERN_WARNING "release_dev: bad pty slave count "
1885 o_tty->count, tty_name(o_tty, buf));
1889 if (--tty->count < 0) {
1890 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1891 tty->count, tty_name(tty, buf));
1896 * We've decremented tty->count, so we need to remove this file
1897 * descriptor off the tty->tty_files list; this serves two
1899 * - check_tty_count sees the correct number of file descriptors
1900 * associated with this tty.
1901 * - do_tty_hangup no longer sees this file descriptor as
1902 * something that needs to be handled for hangups.
1905 filp->private_data = NULL;
1908 * Perform some housekeeping before deciding whether to return.
1910 * Set the TTY_CLOSING flag if this was the last open. In the
1911 * case of a pty we may have to wait around for the other side
1912 * to close, and TTY_CLOSING makes sure we can't be reopened.
1915 set_bit(TTY_CLOSING, &tty->flags);
1917 set_bit(TTY_CLOSING, &o_tty->flags);
1920 * If _either_ side is closing, make sure there aren't any
1921 * processes that still think tty or o_tty is their controlling
1924 if (tty_closing || o_tty_closing) {
1925 struct task_struct *p;
1927 read_lock(&tasklist_lock);
1928 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1929 p->signal->tty = NULL;
1930 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1932 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1933 p->signal->tty = NULL;
1934 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1935 read_unlock(&tasklist_lock);
1940 /* check whether both sides are closing ... */
1941 if (!tty_closing || (o_tty && !o_tty_closing))
1944 #ifdef TTY_DEBUG_HANGUP
1945 printk(KERN_DEBUG "freeing tty structure...");
1948 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1949 * kill any delayed work. As this is the final close it does not
1950 * race with the set_ldisc code path.
1952 clear_bit(TTY_LDISC, &tty->flags);
1953 clear_bit(TTY_DONT_FLIP, &tty->flags);
1954 cancel_delayed_work(&tty->buf.work);
1957 * Wait for ->hangup_work and ->buf.work handlers to terminate
1960 flush_scheduled_work();
1963 * Wait for any short term users (we know they are just driver
1964 * side waiters as the file is closing so user count on the file
1967 spin_lock_irqsave(&tty_ldisc_lock, flags);
1968 while(tty->ldisc.refcount)
1970 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1971 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1972 spin_lock_irqsave(&tty_ldisc_lock, flags);
1974 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1976 * Shutdown the current line discipline, and reset it to N_TTY.
1977 * N.B. why reset ldisc when we're releasing the memory??
1979 * FIXME: this MUST get fixed for the new reflocking
1981 if (tty->ldisc.close)
1982 (tty->ldisc.close)(tty);
1983 tty_ldisc_put(tty->ldisc.num);
1986 * Switch the line discipline back
1988 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1989 tty_set_termios_ldisc(tty,N_TTY);
1991 /* FIXME: could o_tty be in setldisc here ? */
1992 clear_bit(TTY_LDISC, &o_tty->flags);
1993 if (o_tty->ldisc.close)
1994 (o_tty->ldisc.close)(o_tty);
1995 tty_ldisc_put(o_tty->ldisc.num);
1996 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1997 tty_set_termios_ldisc(o_tty,N_TTY);
2000 * The release_mem function takes care of the details of clearing
2001 * the slots and preserving the termios structure.
2003 release_mem(tty, idx);
2005 #ifdef CONFIG_UNIX98_PTYS
2006 /* Make this pty number available for reallocation */
2008 down(&allocated_ptys_lock);
2009 idr_remove(&allocated_ptys, idx);
2010 up(&allocated_ptys_lock);
2017 * tty_open and tty_release keep up the tty count that contains the
2018 * number of opens done on a tty. We cannot use the inode-count, as
2019 * different inodes might point to the same tty.
2021 * Open-counting is needed for pty masters, as well as for keeping
2022 * track of serial lines: DTR is dropped when the last close happens.
2023 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2025 * The termios state of a pty is reset on first open so that
2026 * settings don't persist across reuse.
2028 static int tty_open(struct inode * inode, struct file * filp)
2030 struct tty_struct *tty;
2032 struct tty_driver *driver;
2034 dev_t device = inode->i_rdev;
2035 unsigned short saved_flags = filp->f_flags;
2037 nonseekable_open(inode, filp);
2040 noctty = filp->f_flags & O_NOCTTY;
2046 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2047 if (!current->signal->tty) {
2051 driver = current->signal->tty->driver;
2052 index = current->signal->tty->index;
2053 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2058 if (device == MKDEV(TTY_MAJOR,0)) {
2059 extern struct tty_driver *console_driver;
2060 driver = console_driver;
2066 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2067 driver = console_device(&index);
2069 /* Don't let /dev/console block */
2070 filp->f_flags |= O_NONBLOCK;
2078 driver = get_tty_driver(device, &index);
2084 retval = init_dev(driver, index, &tty);
2089 filp->private_data = tty;
2090 file_move(filp, &tty->tty_files);
2091 check_tty_count(tty, "tty_open");
2092 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2093 tty->driver->subtype == PTY_TYPE_MASTER)
2095 #ifdef TTY_DEBUG_HANGUP
2096 printk(KERN_DEBUG "opening %s...", tty->name);
2099 if (tty->driver->open)
2100 retval = tty->driver->open(tty, filp);
2104 filp->f_flags = saved_flags;
2106 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2110 #ifdef TTY_DEBUG_HANGUP
2111 printk(KERN_DEBUG "error %d in opening %s...", retval,
2115 if (retval != -ERESTARTSYS)
2117 if (signal_pending(current))
2121 * Need to reset f_op in case a hangup happened.
2123 if (filp->f_op == &hung_up_tty_fops)
2124 filp->f_op = &tty_fops;
2128 current->signal->leader &&
2129 !current->signal->tty &&
2130 tty->session == 0) {
2132 current->signal->tty = tty;
2133 task_unlock(current);
2134 current->signal->tty_old_pgrp = 0;
2135 tty->session = current->signal->session;
2136 tty->pgrp = process_group(current);
2141 #ifdef CONFIG_UNIX98_PTYS
2142 static int ptmx_open(struct inode * inode, struct file * filp)
2144 struct tty_struct *tty;
2149 nonseekable_open(inode, filp);
2151 /* find a device that is not in use. */
2152 down(&allocated_ptys_lock);
2153 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2154 up(&allocated_ptys_lock);
2157 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2159 up(&allocated_ptys_lock);
2160 if (idr_ret == -EAGAIN)
2164 if (index >= pty_limit) {
2165 idr_remove(&allocated_ptys, index);
2166 up(&allocated_ptys_lock);
2169 up(&allocated_ptys_lock);
2172 retval = init_dev(ptm_driver, index, &tty);
2178 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2179 filp->private_data = tty;
2180 file_move(filp, &tty->tty_files);
2183 if (devpts_pty_new(tty->link))
2186 check_tty_count(tty, "tty_open");
2187 retval = ptm_driver->open(tty, filp);
2193 down(&allocated_ptys_lock);
2194 idr_remove(&allocated_ptys, index);
2195 up(&allocated_ptys_lock);
2200 static int tty_release(struct inode * inode, struct file * filp)
2208 /* No kernel lock held - fine */
2209 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2211 struct tty_struct * tty;
2212 struct tty_ldisc *ld;
2215 tty = (struct tty_struct *)filp->private_data;
2216 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2219 ld = tty_ldisc_ref_wait(tty);
2221 ret = (ld->poll)(tty, filp, wait);
2222 tty_ldisc_deref(ld);
2226 static int tty_fasync(int fd, struct file * filp, int on)
2228 struct tty_struct * tty;
2231 tty = (struct tty_struct *)filp->private_data;
2232 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2235 retval = fasync_helper(fd, filp, on, &tty->fasync);
2240 if (!waitqueue_active(&tty->read_wait))
2241 tty->minimum_to_wake = 1;
2242 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2246 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2247 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2252 static int tiocsti(struct tty_struct *tty, char __user *p)
2255 struct tty_ldisc *ld;
2257 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2259 if (get_user(ch, p))
2261 ld = tty_ldisc_ref_wait(tty);
2262 ld->receive_buf(tty, &ch, &mbz, 1);
2263 tty_ldisc_deref(ld);
2267 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2269 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2274 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2275 struct winsize __user * arg)
2277 struct winsize tmp_ws;
2279 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2281 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2284 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2287 acquire_console_sem();
2288 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2289 release_console_sem();
2295 kill_pg(tty->pgrp, SIGWINCH, 1);
2296 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2297 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2298 tty->winsize = tmp_ws;
2299 real_tty->winsize = tmp_ws;
2303 static int tioccons(struct file *file)
2305 if (!capable(CAP_SYS_ADMIN))
2307 if (file->f_op->write == redirected_tty_write) {
2309 spin_lock(&redirect_lock);
2312 spin_unlock(&redirect_lock);
2317 spin_lock(&redirect_lock);
2319 spin_unlock(&redirect_lock);
2324 spin_unlock(&redirect_lock);
2329 static int fionbio(struct file *file, int __user *p)
2333 if (get_user(nonblock, p))
2337 file->f_flags |= O_NONBLOCK;
2339 file->f_flags &= ~O_NONBLOCK;
2343 static int tiocsctty(struct tty_struct *tty, int arg)
2347 if (current->signal->leader &&
2348 (current->signal->session == tty->session))
2351 * The process must be a session leader and
2352 * not have a controlling tty already.
2354 if (!current->signal->leader || current->signal->tty)
2356 if (tty->session > 0) {
2358 * This tty is already the controlling
2359 * tty for another session group!
2361 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2366 read_lock(&tasklist_lock);
2367 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2368 p->signal->tty = NULL;
2369 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2370 read_unlock(&tasklist_lock);
2375 current->signal->tty = tty;
2376 task_unlock(current);
2377 current->signal->tty_old_pgrp = 0;
2378 tty->session = current->signal->session;
2379 tty->pgrp = process_group(current);
2383 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2387 * (tty == real_tty) is a cheap way of
2388 * testing if the tty is NOT a master pty.
2390 if (tty == real_tty && current->signal->tty != real_tty)
2393 pgrp = vx_map_pid(real_tty->pgrp);
2394 return put_user(pgrp, p);
2397 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2400 int retval = tty_check_change(real_tty);
2406 if (!current->signal->tty ||
2407 (current->signal->tty != real_tty) ||
2408 (real_tty->session != current->signal->session))
2410 if (get_user(pgrp, p))
2413 pgrp = vx_rmap_pid(pgrp);
2416 if (session_of_pgrp(pgrp) != current->signal->session)
2418 real_tty->pgrp = pgrp;
2422 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2425 * (tty == real_tty) is a cheap way of
2426 * testing if the tty is NOT a master pty.
2428 if (tty == real_tty && current->signal->tty != real_tty)
2430 if (real_tty->session <= 0)
2432 return put_user(real_tty->session, p);
2435 static int tiocsetd(struct tty_struct *tty, int __user *p)
2439 if (get_user(ldisc, p))
2441 return tty_set_ldisc(tty, ldisc);
2444 static int send_break(struct tty_struct *tty, unsigned int duration)
2446 tty->driver->break_ctl(tty, -1);
2447 if (!signal_pending(current)) {
2448 msleep_interruptible(duration);
2450 tty->driver->break_ctl(tty, 0);
2451 if (signal_pending(current))
2457 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2459 int retval = -EINVAL;
2461 if (tty->driver->tiocmget) {
2462 retval = tty->driver->tiocmget(tty, file);
2465 retval = put_user(retval, p);
2471 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2474 int retval = -EINVAL;
2476 if (tty->driver->tiocmset) {
2477 unsigned int set, clear, val;
2479 retval = get_user(val, p);
2497 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2498 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2500 retval = tty->driver->tiocmset(tty, file, set, clear);
2506 * Split this up, as gcc can choke on it otherwise..
2508 int tty_ioctl(struct inode * inode, struct file * file,
2509 unsigned int cmd, unsigned long arg)
2511 struct tty_struct *tty, *real_tty;
2512 void __user *p = (void __user *)arg;
2514 struct tty_ldisc *ld;
2516 tty = (struct tty_struct *)file->private_data;
2517 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2521 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2522 tty->driver->subtype == PTY_TYPE_MASTER)
2523 real_tty = tty->link;
2526 * Break handling by driver
2528 if (!tty->driver->break_ctl) {
2532 if (tty->driver->ioctl)
2533 return tty->driver->ioctl(tty, file, cmd, arg);
2536 /* These two ioctl's always return success; even if */
2537 /* the driver doesn't support them. */
2540 if (!tty->driver->ioctl)
2542 retval = tty->driver->ioctl(tty, file, cmd, arg);
2543 if (retval == -ENOIOCTLCMD)
2550 * Factor out some common prep work
2558 retval = tty_check_change(tty);
2561 if (cmd != TIOCCBRK) {
2562 tty_wait_until_sent(tty, 0);
2563 if (signal_pending(current))
2571 return tiocsti(tty, p);
2573 return tiocgwinsz(tty, p);
2575 return tiocswinsz(tty, real_tty, p);
2577 return real_tty!=tty ? -EINVAL : tioccons(file);
2579 return fionbio(file, p);
2581 set_bit(TTY_EXCLUSIVE, &tty->flags);
2584 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2587 if (current->signal->tty != tty)
2589 if (current->signal->leader)
2590 disassociate_ctty(0);
2592 current->signal->tty = NULL;
2593 task_unlock(current);
2596 return tiocsctty(tty, arg);
2598 return tiocgpgrp(tty, real_tty, p);
2600 return tiocspgrp(tty, real_tty, p);
2602 return tiocgsid(tty, real_tty, p);
2604 /* FIXME: check this is ok */
2605 return put_user(tty->ldisc.num, (int __user *)p);
2607 return tiocsetd(tty, p);
2610 return tioclinux(tty, arg);
2615 case TIOCSBRK: /* Turn break on, unconditionally */
2616 tty->driver->break_ctl(tty, -1);
2619 case TIOCCBRK: /* Turn break off, unconditionally */
2620 tty->driver->break_ctl(tty, 0);
2622 case TCSBRK: /* SVID version: non-zero arg --> no break */
2624 * XXX is the above comment correct, or the
2625 * code below correct? Is this ioctl used at
2629 return send_break(tty, 250);
2631 case TCSBRKP: /* support for POSIX tcsendbreak() */
2632 return send_break(tty, arg ? arg*100 : 250);
2635 return tty_tiocmget(tty, file, p);
2640 return tty_tiocmset(tty, file, cmd, p);
2642 if (tty->driver->ioctl) {
2643 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2644 if (retval != -ENOIOCTLCMD)
2647 ld = tty_ldisc_ref_wait(tty);
2650 retval = ld->ioctl(tty, file, cmd, arg);
2651 if (retval == -ENOIOCTLCMD)
2654 tty_ldisc_deref(ld);
2660 * This implements the "Secure Attention Key" --- the idea is to
2661 * prevent trojan horses by killing all processes associated with this
2662 * tty when the user hits the "Secure Attention Key". Required for
2663 * super-paranoid applications --- see the Orange Book for more details.
2665 * This code could be nicer; ideally it should send a HUP, wait a few
2666 * seconds, then send a INT, and then a KILL signal. But you then
2667 * have to coordinate with the init process, since all processes associated
2668 * with the current tty must be dead before the new getty is allowed
2671 * Now, if it would be correct ;-/ The current code has a nasty hole -
2672 * it doesn't catch files in flight. We may send the descriptor to ourselves
2673 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2675 * Nasty bug: do_SAK is being called in interrupt context. This can
2676 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2678 static void __do_SAK(void *arg)
2683 struct tty_struct *tty = arg;
2684 struct task_struct *p;
2688 struct tty_ldisc *disc;
2689 struct fdtable *fdt;
2693 session = tty->session;
2695 /* We don't want an ldisc switch during this */
2696 disc = tty_ldisc_ref(tty);
2697 if (disc && disc->flush_buffer)
2698 disc->flush_buffer(tty);
2699 tty_ldisc_deref(disc);
2701 if (tty->driver->flush_buffer)
2702 tty->driver->flush_buffer(tty);
2704 read_lock(&tasklist_lock);
2705 do_each_task_pid(session, PIDTYPE_SID, p) {
2706 if (p->signal->tty == tty || session > 0) {
2707 printk(KERN_NOTICE "SAK: killed process %d"
2708 " (%s): p->signal->session==tty->session\n",
2710 send_sig(SIGKILL, p, 1);
2716 * We don't take a ref to the file, so we must
2717 * hold ->file_lock instead.
2719 spin_lock(&p->files->file_lock);
2720 fdt = files_fdtable(p->files);
2721 for (i=0; i < fdt->max_fds; i++) {
2722 filp = fcheck_files(p->files, i);
2725 if (filp->f_op->read == tty_read &&
2726 filp->private_data == tty) {
2727 printk(KERN_NOTICE "SAK: killed process %d"
2728 " (%s): fd#%d opened to the tty\n",
2729 p->pid, p->comm, i);
2730 send_sig(SIGKILL, p, 1);
2734 spin_unlock(&p->files->file_lock);
2737 } while_each_task_pid(session, PIDTYPE_SID, p);
2738 read_unlock(&tasklist_lock);
2743 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2744 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2745 * the values which we write to it will be identical to the values which it
2746 * already has. --akpm
2748 void do_SAK(struct tty_struct *tty)
2752 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2753 schedule_work(&tty->SAK_work);
2756 EXPORT_SYMBOL(do_SAK);
2759 * This routine is called out of the software interrupt to flush data
2760 * from the buffer chain to the line discipline.
2763 static void flush_to_ldisc(void *private_)
2765 struct tty_struct *tty = (struct tty_struct *) private_;
2766 unsigned long flags;
2767 struct tty_ldisc *disc;
2768 struct tty_buffer *tbuf, *head;
2771 unsigned char *flag_buf;
2773 disc = tty_ldisc_ref(tty);
2774 if (disc == NULL) /* !TTY_LDISC */
2777 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2779 * Do it after the next timer tick:
2781 schedule_delayed_work(&tty->buf.work, 1);
2784 spin_lock_irqsave(&tty->buf.lock, flags);
2785 head = tty->buf.head;
2786 tty->buf.head = NULL;
2787 while((tbuf = head) != NULL) {
2788 while ((count = tbuf->commit - tbuf->read) != 0) {
2789 char_buf = tbuf->char_buf_ptr + tbuf->read;
2790 flag_buf = tbuf->flag_buf_ptr + tbuf->read;
2791 tbuf->read += count;
2792 spin_unlock_irqrestore(&tty->buf.lock, flags);
2793 disc->receive_buf(tty, char_buf, flag_buf, count);
2794 spin_lock_irqsave(&tty->buf.lock, flags);
2797 tty->buf.head = head;
2802 tty->buf.tail = NULL;
2803 tty_buffer_free(tty, tbuf);
2805 spin_unlock_irqrestore(&tty->buf.lock, flags);
2807 tty_ldisc_deref(disc);
2811 * Routine which returns the baud rate of the tty
2813 * Note that the baud_table needs to be kept in sync with the
2814 * include/asm/termbits.h file.
2816 static int baud_table[] = {
2817 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2818 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2820 76800, 153600, 307200, 614400, 921600
2822 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2823 2500000, 3000000, 3500000, 4000000
2827 static int n_baud_table = ARRAY_SIZE(baud_table);
2830 * tty_termios_baud_rate
2831 * @termios: termios structure
2833 * Convert termios baud rate data into a speed. This should be called
2834 * with the termios lock held if this termios is a terminal termios
2835 * structure. May change the termios data.
2838 int tty_termios_baud_rate(struct termios *termios)
2842 cbaud = termios->c_cflag & CBAUD;
2844 if (cbaud & CBAUDEX) {
2847 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2848 termios->c_cflag &= ~CBAUDEX;
2852 return baud_table[cbaud];
2855 EXPORT_SYMBOL(tty_termios_baud_rate);
2858 * tty_get_baud_rate - get tty bit rates
2859 * @tty: tty to query
2861 * Returns the baud rate as an integer for this terminal. The
2862 * termios lock must be held by the caller and the terminal bit
2863 * flags may be updated.
2866 int tty_get_baud_rate(struct tty_struct *tty)
2868 int baud = tty_termios_baud_rate(tty->termios);
2870 if (baud == 38400 && tty->alt_speed) {
2872 printk(KERN_WARNING "Use of setserial/setrocket to "
2873 "set SPD_* flags is deprecated\n");
2876 baud = tty->alt_speed;
2882 EXPORT_SYMBOL(tty_get_baud_rate);
2885 * tty_flip_buffer_push - terminal
2888 * Queue a push of the terminal flip buffers to the line discipline. This
2889 * function must not be called from IRQ context if tty->low_latency is set.
2891 * In the event of the queue being busy for flipping the work will be
2892 * held off and retried later.
2895 void tty_flip_buffer_push(struct tty_struct *tty)
2897 unsigned long flags;
2898 spin_lock_irqsave(&tty->buf.lock, flags);
2899 if (tty->buf.tail != NULL) {
2900 tty->buf.tail->active = 0;
2901 tty->buf.tail->commit = tty->buf.tail->used;
2903 spin_unlock_irqrestore(&tty->buf.lock, flags);
2905 if (tty->low_latency)
2906 flush_to_ldisc((void *) tty);
2908 schedule_delayed_work(&tty->buf.work, 1);
2911 EXPORT_SYMBOL(tty_flip_buffer_push);
2915 * This subroutine initializes a tty structure.
2917 static void initialize_tty_struct(struct tty_struct *tty)
2919 memset(tty, 0, sizeof(struct tty_struct));
2920 tty->magic = TTY_MAGIC;
2921 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2923 tty->overrun_time = jiffies;
2924 tty->buf.head = tty->buf.tail = NULL;
2925 tty_buffer_init(tty);
2926 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
2927 init_MUTEX(&tty->buf.pty_sem);
2928 init_MUTEX(&tty->termios_sem);
2929 init_waitqueue_head(&tty->write_wait);
2930 init_waitqueue_head(&tty->read_wait);
2931 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2932 sema_init(&tty->atomic_read, 1);
2933 sema_init(&tty->atomic_write, 1);
2934 spin_lock_init(&tty->read_lock);
2935 INIT_LIST_HEAD(&tty->tty_files);
2936 INIT_WORK(&tty->SAK_work, NULL, NULL);
2940 * The default put_char routine if the driver did not define one.
2942 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2944 tty->driver->write(tty, &ch, 1);
2947 static struct class *tty_class;
2950 * tty_register_device - register a tty device
2951 * @driver: the tty driver that describes the tty device
2952 * @index: the index in the tty driver for this tty device
2953 * @device: a struct device that is associated with this tty device.
2954 * This field is optional, if there is no known struct device for this
2955 * tty device it can be set to NULL safely.
2957 * This call is required to be made to register an individual tty device if
2958 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2959 * bit is not set, this function should not be called.
2961 void tty_register_device(struct tty_driver *driver, unsigned index,
2962 struct device *device)
2965 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2967 if (index >= driver->num) {
2968 printk(KERN_ERR "Attempt to register invalid tty line number "
2973 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2974 "%s%d", driver->devfs_name, index + driver->name_base);
2976 if (driver->type == TTY_DRIVER_TYPE_PTY)
2977 pty_line_name(driver, index, name);
2979 tty_line_name(driver, index, name);
2980 class_device_create(tty_class, NULL, dev, device, "%s", name);
2984 * tty_unregister_device - unregister a tty device
2985 * @driver: the tty driver that describes the tty device
2986 * @index: the index in the tty driver for this tty device
2988 * If a tty device is registered with a call to tty_register_device() then
2989 * this function must be made when the tty device is gone.
2991 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2993 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2994 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
2997 EXPORT_SYMBOL(tty_register_device);
2998 EXPORT_SYMBOL(tty_unregister_device);
3000 struct tty_driver *alloc_tty_driver(int lines)
3002 struct tty_driver *driver;
3004 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3006 memset(driver, 0, sizeof(struct tty_driver));
3007 driver->magic = TTY_DRIVER_MAGIC;
3008 driver->num = lines;
3009 /* later we'll move allocation of tables here */
3014 void put_tty_driver(struct tty_driver *driver)
3019 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3021 driver->open = op->open;
3022 driver->close = op->close;
3023 driver->write = op->write;
3024 driver->put_char = op->put_char;
3025 driver->flush_chars = op->flush_chars;
3026 driver->write_room = op->write_room;
3027 driver->chars_in_buffer = op->chars_in_buffer;
3028 driver->ioctl = op->ioctl;
3029 driver->set_termios = op->set_termios;
3030 driver->throttle = op->throttle;
3031 driver->unthrottle = op->unthrottle;
3032 driver->stop = op->stop;
3033 driver->start = op->start;
3034 driver->hangup = op->hangup;
3035 driver->break_ctl = op->break_ctl;
3036 driver->flush_buffer = op->flush_buffer;
3037 driver->set_ldisc = op->set_ldisc;
3038 driver->wait_until_sent = op->wait_until_sent;
3039 driver->send_xchar = op->send_xchar;
3040 driver->read_proc = op->read_proc;
3041 driver->write_proc = op->write_proc;
3042 driver->tiocmget = op->tiocmget;
3043 driver->tiocmset = op->tiocmset;
3047 EXPORT_SYMBOL(alloc_tty_driver);
3048 EXPORT_SYMBOL(put_tty_driver);
3049 EXPORT_SYMBOL(tty_set_operations);
3052 * Called by a tty driver to register itself.
3054 int tty_register_driver(struct tty_driver *driver)
3061 if (driver->flags & TTY_DRIVER_INSTALLED)
3064 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3065 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3068 memset(p, 0, driver->num * 3 * sizeof(void *));
3071 if (!driver->major) {
3072 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3073 (char*)driver->name);
3075 driver->major = MAJOR(dev);
3076 driver->minor_start = MINOR(dev);
3079 dev = MKDEV(driver->major, driver->minor_start);
3080 error = register_chrdev_region(dev, driver->num,
3081 (char*)driver->name);
3089 driver->ttys = (struct tty_struct **)p;
3090 driver->termios = (struct termios **)(p + driver->num);
3091 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3093 driver->ttys = NULL;
3094 driver->termios = NULL;
3095 driver->termios_locked = NULL;
3098 cdev_init(&driver->cdev, &tty_fops);
3099 driver->cdev.owner = driver->owner;
3100 error = cdev_add(&driver->cdev, dev, driver->num);
3102 cdev_del(&driver->cdev);
3103 unregister_chrdev_region(dev, driver->num);
3104 driver->ttys = NULL;
3105 driver->termios = driver->termios_locked = NULL;
3110 if (!driver->put_char)
3111 driver->put_char = tty_default_put_char;
3113 list_add(&driver->tty_drivers, &tty_drivers);
3115 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
3116 for(i = 0; i < driver->num; i++)
3117 tty_register_device(driver, i, NULL);
3119 proc_tty_register_driver(driver);
3123 EXPORT_SYMBOL(tty_register_driver);
3126 * Called by a tty driver to unregister itself.
3128 int tty_unregister_driver(struct tty_driver *driver)
3134 if (driver->refcount)
3137 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3140 list_del(&driver->tty_drivers);
3143 * Free the termios and termios_locked structures because
3144 * we don't want to get memory leaks when modular tty
3145 * drivers are removed from the kernel.
3147 for (i = 0; i < driver->num; i++) {
3148 tp = driver->termios[i];
3150 driver->termios[i] = NULL;
3153 tp = driver->termios_locked[i];
3155 driver->termios_locked[i] = NULL;
3158 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
3159 tty_unregister_device(driver, i);
3162 proc_tty_unregister_driver(driver);
3163 driver->ttys = NULL;
3164 driver->termios = driver->termios_locked = NULL;
3166 cdev_del(&driver->cdev);
3170 EXPORT_SYMBOL(tty_unregister_driver);
3174 * Initialize the console device. This is called *early*, so
3175 * we can't necessarily depend on lots of kernel help here.
3176 * Just do some early initializations, and do the complex setup
3179 void __init console_init(void)
3183 /* Setup the default TTY line discipline. */
3184 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3187 * set up the console device so that later boot sequences can
3188 * inform about problems etc..
3190 #ifdef CONFIG_EARLY_PRINTK
3191 disable_early_printk();
3193 call = __con_initcall_start;
3194 while (call < __con_initcall_end) {
3201 extern int vty_init(void);
3204 static int __init tty_class_init(void)
3206 tty_class = class_create(THIS_MODULE, "tty");
3207 if (IS_ERR(tty_class))
3208 return PTR_ERR(tty_class);
3212 postcore_initcall(tty_class_init);
3214 /* 3/2004 jmc: why do these devices exist? */
3216 static struct cdev tty_cdev, console_cdev;
3217 #ifdef CONFIG_UNIX98_PTYS
3218 static struct cdev ptmx_cdev;
3221 static struct cdev vc0_cdev;
3225 * Ok, now we can initialize the rest of the tty devices and can count
3226 * on memory allocations, interrupts etc..
3228 static int __init tty_init(void)
3230 cdev_init(&tty_cdev, &tty_fops);
3231 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3232 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3233 panic("Couldn't register /dev/tty driver\n");
3234 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
3235 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3237 cdev_init(&console_cdev, &console_fops);
3238 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3239 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3240 panic("Couldn't register /dev/console driver\n");
3241 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
3242 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3244 #ifdef CONFIG_UNIX98_PTYS
3245 cdev_init(&ptmx_cdev, &ptmx_fops);
3246 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3247 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3248 panic("Couldn't register /dev/ptmx driver\n");
3249 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
3250 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3254 cdev_init(&vc0_cdev, &console_fops);
3255 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3256 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3257 panic("Couldn't register /dev/tty0 driver\n");
3258 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3259 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3265 module_init(tty_init);