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/types.h>
69 #include <linux/major.h>
70 #include <linux/errno.h>
71 #include <linux/signal.h>
72 #include <linux/fcntl.h>
73 #include <linux/sched.h>
74 #include <linux/interrupt.h>
75 #include <linux/tty.h>
76 #include <linux/tty_driver.h>
77 #include <linux/tty_flip.h>
78 #include <linux/devpts_fs.h>
79 #include <linux/file.h>
80 #include <linux/console.h>
81 #include <linux/timer.h>
82 #include <linux/ctype.h>
85 #include <linux/string.h>
86 #include <linux/slab.h>
87 #include <linux/poll.h>
88 #include <linux/proc_fs.h>
89 #include <linux/init.h>
90 #include <linux/module.h>
91 #include <linux/smp_lock.h>
92 #include <linux/device.h>
93 #include <linux/idr.h>
94 #include <linux/wait.h>
95 #include <linux/bitops.h>
96 #include <linux/delay.h>
98 #include <asm/uaccess.h>
99 #include <asm/system.h>
101 #include <linux/kbd_kern.h>
102 #include <linux/vt_kern.h>
103 #include <linux/selection.h>
105 #include <linux/kmod.h>
107 #undef TTY_DEBUG_HANGUP
109 #define TTY_PARANOIA_CHECK 1
110 #define CHECK_TTY_COUNT 1
112 struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
113 .c_iflag = ICRNL | IXON,
114 .c_oflag = OPOST | ONLCR,
115 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
116 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
117 ECHOCTL | ECHOKE | IEXTEN,
123 EXPORT_SYMBOL(tty_std_termios);
125 /* This list gets poked at by procfs and various bits of boot up code. This
126 could do with some rationalisation such as pulling the tty proc function
129 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131 /* Mutex to protect creating and releasing a tty. This is shared with
132 vt.c for deeply disgusting hack reasons */
133 DEFINE_MUTEX(tty_mutex);
134 EXPORT_SYMBOL(tty_mutex);
136 #ifdef CONFIG_UNIX98_PTYS
137 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
138 extern int pty_limit; /* Config limit on Unix98 ptys */
139 static DEFINE_IDR(allocated_ptys);
140 static DECLARE_MUTEX(allocated_ptys_lock);
141 static int ptmx_open(struct inode *, struct file *);
144 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);
155 static long tty_compat_ioctl(struct file * file, unsigned int cmd,
158 #define tty_compat_ioctl NULL
160 static int tty_fasync(int fd, struct file * filp, int on);
161 static void release_tty(struct tty_struct *tty, int idx);
162 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
163 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
166 * alloc_tty_struct - allocate a tty object
168 * Return a new empty tty structure. The data fields have not
169 * been initialized in any way but has been zeroed
174 static struct tty_struct *alloc_tty_struct(void)
176 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
179 static void tty_buffer_free_all(struct tty_struct *);
182 * free_tty_struct - free a disused tty
183 * @tty: tty struct to free
185 * Free the write buffers, tty queue and tty memory itself.
187 * Locking: none. Must be called after tty is definitely unused
190 static inline void free_tty_struct(struct tty_struct *tty)
192 kfree(tty->write_buf);
193 tty_buffer_free_all(tty);
197 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
200 * tty_name - return tty naming
201 * @tty: tty structure
202 * @buf: buffer for output
204 * Convert a tty structure into a name. The name reflects the kernel
205 * naming policy and if udev is in use may not reflect user space
210 char *tty_name(struct tty_struct *tty, char *buf)
212 if (!tty) /* Hmm. NULL pointer. That's fun. */
213 strcpy(buf, "NULL tty");
215 strcpy(buf, tty->name);
219 EXPORT_SYMBOL(tty_name);
221 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
224 #ifdef TTY_PARANOIA_CHECK
227 "null TTY for (%d:%d) in %s\n",
228 imajor(inode), iminor(inode), routine);
231 if (tty->magic != TTY_MAGIC) {
233 "bad magic number for tty struct (%d:%d) in %s\n",
234 imajor(inode), iminor(inode), routine);
241 static int check_tty_count(struct tty_struct *tty, const char *routine)
243 #ifdef CHECK_TTY_COUNT
248 list_for_each(p, &tty->tty_files) {
252 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
253 tty->driver->subtype == PTY_TYPE_SLAVE &&
254 tty->link && tty->link->count)
256 if (tty->count != count) {
257 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
258 "!= #fd's(%d) in %s\n",
259 tty->name, tty->count, count, routine);
267 * Tty buffer allocation management
271 * tty_buffer_free_all - free buffers used by a tty
272 * @tty: tty to free from
274 * Remove all the buffers pending on a tty whether queued with data
275 * or in the free ring. Must be called when the tty is no longer in use
280 static void tty_buffer_free_all(struct tty_struct *tty)
282 struct tty_buffer *thead;
283 while((thead = tty->buf.head) != NULL) {
284 tty->buf.head = thead->next;
287 while((thead = tty->buf.free) != NULL) {
288 tty->buf.free = thead->next;
291 tty->buf.tail = NULL;
292 tty->buf.memory_used = 0;
296 * tty_buffer_init - prepare a tty buffer structure
297 * @tty: tty to initialise
299 * Set up the initial state of the buffer management for a tty device.
300 * Must be called before the other tty buffer functions are used.
305 static void tty_buffer_init(struct tty_struct *tty)
307 spin_lock_init(&tty->buf.lock);
308 tty->buf.head = NULL;
309 tty->buf.tail = NULL;
310 tty->buf.free = NULL;
311 tty->buf.memory_used = 0;
315 * tty_buffer_alloc - allocate a tty buffer
317 * @size: desired size (characters)
319 * Allocate a new tty buffer to hold the desired number of characters.
320 * Return NULL if out of memory or the allocation would exceed the
323 * Locking: Caller must hold tty->buf.lock
326 static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
328 struct tty_buffer *p;
330 if (tty->buf.memory_used + size > 65536)
332 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
340 p->char_buf_ptr = (char *)(p->data);
341 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
342 tty->buf.memory_used += size;
347 * tty_buffer_free - free a tty buffer
348 * @tty: tty owning the buffer
349 * @b: the buffer to free
351 * Free a tty buffer, or add it to the free list according to our
354 * Locking: Caller must hold tty->buf.lock
357 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
359 /* Dumb strategy for now - should keep some stats */
360 tty->buf.memory_used -= b->size;
361 WARN_ON(tty->buf.memory_used < 0);
366 b->next = tty->buf.free;
372 * tty_buffer_find - find a free tty buffer
373 * @tty: tty owning the buffer
374 * @size: characters wanted
376 * Locate an existing suitable tty buffer or if we are lacking one then
377 * allocate a new one. We round our buffers off in 256 character chunks
378 * to get better allocation behaviour.
380 * Locking: Caller must hold tty->buf.lock
383 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
385 struct tty_buffer **tbh = &tty->buf.free;
386 while((*tbh) != NULL) {
387 struct tty_buffer *t = *tbh;
388 if(t->size >= size) {
394 tty->buf.memory_used += t->size;
397 tbh = &((*tbh)->next);
399 /* Round the buffer size out */
400 size = (size + 0xFF) & ~ 0xFF;
401 return tty_buffer_alloc(tty, size);
402 /* Should possibly check if this fails for the largest buffer we
403 have queued and recycle that ? */
407 * tty_buffer_request_room - grow tty buffer if needed
408 * @tty: tty structure
409 * @size: size desired
411 * Make at least size bytes of linear space available for the tty
412 * buffer. If we fail return the size we managed to find.
414 * Locking: Takes tty->buf.lock
416 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
418 struct tty_buffer *b, *n;
422 spin_lock_irqsave(&tty->buf.lock, flags);
424 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
425 remove this conditional if its worth it. This would be invisible
427 if ((b = tty->buf.tail) != NULL)
428 left = b->size - b->used;
433 /* This is the slow path - looking for new buffers to use */
434 if ((n = tty_buffer_find(tty, size)) != NULL) {
445 spin_unlock_irqrestore(&tty->buf.lock, flags);
448 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
451 * tty_insert_flip_string - Add characters to the tty buffer
452 * @tty: tty structure
456 * Queue a series of bytes to the tty buffering. All the characters
457 * passed are marked as without error. Returns the number added.
459 * Locking: Called functions may take tty->buf.lock
462 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
467 int space = tty_buffer_request_room(tty, size - copied);
468 struct tty_buffer *tb = tty->buf.tail;
469 /* If there is no space then tb may be NULL */
470 if(unlikely(space == 0))
472 memcpy(tb->char_buf_ptr + tb->used, chars, space);
473 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
477 /* There is a small chance that we need to split the data over
478 several buffers. If this is the case we must loop */
479 } while (unlikely(size > copied));
482 EXPORT_SYMBOL(tty_insert_flip_string);
485 * tty_insert_flip_string_flags - Add characters to the tty buffer
486 * @tty: tty structure
491 * Queue a series of bytes to the tty buffering. For each character
492 * the flags array indicates the status of the character. Returns the
495 * Locking: Called functions may take tty->buf.lock
498 int tty_insert_flip_string_flags(struct tty_struct *tty,
499 const unsigned char *chars, const char *flags, size_t size)
503 int space = tty_buffer_request_room(tty, size - copied);
504 struct tty_buffer *tb = tty->buf.tail;
505 /* If there is no space then tb may be NULL */
506 if(unlikely(space == 0))
508 memcpy(tb->char_buf_ptr + tb->used, chars, space);
509 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
514 /* There is a small chance that we need to split the data over
515 several buffers. If this is the case we must loop */
516 } while (unlikely(size > copied));
519 EXPORT_SYMBOL(tty_insert_flip_string_flags);
522 * tty_schedule_flip - push characters to ldisc
523 * @tty: tty to push from
525 * Takes any pending buffers and transfers their ownership to the
526 * ldisc side of the queue. It then schedules those characters for
527 * processing by the line discipline.
529 * Locking: Takes tty->buf.lock
532 void tty_schedule_flip(struct tty_struct *tty)
535 spin_lock_irqsave(&tty->buf.lock, flags);
536 if (tty->buf.tail != NULL)
537 tty->buf.tail->commit = tty->buf.tail->used;
538 spin_unlock_irqrestore(&tty->buf.lock, flags);
539 schedule_delayed_work(&tty->buf.work, 1);
541 EXPORT_SYMBOL(tty_schedule_flip);
544 * tty_prepare_flip_string - make room for characters
546 * @chars: return pointer for character write area
547 * @size: desired size
549 * Prepare a block of space in the buffer for data. Returns the length
550 * available and buffer pointer to the space which is now allocated and
551 * accounted for as ready for normal characters. This is used for drivers
552 * that need their own block copy routines into the buffer. There is no
553 * guarantee the buffer is a DMA target!
555 * Locking: May call functions taking tty->buf.lock
558 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
560 int space = tty_buffer_request_room(tty, size);
562 struct tty_buffer *tb = tty->buf.tail;
563 *chars = tb->char_buf_ptr + tb->used;
564 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
570 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
573 * tty_prepare_flip_string_flags - make room for characters
575 * @chars: return pointer for character write area
576 * @flags: return pointer for status flag write area
577 * @size: desired size
579 * Prepare a block of space in the buffer for data. Returns the length
580 * available and buffer pointer to the space which is now allocated and
581 * accounted for as ready for characters. This is used for drivers
582 * that need their own block copy routines into the buffer. There is no
583 * guarantee the buffer is a DMA target!
585 * Locking: May call functions taking tty->buf.lock
588 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
590 int space = tty_buffer_request_room(tty, size);
592 struct tty_buffer *tb = tty->buf.tail;
593 *chars = tb->char_buf_ptr + tb->used;
594 *flags = tb->flag_buf_ptr + tb->used;
600 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
605 * tty_set_termios_ldisc - set ldisc field
606 * @tty: tty structure
607 * @num: line discipline number
609 * This is probably overkill for real world processors but
610 * they are not on hot paths so a little discipline won't do
613 * Locking: takes termios_mutex
616 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
618 mutex_lock(&tty->termios_mutex);
619 tty->termios->c_line = num;
620 mutex_unlock(&tty->termios_mutex);
624 * This guards the refcounted line discipline lists. The lock
625 * must be taken with irqs off because there are hangup path
626 * callers who will do ldisc lookups and cannot sleep.
629 static DEFINE_SPINLOCK(tty_ldisc_lock);
630 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
631 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
634 * tty_register_ldisc - install a line discipline
635 * @disc: ldisc number
636 * @new_ldisc: pointer to the ldisc object
638 * Installs a new line discipline into the kernel. The discipline
639 * is set up as unreferenced and then made available to the kernel
640 * from this point onwards.
643 * takes tty_ldisc_lock to guard against ldisc races
646 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
651 if (disc < N_TTY || disc >= NR_LDISCS)
654 spin_lock_irqsave(&tty_ldisc_lock, flags);
655 tty_ldiscs[disc] = *new_ldisc;
656 tty_ldiscs[disc].num = disc;
657 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
658 tty_ldiscs[disc].refcount = 0;
659 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
663 EXPORT_SYMBOL(tty_register_ldisc);
666 * tty_unregister_ldisc - unload a line discipline
667 * @disc: ldisc number
668 * @new_ldisc: pointer to the ldisc object
670 * Remove a line discipline from the kernel providing it is not
674 * takes tty_ldisc_lock to guard against ldisc races
677 int tty_unregister_ldisc(int disc)
682 if (disc < N_TTY || disc >= NR_LDISCS)
685 spin_lock_irqsave(&tty_ldisc_lock, flags);
686 if (tty_ldiscs[disc].refcount)
689 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
690 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
694 EXPORT_SYMBOL(tty_unregister_ldisc);
697 * tty_ldisc_get - take a reference to an ldisc
698 * @disc: ldisc number
700 * Takes a reference to a line discipline. Deals with refcounts and
701 * module locking counts. Returns NULL if the discipline is not available.
702 * Returns a pointer to the discipline and bumps the ref count if it is
706 * takes tty_ldisc_lock to guard against ldisc races
709 struct tty_ldisc *tty_ldisc_get(int disc)
712 struct tty_ldisc *ld;
714 if (disc < N_TTY || disc >= NR_LDISCS)
717 spin_lock_irqsave(&tty_ldisc_lock, flags);
719 ld = &tty_ldiscs[disc];
720 /* Check the entry is defined */
721 if(ld->flags & LDISC_FLAG_DEFINED)
723 /* If the module is being unloaded we can't use it */
724 if (!try_module_get(ld->owner))
731 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
735 EXPORT_SYMBOL_GPL(tty_ldisc_get);
738 * tty_ldisc_put - drop ldisc reference
739 * @disc: ldisc number
741 * Drop a reference to a line discipline. Manage refcounts and
742 * module usage counts
745 * takes tty_ldisc_lock to guard against ldisc races
748 void tty_ldisc_put(int disc)
750 struct tty_ldisc *ld;
753 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
755 spin_lock_irqsave(&tty_ldisc_lock, flags);
756 ld = &tty_ldiscs[disc];
757 BUG_ON(ld->refcount == 0);
759 module_put(ld->owner);
760 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
763 EXPORT_SYMBOL_GPL(tty_ldisc_put);
766 * tty_ldisc_assign - set ldisc on a tty
767 * @tty: tty to assign
768 * @ld: line discipline
770 * Install an instance of a line discipline into a tty structure. The
771 * ldisc must have a reference count above zero to ensure it remains/
772 * The tty instance refcount starts at zero.
775 * Caller must hold references
778 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
781 tty->ldisc.refcount = 0;
785 * tty_ldisc_try - internal helper
788 * Make a single attempt to grab and bump the refcount on
789 * the tty ldisc. Return 0 on failure or 1 on success. This is
790 * used to implement both the waiting and non waiting versions
793 * Locking: takes tty_ldisc_lock
796 static int tty_ldisc_try(struct tty_struct *tty)
799 struct tty_ldisc *ld;
802 spin_lock_irqsave(&tty_ldisc_lock, flags);
804 if(test_bit(TTY_LDISC, &tty->flags))
809 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
814 * tty_ldisc_ref_wait - wait for the tty ldisc
817 * Dereference the line discipline for the terminal and take a
818 * reference to it. If the line discipline is in flux then
819 * wait patiently until it changes.
821 * Note: Must not be called from an IRQ/timer context. The caller
822 * must also be careful not to hold other locks that will deadlock
823 * against a discipline change, such as an existing ldisc reference
824 * (which we check for)
826 * Locking: call functions take tty_ldisc_lock
829 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
831 /* wait_event is a macro */
832 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
833 if(tty->ldisc.refcount == 0)
834 printk(KERN_ERR "tty_ldisc_ref_wait\n");
838 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
841 * tty_ldisc_ref - get the tty ldisc
844 * Dereference the line discipline for the terminal and take a
845 * reference to it. If the line discipline is in flux then
846 * return NULL. Can be called from IRQ and timer functions.
848 * Locking: called functions take tty_ldisc_lock
851 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
853 if(tty_ldisc_try(tty))
858 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
861 * tty_ldisc_deref - free a tty ldisc reference
862 * @ld: reference to free up
864 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
865 * be called in IRQ context.
867 * Locking: takes tty_ldisc_lock
870 void tty_ldisc_deref(struct tty_ldisc *ld)
876 spin_lock_irqsave(&tty_ldisc_lock, flags);
877 if(ld->refcount == 0)
878 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
881 if(ld->refcount == 0)
882 wake_up(&tty_ldisc_wait);
883 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
886 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
889 * tty_ldisc_enable - allow ldisc use
890 * @tty: terminal to activate ldisc on
892 * Set the TTY_LDISC flag when the line discipline can be called
893 * again. Do neccessary wakeups for existing sleepers.
895 * Note: nobody should set this bit except via this function. Clearing
896 * directly is allowed.
899 static void tty_ldisc_enable(struct tty_struct *tty)
901 set_bit(TTY_LDISC, &tty->flags);
902 wake_up(&tty_ldisc_wait);
906 * tty_set_ldisc - set line discipline
907 * @tty: the terminal to set
908 * @ldisc: the line discipline
910 * Set the discipline of a tty line. Must be called from a process
913 * Locking: takes tty_ldisc_lock.
914 * called functions take termios_mutex
917 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
920 struct tty_ldisc o_ldisc;
924 struct tty_ldisc *ld;
925 struct tty_struct *o_tty;
927 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
932 ld = tty_ldisc_get(ldisc);
933 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
934 /* Cyrus Durgin <cider@speakeasy.org> */
936 request_module("tty-ldisc-%d", ldisc);
937 ld = tty_ldisc_get(ldisc);
943 * Problem: What do we do if this blocks ?
946 tty_wait_until_sent(tty, 0);
948 if (tty->ldisc.num == ldisc) {
949 tty_ldisc_put(ldisc);
954 * No more input please, we are switching. The new ldisc
955 * will update this value in the ldisc open function
958 tty->receive_room = 0;
960 o_ldisc = tty->ldisc;
964 * Make sure we don't change while someone holds a
965 * reference to the line discipline. The TTY_LDISC bit
966 * prevents anyone taking a reference once it is clear.
967 * We need the lock to avoid racing reference takers.
970 spin_lock_irqsave(&tty_ldisc_lock, flags);
971 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
972 if(tty->ldisc.refcount) {
973 /* Free the new ldisc we grabbed. Must drop the lock
975 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
976 tty_ldisc_put(ldisc);
978 * There are several reasons we may be busy, including
979 * random momentary I/O traffic. We must therefore
980 * retry. We could distinguish between blocking ops
981 * and retries if we made tty_ldisc_wait() smarter. That
982 * is up for discussion.
984 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
988 if(o_tty && o_tty->ldisc.refcount) {
989 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
990 tty_ldisc_put(ldisc);
991 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
997 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
999 if (!test_bit(TTY_LDISC, &tty->flags)) {
1000 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1001 tty_ldisc_put(ldisc);
1002 ld = tty_ldisc_ref_wait(tty);
1003 tty_ldisc_deref(ld);
1007 clear_bit(TTY_LDISC, &tty->flags);
1009 clear_bit(TTY_LDISC, &o_tty->flags);
1010 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1013 * From this point on we know nobody has an ldisc
1014 * usage reference, nor can they obtain one until
1015 * we say so later on.
1018 work = cancel_delayed_work(&tty->buf.work);
1020 * Wait for ->hangup_work and ->buf.work handlers to terminate
1023 flush_scheduled_work();
1024 /* Shutdown the current discipline. */
1025 if (tty->ldisc.close)
1026 (tty->ldisc.close)(tty);
1028 /* Now set up the new line discipline. */
1029 tty_ldisc_assign(tty, ld);
1030 tty_set_termios_ldisc(tty, ldisc);
1031 if (tty->ldisc.open)
1032 retval = (tty->ldisc.open)(tty);
1034 tty_ldisc_put(ldisc);
1035 /* There is an outstanding reference here so this is safe */
1036 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1037 tty_set_termios_ldisc(tty, tty->ldisc.num);
1038 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1039 tty_ldisc_put(o_ldisc.num);
1040 /* This driver is always present */
1041 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1042 tty_set_termios_ldisc(tty, N_TTY);
1043 if (tty->ldisc.open) {
1044 int r = tty->ldisc.open(tty);
1047 panic("Couldn't open N_TTY ldisc for "
1049 tty_name(tty, buf), r);
1053 /* At this point we hold a reference to the new ldisc and a
1054 a reference to the old ldisc. If we ended up flipping back
1055 to the existing ldisc we have two references to it */
1057 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1058 tty->driver->set_ldisc(tty);
1060 tty_ldisc_put(o_ldisc.num);
1063 * Allow ldisc referencing to occur as soon as the driver
1064 * ldisc callback completes.
1067 tty_ldisc_enable(tty);
1069 tty_ldisc_enable(o_tty);
1071 /* Restart it in case no characters kick it off. Safe if
1074 schedule_delayed_work(&tty->buf.work, 1);
1079 * get_tty_driver - find device of a tty
1080 * @dev_t: device identifier
1081 * @index: returns the index of the tty
1083 * This routine returns a tty driver structure, given a device number
1084 * and also passes back the index number.
1086 * Locking: caller must hold tty_mutex
1089 static struct tty_driver *get_tty_driver(dev_t device, int *index)
1091 struct tty_driver *p;
1093 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1094 dev_t base = MKDEV(p->major, p->minor_start);
1095 if (device < base || device >= base + p->num)
1097 *index = device - base;
1104 * tty_check_change - check for POSIX terminal changes
1105 * @tty: tty to check
1107 * If we try to write to, or set the state of, a terminal and we're
1108 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1109 * ignored, go ahead and perform the operation. (POSIX 7.2)
1114 int tty_check_change(struct tty_struct * tty)
1116 if (current->signal->tty != tty)
1119 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
1122 if (task_pgrp(current) == tty->pgrp)
1124 if (is_ignored(SIGTTOU))
1126 if (is_current_pgrp_orphaned())
1128 (void) kill_pgrp(task_pgrp(current), SIGTTOU, 1);
1129 return -ERESTARTSYS;
1132 EXPORT_SYMBOL(tty_check_change);
1134 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1135 size_t count, loff_t *ppos)
1140 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1141 size_t count, loff_t *ppos)
1146 /* No kernel lock held - none needed ;) */
1147 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1149 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1152 static long hung_up_tty_ioctl(struct file * file,
1153 unsigned int cmd, unsigned long arg)
1155 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1158 static const struct file_operations tty_fops = {
1159 .llseek = no_llseek,
1164 .compat_ioctl = tty_compat_ioctl,
1166 .release = tty_release,
1167 .fasync = tty_fasync,
1170 #ifdef CONFIG_UNIX98_PTYS
1171 static const struct file_operations ptmx_fops = {
1172 .llseek = no_llseek,
1177 .compat_ioctl = tty_compat_ioctl,
1179 .release = tty_release,
1180 .fasync = tty_fasync,
1184 static const struct file_operations console_fops = {
1185 .llseek = no_llseek,
1187 .write = redirected_tty_write,
1190 .compat_ioctl = tty_compat_ioctl,
1192 .release = tty_release,
1193 .fasync = tty_fasync,
1196 static const struct file_operations hung_up_tty_fops = {
1197 .llseek = no_llseek,
1198 .read = hung_up_tty_read,
1199 .write = hung_up_tty_write,
1200 .poll = hung_up_tty_poll,
1201 .unlocked_ioctl = hung_up_tty_ioctl,
1202 .compat_ioctl = hung_up_tty_ioctl,
1203 .release = tty_release,
1206 static DEFINE_SPINLOCK(redirect_lock);
1207 static struct file *redirect;
1210 * tty_wakeup - request more data
1213 * Internal and external helper for wakeups of tty. This function
1214 * informs the line discipline if present that the driver is ready
1215 * to receive more output data.
1218 void tty_wakeup(struct tty_struct *tty)
1220 struct tty_ldisc *ld;
1222 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1223 ld = tty_ldisc_ref(tty);
1225 if(ld->write_wakeup)
1226 ld->write_wakeup(tty);
1227 tty_ldisc_deref(ld);
1230 wake_up_interruptible(&tty->write_wait);
1233 EXPORT_SYMBOL_GPL(tty_wakeup);
1236 * tty_ldisc_flush - flush line discipline queue
1239 * Flush the line discipline queue (if any) for this tty. If there
1240 * is no line discipline active this is a no-op.
1243 void tty_ldisc_flush(struct tty_struct *tty)
1245 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1247 if(ld->flush_buffer)
1248 ld->flush_buffer(tty);
1249 tty_ldisc_deref(ld);
1253 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1256 * tty_reset_termios - reset terminal state
1257 * @tty: tty to reset
1259 * Restore a terminal to the driver default state
1262 static void tty_reset_termios(struct tty_struct *tty)
1264 mutex_lock(&tty->termios_mutex);
1265 *tty->termios = tty->driver->init_termios;
1266 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1267 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1268 mutex_unlock(&tty->termios_mutex);
1272 * do_tty_hangup - actual handler for hangup events
1275 * This can be called by the "eventd" kernel thread. That is process
1276 * synchronous but doesn't hold any locks, so we need to make sure we
1277 * have the appropriate locks for what we're doing.
1279 * The hangup event clears any pending redirections onto the hung up
1280 * device. It ensures future writes will error and it does the needed
1281 * line discipline hangup and signal delivery. The tty object itself
1286 * redirect lock for undoing redirection
1287 * file list lock for manipulating list of ttys
1288 * tty_ldisc_lock from called functions
1289 * termios_mutex resetting termios data
1290 * tasklist_lock to walk task list for hangup event
1291 * ->siglock to protect ->signal/->sighand
1293 static void do_tty_hangup(struct work_struct *work)
1295 struct tty_struct *tty =
1296 container_of(work, struct tty_struct, hangup_work);
1297 struct file * cons_filp = NULL;
1298 struct file *filp, *f = NULL;
1299 struct task_struct *p;
1300 struct tty_ldisc *ld;
1301 int closecount = 0, n;
1306 /* inuse_filps is protected by the single kernel lock */
1309 spin_lock(&redirect_lock);
1310 if (redirect && redirect->private_data == tty) {
1314 spin_unlock(&redirect_lock);
1316 check_tty_count(tty, "do_tty_hangup");
1318 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1319 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1320 if (filp->f_op->write == redirected_tty_write)
1322 if (filp->f_op->write != tty_write)
1325 tty_fasync(-1, filp, 0); /* can't block */
1326 filp->f_op = &hung_up_tty_fops;
1330 /* FIXME! What are the locking issues here? This may me overdoing things..
1331 * this question is especially important now that we've removed the irqlock. */
1333 ld = tty_ldisc_ref(tty);
1334 if(ld != NULL) /* We may have no line discipline at this point */
1336 if (ld->flush_buffer)
1337 ld->flush_buffer(tty);
1338 if (tty->driver->flush_buffer)
1339 tty->driver->flush_buffer(tty);
1340 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1342 ld->write_wakeup(tty);
1347 /* FIXME: Once we trust the LDISC code better we can wait here for
1348 ldisc completion and fix the driver call race */
1350 wake_up_interruptible(&tty->write_wait);
1351 wake_up_interruptible(&tty->read_wait);
1354 * Shutdown the current line discipline, and reset it to
1357 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1358 tty_reset_termios(tty);
1360 /* Defer ldisc switch */
1361 /* tty_deferred_ldisc_switch(N_TTY);
1363 This should get done automatically when the port closes and
1364 tty_release is called */
1366 read_lock(&tasklist_lock);
1368 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
1369 spin_lock_irq(&p->sighand->siglock);
1370 if (p->signal->tty == tty)
1371 p->signal->tty = NULL;
1372 if (!p->signal->leader) {
1373 spin_unlock_irq(&p->sighand->siglock);
1376 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1377 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1378 put_pid(p->signal->tty_old_pgrp); /* A noop */
1380 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
1381 spin_unlock_irq(&p->sighand->siglock);
1382 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
1384 read_unlock(&tasklist_lock);
1387 put_pid(tty->session);
1389 tty->session = NULL;
1391 tty->ctrl_status = 0;
1393 * If one of the devices matches a console pointer, we
1394 * cannot just call hangup() because that will cause
1395 * tty->count and state->count to go out of sync.
1396 * So we just call close() the right number of times.
1399 if (tty->driver->close)
1400 for (n = 0; n < closecount; n++)
1401 tty->driver->close(tty, cons_filp);
1402 } else if (tty->driver->hangup)
1403 (tty->driver->hangup)(tty);
1405 /* We don't want to have driver/ldisc interactions beyond
1406 the ones we did here. The driver layer expects no
1407 calls after ->hangup() from the ldisc side. However we
1408 can't yet guarantee all that */
1410 set_bit(TTY_HUPPED, &tty->flags);
1412 tty_ldisc_enable(tty);
1413 tty_ldisc_deref(ld);
1421 * tty_hangup - trigger a hangup event
1422 * @tty: tty to hangup
1424 * A carrier loss (virtual or otherwise) has occurred on this like
1425 * schedule a hangup sequence to run after this event.
1428 void tty_hangup(struct tty_struct * tty)
1430 #ifdef TTY_DEBUG_HANGUP
1433 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1435 schedule_work(&tty->hangup_work);
1438 EXPORT_SYMBOL(tty_hangup);
1441 * tty_vhangup - process vhangup
1442 * @tty: tty to hangup
1444 * The user has asked via system call for the terminal to be hung up.
1445 * We do this synchronously so that when the syscall returns the process
1446 * is complete. That guarantee is neccessary for security reasons.
1449 void tty_vhangup(struct tty_struct * tty)
1451 #ifdef TTY_DEBUG_HANGUP
1454 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1456 do_tty_hangup(&tty->hangup_work);
1458 EXPORT_SYMBOL(tty_vhangup);
1461 * tty_hung_up_p - was tty hung up
1462 * @filp: file pointer of tty
1464 * Return true if the tty has been subject to a vhangup or a carrier
1468 int tty_hung_up_p(struct file * filp)
1470 return (filp->f_op == &hung_up_tty_fops);
1473 EXPORT_SYMBOL(tty_hung_up_p);
1475 static void session_clear_tty(struct pid *session)
1477 struct task_struct *p;
1478 do_each_pid_task(session, PIDTYPE_SID, p) {
1480 } while_each_pid_task(session, PIDTYPE_SID, p);
1484 * disassociate_ctty - disconnect controlling tty
1485 * @on_exit: true if exiting so need to "hang up" the session
1487 * This function is typically called only by the session leader, when
1488 * it wants to disassociate itself from its controlling tty.
1490 * It performs the following functions:
1491 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1492 * (2) Clears the tty from being controlling the session
1493 * (3) Clears the controlling tty for all processes in the
1496 * The argument on_exit is set to 1 if called when a process is
1497 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1500 * BKL is taken for hysterical raisins
1501 * tty_mutex is taken to protect tty
1502 * ->siglock is taken to protect ->signal/->sighand
1503 * tasklist_lock is taken to walk process list for sessions
1504 * ->siglock is taken to protect ->signal/->sighand
1507 void disassociate_ctty(int on_exit)
1509 struct tty_struct *tty;
1510 struct pid *tty_pgrp = NULL;
1514 mutex_lock(&tty_mutex);
1515 tty = get_current_tty();
1517 tty_pgrp = get_pid(tty->pgrp);
1518 mutex_unlock(&tty_mutex);
1519 /* XXX: here we race, there is nothing protecting tty */
1520 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1522 } else if (on_exit) {
1523 struct pid *old_pgrp;
1524 spin_lock_irq(¤t->sighand->siglock);
1525 old_pgrp = current->signal->tty_old_pgrp;
1526 current->signal->tty_old_pgrp = NULL;
1527 spin_unlock_irq(¤t->sighand->siglock);
1529 kill_pgrp(old_pgrp, SIGHUP, on_exit);
1530 kill_pgrp(old_pgrp, SIGCONT, on_exit);
1533 mutex_unlock(&tty_mutex);
1538 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
1540 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
1544 spin_lock_irq(¤t->sighand->siglock);
1545 put_pid(current->signal->tty_old_pgrp);
1546 current->signal->tty_old_pgrp = NULL;
1547 spin_unlock_irq(¤t->sighand->siglock);
1549 mutex_lock(&tty_mutex);
1550 /* It is possible that do_tty_hangup has free'd this tty */
1551 tty = get_current_tty();
1553 put_pid(tty->session);
1555 tty->session = NULL;
1558 #ifdef TTY_DEBUG_HANGUP
1559 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
1563 mutex_unlock(&tty_mutex);
1565 /* Now clear signal->tty under the lock */
1566 read_lock(&tasklist_lock);
1567 session_clear_tty(task_session(current));
1568 read_unlock(&tasklist_lock);
1574 * no_tty - Ensure the current process does not have a controlling tty
1578 struct task_struct *tsk = current;
1579 if (tsk->signal->leader)
1580 disassociate_ctty(0);
1581 proc_clear_tty(tsk);
1586 * stop_tty - propagate flow control
1589 * Perform flow control to the driver. For PTY/TTY pairs we
1590 * must also propagate the TIOCKPKT status. May be called
1591 * on an already stopped device and will not re-call the driver
1594 * This functionality is used by both the line disciplines for
1595 * halting incoming flow and by the driver. It may therefore be
1596 * called from any context, may be under the tty atomic_write_lock
1600 * Broken. Relies on BKL which is unsafe here.
1603 void stop_tty(struct tty_struct *tty)
1608 if (tty->link && tty->link->packet) {
1609 tty->ctrl_status &= ~TIOCPKT_START;
1610 tty->ctrl_status |= TIOCPKT_STOP;
1611 wake_up_interruptible(&tty->link->read_wait);
1613 if (tty->driver->stop)
1614 (tty->driver->stop)(tty);
1617 EXPORT_SYMBOL(stop_tty);
1620 * start_tty - propagate flow control
1621 * @tty: tty to start
1623 * Start a tty that has been stopped if at all possible. Perform
1624 * any neccessary wakeups and propagate the TIOCPKT status. If this
1625 * is the tty was previous stopped and is being started then the
1626 * driver start method is invoked and the line discipline woken.
1629 * Broken. Relies on BKL which is unsafe here.
1632 void start_tty(struct tty_struct *tty)
1634 if (!tty->stopped || tty->flow_stopped)
1637 if (tty->link && tty->link->packet) {
1638 tty->ctrl_status &= ~TIOCPKT_STOP;
1639 tty->ctrl_status |= TIOCPKT_START;
1640 wake_up_interruptible(&tty->link->read_wait);
1642 if (tty->driver->start)
1643 (tty->driver->start)(tty);
1645 /* If we have a running line discipline it may need kicking */
1649 EXPORT_SYMBOL(start_tty);
1652 * tty_read - read method for tty device files
1653 * @file: pointer to tty file
1655 * @count: size of user buffer
1658 * Perform the read system call function on this terminal device. Checks
1659 * for hung up devices before calling the line discipline method.
1662 * Locks the line discipline internally while needed
1663 * For historical reasons the line discipline read method is
1664 * invoked under the BKL. This will go away in time so do not rely on it
1665 * in new code. Multiple read calls may be outstanding in parallel.
1668 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1672 struct tty_struct * tty;
1673 struct inode *inode;
1674 struct tty_ldisc *ld;
1676 tty = (struct tty_struct *)file->private_data;
1677 inode = file->f_path.dentry->d_inode;
1678 if (tty_paranoia_check(tty, inode, "tty_read"))
1680 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1683 /* We want to wait for the line discipline to sort out in this
1685 ld = tty_ldisc_ref_wait(tty);
1688 i = (ld->read)(tty,file,buf,count);
1691 tty_ldisc_deref(ld);
1694 inode->i_atime = current_fs_time(inode->i_sb);
1699 * Split writes up in sane blocksizes to avoid
1700 * denial-of-service type attacks
1702 static inline ssize_t do_tty_write(
1703 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1704 struct tty_struct *tty,
1706 const char __user *buf,
1709 ssize_t ret = 0, written = 0;
1712 /* FIXME: O_NDELAY ... */
1713 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1714 return -ERESTARTSYS;
1718 * We chunk up writes into a temporary buffer. This
1719 * simplifies low-level drivers immensely, since they
1720 * don't have locking issues and user mode accesses.
1722 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1725 * The default chunk-size is 2kB, because the NTTY
1726 * layer has problems with bigger chunks. It will
1727 * claim to be able to handle more characters than
1730 * FIXME: This can probably go away now except that 64K chunks
1731 * are too likely to fail unless switched to vmalloc...
1734 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1739 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1740 if (tty->write_cnt < chunk) {
1746 buf = kmalloc(chunk, GFP_KERNEL);
1748 mutex_unlock(&tty->atomic_write_lock);
1751 kfree(tty->write_buf);
1752 tty->write_cnt = chunk;
1753 tty->write_buf = buf;
1756 /* Do the write .. */
1758 size_t size = count;
1762 if (copy_from_user(tty->write_buf, buf, size))
1765 ret = write(tty, file, tty->write_buf, size);
1775 if (signal_pending(current))
1780 struct inode *inode = file->f_path.dentry->d_inode;
1781 inode->i_mtime = current_fs_time(inode->i_sb);
1784 mutex_unlock(&tty->atomic_write_lock);
1790 * tty_write - write method for tty device file
1791 * @file: tty file pointer
1792 * @buf: user data to write
1793 * @count: bytes to write
1796 * Write data to a tty device via the line discipline.
1799 * Locks the line discipline as required
1800 * Writes to the tty driver are serialized by the atomic_write_lock
1801 * and are then processed in chunks to the device. The line discipline
1802 * write method will not be involked in parallel for each device
1803 * The line discipline write method is called under the big
1804 * kernel lock for historical reasons. New code should not rely on this.
1807 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1810 struct tty_struct * tty;
1811 struct inode *inode = file->f_path.dentry->d_inode;
1813 struct tty_ldisc *ld;
1815 tty = (struct tty_struct *)file->private_data;
1816 if (tty_paranoia_check(tty, inode, "tty_write"))
1818 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1821 ld = tty_ldisc_ref_wait(tty);
1825 ret = do_tty_write(ld->write, tty, file, buf, count);
1826 tty_ldisc_deref(ld);
1830 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1833 struct file *p = NULL;
1835 spin_lock(&redirect_lock);
1840 spin_unlock(&redirect_lock);
1844 res = vfs_write(p, buf, count, &p->f_pos);
1849 return tty_write(file, buf, count, ppos);
1852 static char ptychar[] = "pqrstuvwxyzabcde";
1855 * pty_line_name - generate name for a pty
1856 * @driver: the tty driver in use
1857 * @index: the minor number
1858 * @p: output buffer of at least 6 bytes
1860 * Generate a name from a driver reference and write it to the output
1865 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1867 int i = index + driver->name_base;
1868 /* ->name is initialized to "ttyp", but "tty" is expected */
1869 sprintf(p, "%s%c%x",
1870 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1871 ptychar[i >> 4 & 0xf], i & 0xf);
1875 * pty_line_name - generate name for a tty
1876 * @driver: the tty driver in use
1877 * @index: the minor number
1878 * @p: output buffer of at least 7 bytes
1880 * Generate a name from a driver reference and write it to the output
1885 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1887 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1891 * init_dev - initialise a tty device
1892 * @driver: tty driver we are opening a device on
1893 * @idx: device index
1894 * @tty: returned tty structure
1896 * Prepare a tty device. This may not be a "new" clean device but
1897 * could also be an active device. The pty drivers require special
1898 * handling because of this.
1901 * The function is called under the tty_mutex, which
1902 * protects us from the tty struct or driver itself going away.
1904 * On exit the tty device has the line discipline attached and
1905 * a reference count of 1. If a pair was created for pty/tty use
1906 * and the other was a pty master then it too has a reference count of 1.
1908 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1909 * failed open. The new code protects the open with a mutex, so it's
1910 * really quite straightforward. The mutex locking can probably be
1911 * relaxed for the (most common) case of reopening a tty.
1914 static int init_dev(struct tty_driver *driver, int idx,
1915 struct tty_struct **ret_tty)
1917 struct tty_struct *tty, *o_tty;
1918 struct ktermios *tp, **tp_loc, *o_tp, **o_tp_loc;
1919 struct ktermios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1922 /* check whether we're reopening an existing tty */
1923 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1924 tty = devpts_get_tty(idx);
1926 * If we don't have a tty here on a slave open, it's because
1927 * the master already started the close process and there's
1928 * no relation between devpts file and tty anymore.
1930 if (!tty && driver->subtype == PTY_TYPE_SLAVE) {
1935 * It's safe from now on because init_dev() is called with
1936 * tty_mutex held and release_dev() won't change tty->count
1937 * or tty->flags without having to grab tty_mutex
1939 if (tty && driver->subtype == PTY_TYPE_MASTER)
1942 tty = driver->ttys[idx];
1944 if (tty) goto fast_track;
1947 * First time open is complex, especially for PTY devices.
1948 * This code guarantees that either everything succeeds and the
1949 * TTY is ready for operation, or else the table slots are vacated
1950 * and the allocated memory released. (Except that the termios
1951 * and locked termios may be retained.)
1954 if (!try_module_get(driver->owner)) {
1963 tty = alloc_tty_struct();
1966 initialize_tty_struct(tty);
1967 tty->driver = driver;
1969 tty_line_name(driver, idx, tty->name);
1971 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1972 tp_loc = &tty->termios;
1973 ltp_loc = &tty->termios_locked;
1975 tp_loc = &driver->termios[idx];
1976 ltp_loc = &driver->termios_locked[idx];
1980 tp = (struct ktermios *) kmalloc(sizeof(struct ktermios),
1984 *tp = driver->init_termios;
1988 ltp = (struct ktermios *) kmalloc(sizeof(struct ktermios),
1992 memset(ltp, 0, sizeof(struct ktermios));
1995 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1996 o_tty = alloc_tty_struct();
1999 initialize_tty_struct(o_tty);
2000 o_tty->driver = driver->other;
2002 tty_line_name(driver->other, idx, o_tty->name);
2004 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
2005 o_tp_loc = &o_tty->termios;
2006 o_ltp_loc = &o_tty->termios_locked;
2008 o_tp_loc = &driver->other->termios[idx];
2009 o_ltp_loc = &driver->other->termios_locked[idx];
2013 o_tp = (struct ktermios *)
2014 kmalloc(sizeof(struct ktermios), GFP_KERNEL);
2017 *o_tp = driver->other->init_termios;
2021 o_ltp = (struct ktermios *)
2022 kmalloc(sizeof(struct ktermios), GFP_KERNEL);
2025 memset(o_ltp, 0, sizeof(struct ktermios));
2029 * Everything allocated ... set up the o_tty structure.
2031 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
2032 driver->other->ttys[idx] = o_tty;
2038 o_tty->termios = *o_tp_loc;
2039 o_tty->termios_locked = *o_ltp_loc;
2040 driver->other->refcount++;
2041 if (driver->subtype == PTY_TYPE_MASTER)
2044 /* Establish the links in both directions */
2050 * All structures have been allocated, so now we install them.
2051 * Failures after this point use release_tty to clean up, so
2052 * there's no need to null out the local pointers.
2054 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2055 driver->ttys[idx] = tty;
2062 tty->termios = *tp_loc;
2063 tty->termios_locked = *ltp_loc;
2064 /* Compatibility until drivers always set this */
2065 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
2066 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
2071 * Structures all installed ... call the ldisc open routines.
2072 * If we fail here just call release_tty to clean up. No need
2073 * to decrement the use counts, as release_tty doesn't care.
2076 if (tty->ldisc.open) {
2077 retval = (tty->ldisc.open)(tty);
2079 goto release_mem_out;
2081 if (o_tty && o_tty->ldisc.open) {
2082 retval = (o_tty->ldisc.open)(o_tty);
2084 if (tty->ldisc.close)
2085 (tty->ldisc.close)(tty);
2086 goto release_mem_out;
2088 tty_ldisc_enable(o_tty);
2090 tty_ldisc_enable(tty);
2094 * This fast open can be used if the tty is already open.
2095 * No memory is allocated, and the only failures are from
2096 * attempting to open a closing tty or attempting multiple
2097 * opens on a pty master.
2100 if (test_bit(TTY_CLOSING, &tty->flags)) {
2104 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2105 driver->subtype == PTY_TYPE_MASTER) {
2107 * special case for PTY masters: only one open permitted,
2108 * and the slave side open count is incremented as well.
2117 tty->driver = driver; /* N.B. why do this every time?? */
2120 if(!test_bit(TTY_LDISC, &tty->flags))
2121 printk(KERN_ERR "init_dev but no ldisc\n");
2125 /* All paths come through here to release the mutex */
2129 /* Release locally allocated memory ... nothing placed in slots */
2133 free_tty_struct(o_tty);
2136 free_tty_struct(tty);
2139 module_put(driver->owner);
2143 /* call the tty release_tty routine to clean out this slot */
2145 if (printk_ratelimit())
2146 printk(KERN_INFO "init_dev: ldisc open failed, "
2147 "clearing slot %d\n", idx);
2148 release_tty(tty, idx);
2153 * release_one_tty - release tty structure memory
2155 * Releases memory associated with a tty structure, and clears out the
2156 * driver table slots. This function is called when a device is no longer
2157 * in use. It also gets called when setup of a device fails.
2160 * tty_mutex - sometimes only
2161 * takes the file list lock internally when working on the list
2162 * of ttys that the driver keeps.
2163 * FIXME: should we require tty_mutex is held here ??
2165 static void release_one_tty(struct tty_struct *tty, int idx)
2167 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2168 struct ktermios *tp;
2171 tty->driver->ttys[idx] = NULL;
2173 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2176 tty->driver->termios[idx] = NULL;
2179 tp = tty->termios_locked;
2181 tty->driver->termios_locked[idx] = NULL;
2187 tty->driver->refcount--;
2190 list_del_init(&tty->tty_files);
2193 free_tty_struct(tty);
2197 * release_tty - release tty structure memory
2199 * Release both @tty and a possible linked partner (think pty pair),
2200 * and decrement the refcount of the backing module.
2203 * tty_mutex - sometimes only
2204 * takes the file list lock internally when working on the list
2205 * of ttys that the driver keeps.
2206 * FIXME: should we require tty_mutex is held here ??
2208 static void release_tty(struct tty_struct *tty, int idx)
2210 struct tty_driver *driver = tty->driver;
2213 release_one_tty(tty->link, idx);
2214 release_one_tty(tty, idx);
2215 module_put(driver->owner);
2219 * Even releasing the tty structures is a tricky business.. We have
2220 * to be very careful that the structures are all released at the
2221 * same time, as interrupts might otherwise get the wrong pointers.
2223 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2224 * lead to double frees or releasing memory still in use.
2226 static void release_dev(struct file * filp)
2228 struct tty_struct *tty, *o_tty;
2229 int pty_master, tty_closing, o_tty_closing, do_sleep;
2233 unsigned long flags;
2235 tty = (struct tty_struct *)filp->private_data;
2236 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "release_dev"))
2239 check_tty_count(tty, "release_dev");
2241 tty_fasync(-1, filp, 0);
2244 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2245 tty->driver->subtype == PTY_TYPE_MASTER);
2246 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2249 #ifdef TTY_PARANOIA_CHECK
2250 if (idx < 0 || idx >= tty->driver->num) {
2251 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2252 "free (%s)\n", tty->name);
2255 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2256 if (tty != tty->driver->ttys[idx]) {
2257 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2258 "for (%s)\n", idx, tty->name);
2261 if (tty->termios != tty->driver->termios[idx]) {
2262 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2267 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2268 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2269 "termios_locked for (%s)\n",
2276 #ifdef TTY_DEBUG_HANGUP
2277 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2278 tty_name(tty, buf), tty->count);
2281 #ifdef TTY_PARANOIA_CHECK
2282 if (tty->driver->other &&
2283 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2284 if (o_tty != tty->driver->other->ttys[idx]) {
2285 printk(KERN_DEBUG "release_dev: other->table[%d] "
2286 "not o_tty for (%s)\n",
2290 if (o_tty->termios != tty->driver->other->termios[idx]) {
2291 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2292 "not o_termios for (%s)\n",
2296 if (o_tty->termios_locked !=
2297 tty->driver->other->termios_locked[idx]) {
2298 printk(KERN_DEBUG "release_dev: other->termios_locked["
2299 "%d] not o_termios_locked for (%s)\n",
2303 if (o_tty->link != tty) {
2304 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2309 if (tty->driver->close)
2310 tty->driver->close(tty, filp);
2313 * Sanity check: if tty->count is going to zero, there shouldn't be
2314 * any waiters on tty->read_wait or tty->write_wait. We test the
2315 * wait queues and kick everyone out _before_ actually starting to
2316 * close. This ensures that we won't block while releasing the tty
2319 * The test for the o_tty closing is necessary, since the master and
2320 * slave sides may close in any order. If the slave side closes out
2321 * first, its count will be one, since the master side holds an open.
2322 * Thus this test wouldn't be triggered at the time the slave closes,
2325 * Note that it's possible for the tty to be opened again while we're
2326 * flushing out waiters. By recalculating the closing flags before
2327 * each iteration we avoid any problems.
2330 /* Guard against races with tty->count changes elsewhere and
2331 opens on /dev/tty */
2333 mutex_lock(&tty_mutex);
2334 tty_closing = tty->count <= 1;
2335 o_tty_closing = o_tty &&
2336 (o_tty->count <= (pty_master ? 1 : 0));
2340 if (waitqueue_active(&tty->read_wait)) {
2341 wake_up(&tty->read_wait);
2344 if (waitqueue_active(&tty->write_wait)) {
2345 wake_up(&tty->write_wait);
2349 if (o_tty_closing) {
2350 if (waitqueue_active(&o_tty->read_wait)) {
2351 wake_up(&o_tty->read_wait);
2354 if (waitqueue_active(&o_tty->write_wait)) {
2355 wake_up(&o_tty->write_wait);
2362 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2363 "active!\n", tty_name(tty, buf));
2364 mutex_unlock(&tty_mutex);
2369 * The closing flags are now consistent with the open counts on
2370 * both sides, and we've completed the last operation that could
2371 * block, so it's safe to proceed with closing.
2374 if (--o_tty->count < 0) {
2375 printk(KERN_WARNING "release_dev: bad pty slave count "
2377 o_tty->count, tty_name(o_tty, buf));
2381 if (--tty->count < 0) {
2382 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2383 tty->count, tty_name(tty, buf));
2388 * We've decremented tty->count, so we need to remove this file
2389 * descriptor off the tty->tty_files list; this serves two
2391 * - check_tty_count sees the correct number of file descriptors
2392 * associated with this tty.
2393 * - do_tty_hangup no longer sees this file descriptor as
2394 * something that needs to be handled for hangups.
2397 filp->private_data = NULL;
2400 * Perform some housekeeping before deciding whether to return.
2402 * Set the TTY_CLOSING flag if this was the last open. In the
2403 * case of a pty we may have to wait around for the other side
2404 * to close, and TTY_CLOSING makes sure we can't be reopened.
2407 set_bit(TTY_CLOSING, &tty->flags);
2409 set_bit(TTY_CLOSING, &o_tty->flags);
2412 * If _either_ side is closing, make sure there aren't any
2413 * processes that still think tty or o_tty is their controlling
2416 if (tty_closing || o_tty_closing) {
2417 read_lock(&tasklist_lock);
2418 session_clear_tty(tty->session);
2420 session_clear_tty(o_tty->session);
2421 read_unlock(&tasklist_lock);
2424 mutex_unlock(&tty_mutex);
2426 /* check whether both sides are closing ... */
2427 if (!tty_closing || (o_tty && !o_tty_closing))
2430 #ifdef TTY_DEBUG_HANGUP
2431 printk(KERN_DEBUG "freeing tty structure...");
2434 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2435 * kill any delayed work. As this is the final close it does not
2436 * race with the set_ldisc code path.
2438 clear_bit(TTY_LDISC, &tty->flags);
2439 cancel_delayed_work(&tty->buf.work);
2442 * Wait for ->hangup_work and ->buf.work handlers to terminate
2445 flush_scheduled_work();
2448 * Wait for any short term users (we know they are just driver
2449 * side waiters as the file is closing so user count on the file
2452 spin_lock_irqsave(&tty_ldisc_lock, flags);
2453 while(tty->ldisc.refcount)
2455 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2456 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2457 spin_lock_irqsave(&tty_ldisc_lock, flags);
2459 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2461 * Shutdown the current line discipline, and reset it to N_TTY.
2462 * N.B. why reset ldisc when we're releasing the memory??
2464 * FIXME: this MUST get fixed for the new reflocking
2466 if (tty->ldisc.close)
2467 (tty->ldisc.close)(tty);
2468 tty_ldisc_put(tty->ldisc.num);
2471 * Switch the line discipline back
2473 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2474 tty_set_termios_ldisc(tty,N_TTY);
2476 /* FIXME: could o_tty be in setldisc here ? */
2477 clear_bit(TTY_LDISC, &o_tty->flags);
2478 if (o_tty->ldisc.close)
2479 (o_tty->ldisc.close)(o_tty);
2480 tty_ldisc_put(o_tty->ldisc.num);
2481 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2482 tty_set_termios_ldisc(o_tty,N_TTY);
2485 * The release_tty function takes care of the details of clearing
2486 * the slots and preserving the termios structure.
2488 release_tty(tty, idx);
2490 #ifdef CONFIG_UNIX98_PTYS
2491 /* Make this pty number available for reallocation */
2493 down(&allocated_ptys_lock);
2494 idr_remove(&allocated_ptys, idx);
2495 up(&allocated_ptys_lock);
2502 * tty_open - open a tty device
2503 * @inode: inode of device file
2504 * @filp: file pointer to tty
2506 * tty_open and tty_release keep up the tty count that contains the
2507 * number of opens done on a tty. We cannot use the inode-count, as
2508 * different inodes might point to the same tty.
2510 * Open-counting is needed for pty masters, as well as for keeping
2511 * track of serial lines: DTR is dropped when the last close happens.
2512 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2514 * The termios state of a pty is reset on first open so that
2515 * settings don't persist across reuse.
2517 * Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2518 * tty->count should protect the rest.
2519 * ->siglock protects ->signal/->sighand
2522 static int tty_open(struct inode * inode, struct file * filp)
2524 struct tty_struct *tty;
2526 struct tty_driver *driver;
2528 dev_t device = inode->i_rdev;
2529 unsigned short saved_flags = filp->f_flags;
2531 nonseekable_open(inode, filp);
2534 noctty = filp->f_flags & O_NOCTTY;
2538 mutex_lock(&tty_mutex);
2540 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2541 tty = get_current_tty();
2543 mutex_unlock(&tty_mutex);
2546 driver = tty->driver;
2548 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2553 if (device == MKDEV(TTY_MAJOR,0)) {
2554 extern struct tty_driver *console_driver;
2555 driver = console_driver;
2561 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2562 driver = console_device(&index);
2564 /* Don't let /dev/console block */
2565 filp->f_flags |= O_NONBLOCK;
2569 mutex_unlock(&tty_mutex);
2573 driver = get_tty_driver(device, &index);
2575 mutex_unlock(&tty_mutex);
2579 retval = init_dev(driver, index, &tty);
2580 mutex_unlock(&tty_mutex);
2584 filp->private_data = tty;
2585 file_move(filp, &tty->tty_files);
2586 check_tty_count(tty, "tty_open");
2587 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2588 tty->driver->subtype == PTY_TYPE_MASTER)
2590 #ifdef TTY_DEBUG_HANGUP
2591 printk(KERN_DEBUG "opening %s...", tty->name);
2594 if (tty->driver->open)
2595 retval = tty->driver->open(tty, filp);
2599 filp->f_flags = saved_flags;
2601 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2605 #ifdef TTY_DEBUG_HANGUP
2606 printk(KERN_DEBUG "error %d in opening %s...", retval,
2610 if (retval != -ERESTARTSYS)
2612 if (signal_pending(current))
2616 * Need to reset f_op in case a hangup happened.
2618 if (filp->f_op == &hung_up_tty_fops)
2619 filp->f_op = &tty_fops;
2623 mutex_lock(&tty_mutex);
2624 spin_lock_irq(¤t->sighand->siglock);
2626 current->signal->leader &&
2627 !current->signal->tty &&
2628 tty->session == NULL)
2629 __proc_set_tty(current, tty);
2630 spin_unlock_irq(¤t->sighand->siglock);
2631 mutex_unlock(&tty_mutex);
2635 #ifdef CONFIG_UNIX98_PTYS
2637 * ptmx_open - open a unix 98 pty master
2638 * @inode: inode of device file
2639 * @filp: file pointer to tty
2641 * Allocate a unix98 pty master device from the ptmx driver.
2643 * Locking: tty_mutex protects theinit_dev work. tty->count should
2645 * allocated_ptys_lock handles the list of free pty numbers
2648 static int ptmx_open(struct inode * inode, struct file * filp)
2650 struct tty_struct *tty;
2655 nonseekable_open(inode, filp);
2657 /* find a device that is not in use. */
2658 down(&allocated_ptys_lock);
2659 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2660 up(&allocated_ptys_lock);
2663 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2665 up(&allocated_ptys_lock);
2666 if (idr_ret == -EAGAIN)
2670 if (index >= pty_limit) {
2671 idr_remove(&allocated_ptys, index);
2672 up(&allocated_ptys_lock);
2675 up(&allocated_ptys_lock);
2677 mutex_lock(&tty_mutex);
2678 retval = init_dev(ptm_driver, index, &tty);
2679 mutex_unlock(&tty_mutex);
2684 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2685 filp->private_data = tty;
2686 file_move(filp, &tty->tty_files);
2689 if (devpts_pty_new(tty->link))
2692 check_tty_count(tty, "tty_open");
2693 retval = ptm_driver->open(tty, filp);
2700 down(&allocated_ptys_lock);
2701 idr_remove(&allocated_ptys, index);
2702 up(&allocated_ptys_lock);
2708 * tty_release - vfs callback for close
2709 * @inode: inode of tty
2710 * @filp: file pointer for handle to tty
2712 * Called the last time each file handle is closed that references
2713 * this tty. There may however be several such references.
2716 * Takes bkl. See release_dev
2719 static int tty_release(struct inode * inode, struct file * filp)
2728 * tty_poll - check tty status
2729 * @filp: file being polled
2730 * @wait: poll wait structures to update
2732 * Call the line discipline polling method to obtain the poll
2733 * status of the device.
2735 * Locking: locks called line discipline but ldisc poll method
2736 * may be re-entered freely by other callers.
2739 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2741 struct tty_struct * tty;
2742 struct tty_ldisc *ld;
2745 tty = (struct tty_struct *)filp->private_data;
2746 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
2749 ld = tty_ldisc_ref_wait(tty);
2751 ret = (ld->poll)(tty, filp, wait);
2752 tty_ldisc_deref(ld);
2756 static int tty_fasync(int fd, struct file * filp, int on)
2758 struct tty_struct * tty;
2761 tty = (struct tty_struct *)filp->private_data;
2762 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
2765 retval = fasync_helper(fd, filp, on, &tty->fasync);
2772 if (!waitqueue_active(&tty->read_wait))
2773 tty->minimum_to_wake = 1;
2776 type = PIDTYPE_PGID;
2778 pid = task_pid(current);
2781 retval = __f_setown(filp, pid, type, 0);
2785 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2786 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2792 * tiocsti - fake input character
2793 * @tty: tty to fake input into
2794 * @p: pointer to character
2796 * Fake input to a tty device. Does the neccessary locking and
2799 * FIXME: does not honour flow control ??
2802 * Called functions take tty_ldisc_lock
2803 * current->signal->tty check is safe without locks
2805 * FIXME: may race normal receive processing
2808 static int tiocsti(struct tty_struct *tty, char __user *p)
2811 struct tty_ldisc *ld;
2813 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2815 if (get_user(ch, p))
2817 ld = tty_ldisc_ref_wait(tty);
2818 ld->receive_buf(tty, &ch, &mbz, 1);
2819 tty_ldisc_deref(ld);
2824 * tiocgwinsz - implement window query ioctl
2826 * @arg: user buffer for result
2828 * Copies the kernel idea of the window size into the user buffer.
2830 * Locking: tty->termios_mutex is taken to ensure the winsize data
2834 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2838 mutex_lock(&tty->termios_mutex);
2839 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2840 mutex_unlock(&tty->termios_mutex);
2842 return err ? -EFAULT: 0;
2846 * tiocswinsz - implement window size set ioctl
2848 * @arg: user buffer for result
2850 * Copies the user idea of the window size to the kernel. Traditionally
2851 * this is just advisory information but for the Linux console it
2852 * actually has driver level meaning and triggers a VC resize.
2855 * Called function use the console_sem is used to ensure we do
2856 * not try and resize the console twice at once.
2857 * The tty->termios_mutex is used to ensure we don't double
2858 * resize and get confused. Lock order - tty->termios_mutex before
2862 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2863 struct winsize __user * arg)
2865 struct winsize tmp_ws;
2867 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2870 mutex_lock(&tty->termios_mutex);
2871 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2875 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2876 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2878 mutex_unlock(&tty->termios_mutex);
2884 kill_pgrp(tty->pgrp, SIGWINCH, 1);
2885 if ((real_tty->pgrp != tty->pgrp) && real_tty->pgrp)
2886 kill_pgrp(real_tty->pgrp, SIGWINCH, 1);
2887 tty->winsize = tmp_ws;
2888 real_tty->winsize = tmp_ws;
2890 mutex_unlock(&tty->termios_mutex);
2895 * tioccons - allow admin to move logical console
2896 * @file: the file to become console
2898 * Allow the adminstrator to move the redirected console device
2900 * Locking: uses redirect_lock to guard the redirect information
2903 static int tioccons(struct file *file)
2905 if (!capable(CAP_SYS_ADMIN))
2907 if (file->f_op->write == redirected_tty_write) {
2909 spin_lock(&redirect_lock);
2912 spin_unlock(&redirect_lock);
2917 spin_lock(&redirect_lock);
2919 spin_unlock(&redirect_lock);
2924 spin_unlock(&redirect_lock);
2929 * fionbio - non blocking ioctl
2930 * @file: file to set blocking value
2931 * @p: user parameter
2933 * Historical tty interfaces had a blocking control ioctl before
2934 * the generic functionality existed. This piece of history is preserved
2935 * in the expected tty API of posix OS's.
2937 * Locking: none, the open fle handle ensures it won't go away.
2940 static int fionbio(struct file *file, int __user *p)
2944 if (get_user(nonblock, p))
2948 file->f_flags |= O_NONBLOCK;
2950 file->f_flags &= ~O_NONBLOCK;
2955 * tiocsctty - set controlling tty
2956 * @tty: tty structure
2957 * @arg: user argument
2959 * This ioctl is used to manage job control. It permits a session
2960 * leader to set this tty as the controlling tty for the session.
2963 * Takes tty_mutex() to protect tty instance
2964 * Takes tasklist_lock internally to walk sessions
2965 * Takes ->siglock() when updating signal->tty
2968 static int tiocsctty(struct tty_struct *tty, int arg)
2971 if (current->signal->leader && (task_session(current) == tty->session))
2974 mutex_lock(&tty_mutex);
2976 * The process must be a session leader and
2977 * not have a controlling tty already.
2979 if (!current->signal->leader || current->signal->tty) {
2986 * This tty is already the controlling
2987 * tty for another session group!
2989 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2993 read_lock(&tasklist_lock);
2994 session_clear_tty(tty->session);
2995 read_unlock(&tasklist_lock);
3001 proc_set_tty(current, tty);
3003 mutex_unlock(&tty_mutex);
3008 * tiocgpgrp - get process group
3009 * @tty: tty passed by user
3010 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3013 * Obtain the process group of the tty. If there is no process group
3016 * Locking: none. Reference to current->signal->tty is safe.
3019 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3022 * (tty == real_tty) is a cheap way of
3023 * testing if the tty is NOT a master pty.
3025 if (tty == real_tty && current->signal->tty != real_tty)
3027 return put_user(pid_nr(real_tty->pgrp), p);
3031 * tiocspgrp - attempt to set process group
3032 * @tty: tty passed by user
3033 * @real_tty: tty side device matching tty passed by user
3036 * Set the process group of the tty to the session passed. Only
3037 * permitted where the tty session is our session.
3042 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3046 int retval = tty_check_change(real_tty);
3052 if (!current->signal->tty ||
3053 (current->signal->tty != real_tty) ||
3054 (real_tty->session != task_session(current)))
3056 if (get_user(pgrp_nr, p))
3061 pgrp = find_pid(pgrp_nr);
3066 if (session_of_pgrp(pgrp) != task_session(current))
3069 put_pid(real_tty->pgrp);
3070 real_tty->pgrp = get_pid(pgrp);
3077 * tiocgsid - get session id
3078 * @tty: tty passed by user
3079 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3080 * @p: pointer to returned session id
3082 * Obtain the session id of the tty. If there is no session
3085 * Locking: none. Reference to current->signal->tty is safe.
3088 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3091 * (tty == real_tty) is a cheap way of
3092 * testing if the tty is NOT a master pty.
3094 if (tty == real_tty && current->signal->tty != real_tty)
3096 if (!real_tty->session)
3098 return put_user(pid_nr(real_tty->session), p);
3102 * tiocsetd - set line discipline
3104 * @p: pointer to user data
3106 * Set the line discipline according to user request.
3108 * Locking: see tty_set_ldisc, this function is just a helper
3111 static int tiocsetd(struct tty_struct *tty, int __user *p)
3115 if (get_user(ldisc, p))
3117 return tty_set_ldisc(tty, ldisc);
3121 * send_break - performed time break
3122 * @tty: device to break on
3123 * @duration: timeout in mS
3125 * Perform a timed break on hardware that lacks its own driver level
3126 * timed break functionality.
3129 * atomic_write_lock serializes
3133 static int send_break(struct tty_struct *tty, unsigned int duration)
3135 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3137 tty->driver->break_ctl(tty, -1);
3138 if (!signal_pending(current)) {
3139 msleep_interruptible(duration);
3141 tty->driver->break_ctl(tty, 0);
3142 mutex_unlock(&tty->atomic_write_lock);
3143 if (signal_pending(current))
3149 * tiocmget - get modem status
3151 * @file: user file pointer
3152 * @p: pointer to result
3154 * Obtain the modem status bits from the tty driver if the feature
3155 * is supported. Return -EINVAL if it is not available.
3157 * Locking: none (up to the driver)
3160 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3162 int retval = -EINVAL;
3164 if (tty->driver->tiocmget) {
3165 retval = tty->driver->tiocmget(tty, file);
3168 retval = put_user(retval, p);
3174 * tiocmset - set modem status
3176 * @file: user file pointer
3177 * @cmd: command - clear bits, set bits or set all
3178 * @p: pointer to desired bits
3180 * Set the modem status bits from the tty driver if the feature
3181 * is supported. Return -EINVAL if it is not available.
3183 * Locking: none (up to the driver)
3186 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3189 int retval = -EINVAL;
3191 if (tty->driver->tiocmset) {
3192 unsigned int set, clear, val;
3194 retval = get_user(val, p);
3212 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3213 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3215 retval = tty->driver->tiocmset(tty, file, set, clear);
3221 * Split this up, as gcc can choke on it otherwise..
3223 int tty_ioctl(struct inode * inode, struct file * file,
3224 unsigned int cmd, unsigned long arg)
3226 struct tty_struct *tty, *real_tty;
3227 void __user *p = (void __user *)arg;
3229 struct tty_ldisc *ld;
3231 tty = (struct tty_struct *)file->private_data;
3232 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3235 /* CHECKME: is this safe as one end closes ? */
3238 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3239 tty->driver->subtype == PTY_TYPE_MASTER)
3240 real_tty = tty->link;
3243 * Break handling by driver
3245 if (!tty->driver->break_ctl) {
3249 if (tty->driver->ioctl)
3250 return tty->driver->ioctl(tty, file, cmd, arg);
3253 /* These two ioctl's always return success; even if */
3254 /* the driver doesn't support them. */
3257 if (!tty->driver->ioctl)
3259 retval = tty->driver->ioctl(tty, file, cmd, arg);
3260 if (retval == -ENOIOCTLCMD)
3267 * Factor out some common prep work
3275 retval = tty_check_change(tty);
3278 if (cmd != TIOCCBRK) {
3279 tty_wait_until_sent(tty, 0);
3280 if (signal_pending(current))
3288 return tiocsti(tty, p);
3290 return tiocgwinsz(tty, p);
3292 return tiocswinsz(tty, real_tty, p);
3294 return real_tty!=tty ? -EINVAL : tioccons(file);
3296 return fionbio(file, p);
3298 set_bit(TTY_EXCLUSIVE, &tty->flags);
3301 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3304 if (current->signal->tty != tty)
3309 return tiocsctty(tty, arg);
3311 return tiocgpgrp(tty, real_tty, p);
3313 return tiocspgrp(tty, real_tty, p);
3315 return tiocgsid(tty, real_tty, p);
3317 /* FIXME: check this is ok */
3318 return put_user(tty->ldisc.num, (int __user *)p);
3320 return tiocsetd(tty, p);
3323 return tioclinux(tty, arg);
3328 case TIOCSBRK: /* Turn break on, unconditionally */
3329 tty->driver->break_ctl(tty, -1);
3332 case TIOCCBRK: /* Turn break off, unconditionally */
3333 tty->driver->break_ctl(tty, 0);
3335 case TCSBRK: /* SVID version: non-zero arg --> no break */
3336 /* non-zero arg means wait for all output data
3337 * to be sent (performed above) but don't send break.
3338 * This is used by the tcdrain() termios function.
3341 return send_break(tty, 250);
3343 case TCSBRKP: /* support for POSIX tcsendbreak() */
3344 return send_break(tty, arg ? arg*100 : 250);
3347 return tty_tiocmget(tty, file, p);
3352 return tty_tiocmset(tty, file, cmd, p);
3354 if (tty->driver->ioctl) {
3355 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3356 if (retval != -ENOIOCTLCMD)
3359 ld = tty_ldisc_ref_wait(tty);
3362 retval = ld->ioctl(tty, file, cmd, arg);
3363 if (retval == -ENOIOCTLCMD)
3366 tty_ldisc_deref(ld);
3370 #ifdef CONFIG_COMPAT
3371 static long tty_compat_ioctl(struct file * file, unsigned int cmd,
3374 struct inode *inode = file->f_dentry->d_inode;
3375 struct tty_struct *tty = file->private_data;
3376 struct tty_ldisc *ld;
3377 int retval = -ENOIOCTLCMD;
3379 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3382 if (tty->driver->compat_ioctl) {
3383 retval = (tty->driver->compat_ioctl)(tty, file, cmd, arg);
3384 if (retval != -ENOIOCTLCMD)
3388 ld = tty_ldisc_ref_wait(tty);
3389 if (ld->compat_ioctl)
3390 retval = ld->compat_ioctl(tty, file, cmd, arg);
3391 tty_ldisc_deref(ld);
3398 * This implements the "Secure Attention Key" --- the idea is to
3399 * prevent trojan horses by killing all processes associated with this
3400 * tty when the user hits the "Secure Attention Key". Required for
3401 * super-paranoid applications --- see the Orange Book for more details.
3403 * This code could be nicer; ideally it should send a HUP, wait a few
3404 * seconds, then send a INT, and then a KILL signal. But you then
3405 * have to coordinate with the init process, since all processes associated
3406 * with the current tty must be dead before the new getty is allowed
3409 * Now, if it would be correct ;-/ The current code has a nasty hole -
3410 * it doesn't catch files in flight. We may send the descriptor to ourselves
3411 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3413 * Nasty bug: do_SAK is being called in interrupt context. This can
3414 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3416 void __do_SAK(struct tty_struct *tty)
3421 struct task_struct *g, *p;
3422 struct pid *session;
3425 struct fdtable *fdt;
3429 session = tty->session;
3431 tty_ldisc_flush(tty);
3433 if (tty->driver->flush_buffer)
3434 tty->driver->flush_buffer(tty);
3436 read_lock(&tasklist_lock);
3437 /* Kill the entire session */
3438 do_each_pid_task(session, PIDTYPE_SID, p) {
3439 printk(KERN_NOTICE "SAK: killed process %d"
3440 " (%s): process_session(p)==tty->session\n",
3442 send_sig(SIGKILL, p, 1);
3443 } while_each_pid_task(session, PIDTYPE_SID, p);
3444 /* Now kill any processes that happen to have the
3447 do_each_thread(g, p) {
3448 if (p->signal->tty == tty) {
3449 printk(KERN_NOTICE "SAK: killed process %d"
3450 " (%s): process_session(p)==tty->session\n",
3452 send_sig(SIGKILL, p, 1);
3458 * We don't take a ref to the file, so we must
3459 * hold ->file_lock instead.
3461 spin_lock(&p->files->file_lock);
3462 fdt = files_fdtable(p->files);
3463 for (i=0; i < fdt->max_fds; i++) {
3464 filp = fcheck_files(p->files, i);
3467 if (filp->f_op->read == tty_read &&
3468 filp->private_data == tty) {
3469 printk(KERN_NOTICE "SAK: killed process %d"
3470 " (%s): fd#%d opened to the tty\n",
3471 p->pid, p->comm, i);
3472 force_sig(SIGKILL, p);
3476 spin_unlock(&p->files->file_lock);
3479 } while_each_thread(g, p);
3480 read_unlock(&tasklist_lock);
3484 static void do_SAK_work(struct work_struct *work)
3486 struct tty_struct *tty =
3487 container_of(work, struct tty_struct, SAK_work);
3492 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3493 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3494 * the values which we write to it will be identical to the values which it
3495 * already has. --akpm
3497 void do_SAK(struct tty_struct *tty)
3501 schedule_work(&tty->SAK_work);
3504 EXPORT_SYMBOL(do_SAK);
3508 * @work: tty structure passed from work queue.
3510 * This routine is called out of the software interrupt to flush data
3511 * from the buffer chain to the line discipline.
3513 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3514 * while invoking the line discipline receive_buf method. The
3515 * receive_buf method is single threaded for each tty instance.
3518 static void flush_to_ldisc(struct work_struct *work)
3520 struct tty_struct *tty =
3521 container_of(work, struct tty_struct, buf.work.work);
3522 unsigned long flags;
3523 struct tty_ldisc *disc;
3524 struct tty_buffer *tbuf, *head;
3526 unsigned char *flag_buf;
3528 disc = tty_ldisc_ref(tty);
3529 if (disc == NULL) /* !TTY_LDISC */
3532 spin_lock_irqsave(&tty->buf.lock, flags);
3533 head = tty->buf.head;
3535 tty->buf.head = NULL;
3537 int count = head->commit - head->read;
3539 if (head->next == NULL)
3543 tty_buffer_free(tty, tbuf);
3546 if (!tty->receive_room) {
3547 schedule_delayed_work(&tty->buf.work, 1);
3550 if (count > tty->receive_room)
3551 count = tty->receive_room;
3552 char_buf = head->char_buf_ptr + head->read;
3553 flag_buf = head->flag_buf_ptr + head->read;
3554 head->read += count;
3555 spin_unlock_irqrestore(&tty->buf.lock, flags);
3556 disc->receive_buf(tty, char_buf, flag_buf, count);
3557 spin_lock_irqsave(&tty->buf.lock, flags);
3559 tty->buf.head = head;
3561 spin_unlock_irqrestore(&tty->buf.lock, flags);
3563 tty_ldisc_deref(disc);
3567 * tty_flip_buffer_push - terminal
3570 * Queue a push of the terminal flip buffers to the line discipline. This
3571 * function must not be called from IRQ context if tty->low_latency is set.
3573 * In the event of the queue being busy for flipping the work will be
3574 * held off and retried later.
3576 * Locking: tty buffer lock. Driver locks in low latency mode.
3579 void tty_flip_buffer_push(struct tty_struct *tty)
3581 unsigned long flags;
3582 spin_lock_irqsave(&tty->buf.lock, flags);
3583 if (tty->buf.tail != NULL)
3584 tty->buf.tail->commit = tty->buf.tail->used;
3585 spin_unlock_irqrestore(&tty->buf.lock, flags);
3587 if (tty->low_latency)
3588 flush_to_ldisc(&tty->buf.work.work);
3590 schedule_delayed_work(&tty->buf.work, 1);
3593 EXPORT_SYMBOL(tty_flip_buffer_push);
3597 * initialize_tty_struct
3598 * @tty: tty to initialize
3600 * This subroutine initializes a tty structure that has been newly
3603 * Locking: none - tty in question must not be exposed at this point
3606 static void initialize_tty_struct(struct tty_struct *tty)
3608 memset(tty, 0, sizeof(struct tty_struct));
3609 tty->magic = TTY_MAGIC;
3610 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3611 tty->session = NULL;
3613 tty->overrun_time = jiffies;
3614 tty->buf.head = tty->buf.tail = NULL;
3615 tty_buffer_init(tty);
3616 INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
3617 init_MUTEX(&tty->buf.pty_sem);
3618 mutex_init(&tty->termios_mutex);
3619 init_waitqueue_head(&tty->write_wait);
3620 init_waitqueue_head(&tty->read_wait);
3621 INIT_WORK(&tty->hangup_work, do_tty_hangup);
3622 mutex_init(&tty->atomic_read_lock);
3623 mutex_init(&tty->atomic_write_lock);
3624 spin_lock_init(&tty->read_lock);
3625 INIT_LIST_HEAD(&tty->tty_files);
3626 INIT_WORK(&tty->SAK_work, do_SAK_work);
3630 * The default put_char routine if the driver did not define one.
3633 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3635 tty->driver->write(tty, &ch, 1);
3638 static struct class *tty_class;
3641 * tty_register_device - register a tty device
3642 * @driver: the tty driver that describes the tty device
3643 * @index: the index in the tty driver for this tty device
3644 * @device: a struct device that is associated with this tty device.
3645 * This field is optional, if there is no known struct device
3646 * for this tty device it can be set to NULL safely.
3648 * Returns a pointer to the struct device for this tty device
3649 * (or ERR_PTR(-EFOO) on error).
3651 * This call is required to be made to register an individual tty device
3652 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3653 * that bit is not set, this function should not be called by a tty
3659 struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3660 struct device *device)
3663 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3665 if (index >= driver->num) {
3666 printk(KERN_ERR "Attempt to register invalid tty line number "
3668 return ERR_PTR(-EINVAL);
3671 if (driver->type == TTY_DRIVER_TYPE_PTY)
3672 pty_line_name(driver, index, name);
3674 tty_line_name(driver, index, name);
3676 return device_create(tty_class, device, dev, name);
3680 * tty_unregister_device - unregister a tty device
3681 * @driver: the tty driver that describes the tty device
3682 * @index: the index in the tty driver for this tty device
3684 * If a tty device is registered with a call to tty_register_device() then
3685 * this function must be called when the tty device is gone.
3690 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3692 device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3695 EXPORT_SYMBOL(tty_register_device);
3696 EXPORT_SYMBOL(tty_unregister_device);
3698 struct tty_driver *alloc_tty_driver(int lines)
3700 struct tty_driver *driver;
3702 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3704 memset(driver, 0, sizeof(struct tty_driver));
3705 driver->magic = TTY_DRIVER_MAGIC;
3706 driver->num = lines;
3707 /* later we'll move allocation of tables here */
3712 void put_tty_driver(struct tty_driver *driver)
3717 void tty_set_operations(struct tty_driver *driver,
3718 const struct tty_operations *op)
3720 driver->open = op->open;
3721 driver->close = op->close;
3722 driver->write = op->write;
3723 driver->put_char = op->put_char;
3724 driver->flush_chars = op->flush_chars;
3725 driver->write_room = op->write_room;
3726 driver->chars_in_buffer = op->chars_in_buffer;
3727 driver->ioctl = op->ioctl;
3728 driver->compat_ioctl = op->compat_ioctl;
3729 driver->set_termios = op->set_termios;
3730 driver->throttle = op->throttle;
3731 driver->unthrottle = op->unthrottle;
3732 driver->stop = op->stop;
3733 driver->start = op->start;
3734 driver->hangup = op->hangup;
3735 driver->break_ctl = op->break_ctl;
3736 driver->flush_buffer = op->flush_buffer;
3737 driver->set_ldisc = op->set_ldisc;
3738 driver->wait_until_sent = op->wait_until_sent;
3739 driver->send_xchar = op->send_xchar;
3740 driver->read_proc = op->read_proc;
3741 driver->write_proc = op->write_proc;
3742 driver->tiocmget = op->tiocmget;
3743 driver->tiocmset = op->tiocmset;
3747 EXPORT_SYMBOL(alloc_tty_driver);
3748 EXPORT_SYMBOL(put_tty_driver);
3749 EXPORT_SYMBOL(tty_set_operations);
3752 * Called by a tty driver to register itself.
3754 int tty_register_driver(struct tty_driver *driver)
3761 if (driver->flags & TTY_DRIVER_INSTALLED)
3764 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
3765 p = kzalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3770 if (!driver->major) {
3771 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3774 driver->major = MAJOR(dev);
3775 driver->minor_start = MINOR(dev);
3778 dev = MKDEV(driver->major, driver->minor_start);
3779 error = register_chrdev_region(dev, driver->num, driver->name);
3787 driver->ttys = (struct tty_struct **)p;
3788 driver->termios = (struct ktermios **)(p + driver->num);
3789 driver->termios_locked = (struct ktermios **)(p + driver->num * 2);
3791 driver->ttys = NULL;
3792 driver->termios = NULL;
3793 driver->termios_locked = NULL;
3796 cdev_init(&driver->cdev, &tty_fops);
3797 driver->cdev.owner = driver->owner;
3798 error = cdev_add(&driver->cdev, dev, driver->num);
3800 unregister_chrdev_region(dev, driver->num);
3801 driver->ttys = NULL;
3802 driver->termios = driver->termios_locked = NULL;
3807 if (!driver->put_char)
3808 driver->put_char = tty_default_put_char;
3810 mutex_lock(&tty_mutex);
3811 list_add(&driver->tty_drivers, &tty_drivers);
3812 mutex_unlock(&tty_mutex);
3814 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3815 for(i = 0; i < driver->num; i++)
3816 tty_register_device(driver, i, NULL);
3818 proc_tty_register_driver(driver);
3822 EXPORT_SYMBOL(tty_register_driver);
3825 * Called by a tty driver to unregister itself.
3827 int tty_unregister_driver(struct tty_driver *driver)
3830 struct ktermios *tp;
3833 if (driver->refcount)
3836 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3838 mutex_lock(&tty_mutex);
3839 list_del(&driver->tty_drivers);
3840 mutex_unlock(&tty_mutex);
3843 * Free the termios and termios_locked structures because
3844 * we don't want to get memory leaks when modular tty
3845 * drivers are removed from the kernel.
3847 for (i = 0; i < driver->num; i++) {
3848 tp = driver->termios[i];
3850 driver->termios[i] = NULL;
3853 tp = driver->termios_locked[i];
3855 driver->termios_locked[i] = NULL;
3858 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3859 tty_unregister_device(driver, i);
3862 proc_tty_unregister_driver(driver);
3863 driver->ttys = NULL;
3864 driver->termios = driver->termios_locked = NULL;
3866 cdev_del(&driver->cdev);
3869 EXPORT_SYMBOL(tty_unregister_driver);
3871 dev_t tty_devnum(struct tty_struct *tty)
3873 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3875 EXPORT_SYMBOL(tty_devnum);
3877 void proc_clear_tty(struct task_struct *p)
3879 spin_lock_irq(&p->sighand->siglock);
3880 p->signal->tty = NULL;
3881 spin_unlock_irq(&p->sighand->siglock);
3884 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3887 /* We should not have a session or pgrp to here but.... */
3888 put_pid(tty->session);
3890 tty->session = get_pid(task_session(tsk));
3891 tty->pgrp = get_pid(task_pgrp(tsk));
3893 put_pid(tsk->signal->tty_old_pgrp);
3894 tsk->signal->tty = tty;
3895 tsk->signal->tty_old_pgrp = NULL;
3898 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3900 spin_lock_irq(&tsk->sighand->siglock);
3901 __proc_set_tty(tsk, tty);
3902 spin_unlock_irq(&tsk->sighand->siglock);
3905 struct tty_struct *get_current_tty(void)
3907 struct tty_struct *tty;
3908 WARN_ON_ONCE(!mutex_is_locked(&tty_mutex));
3909 tty = current->signal->tty;
3911 * session->tty can be changed/cleared from under us, make sure we
3912 * issue the load. The obtained pointer, when not NULL, is valid as
3913 * long as we hold tty_mutex.
3918 EXPORT_SYMBOL_GPL(get_current_tty);
3921 * Initialize the console device. This is called *early*, so
3922 * we can't necessarily depend on lots of kernel help here.
3923 * Just do some early initializations, and do the complex setup
3926 void __init console_init(void)
3930 /* Setup the default TTY line discipline. */
3931 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3934 * set up the console device so that later boot sequences can
3935 * inform about problems etc..
3937 call = __con_initcall_start;
3938 while (call < __con_initcall_end) {
3945 extern int vty_init(void);
3948 static int __init tty_class_init(void)
3950 tty_class = class_create(THIS_MODULE, "tty");
3951 if (IS_ERR(tty_class))
3952 return PTR_ERR(tty_class);
3956 postcore_initcall(tty_class_init);
3958 /* 3/2004 jmc: why do these devices exist? */
3960 static struct cdev tty_cdev, console_cdev;
3961 #ifdef CONFIG_UNIX98_PTYS
3962 static struct cdev ptmx_cdev;
3965 static struct cdev vc0_cdev;
3969 * Ok, now we can initialize the rest of the tty devices and can count
3970 * on memory allocations, interrupts etc..
3972 static int __init tty_init(void)
3974 cdev_init(&tty_cdev, &tty_fops);
3975 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3976 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3977 panic("Couldn't register /dev/tty driver\n");
3978 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
3980 cdev_init(&console_cdev, &console_fops);
3981 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3982 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3983 panic("Couldn't register /dev/console driver\n");
3984 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
3986 #ifdef CONFIG_UNIX98_PTYS
3987 cdev_init(&ptmx_cdev, &ptmx_fops);
3988 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3989 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3990 panic("Couldn't register /dev/ptmx driver\n");
3991 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
3995 cdev_init(&vc0_cdev, &console_fops);
3996 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3997 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3998 panic("Couldn't register /dev/tty0 driver\n");
3999 device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
4005 module_init(tty_init);