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>
106 #include <linux/vs_cvirt.h>
108 #undef TTY_DEBUG_HANGUP
110 #define TTY_PARANOIA_CHECK 1
111 #define CHECK_TTY_COUNT 1
113 struct termios tty_std_termios = { /* for the benefit of tty drivers */
114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
122 EXPORT_SYMBOL(tty_std_termios);
124 /* This list gets poked at by procfs and various bits of boot up code. This
125 could do with some rationalisation such as pulling the tty proc function
128 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
130 /* Mutex to protect creating and releasing a tty. This is shared with
131 vt.c for deeply disgusting hack reasons */
132 DEFINE_MUTEX(tty_mutex);
133 EXPORT_SYMBOL(tty_mutex);
135 #ifdef CONFIG_UNIX98_PTYS
136 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
137 extern int pty_limit; /* Config limit on Unix98 ptys */
138 static DEFINE_IDR(allocated_ptys);
139 static DECLARE_MUTEX(allocated_ptys_lock);
140 static int ptmx_open(struct inode *, struct file *);
143 extern void disable_early_printk(void);
145 static void initialize_tty_struct(struct tty_struct *tty);
147 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
148 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
149 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
150 static unsigned int tty_poll(struct file *, poll_table *);
151 static int tty_open(struct inode *, struct file *);
152 static int tty_release(struct inode *, struct file *);
153 int tty_ioctl(struct inode * inode, struct file * file,
154 unsigned int cmd, unsigned long arg);
155 static int tty_fasync(int fd, struct file * filp, int on);
156 static void release_mem(struct tty_struct *tty, int idx);
159 * alloc_tty_struct - allocate a tty object
161 * Return a new empty tty structure. The data fields have not
162 * been initialized in any way but has been zeroed
167 static struct tty_struct *alloc_tty_struct(void)
169 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
172 static void tty_buffer_free_all(struct tty_struct *);
175 * free_tty_struct - free a disused tty
176 * @tty: tty struct to free
178 * Free the write buffers, tty queue and tty memory itself.
180 * Locking: none. Must be called after tty is definitely unused
183 static inline void free_tty_struct(struct tty_struct *tty)
185 kfree(tty->write_buf);
186 tty_buffer_free_all(tty);
190 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
193 * tty_name - return tty naming
194 * @tty: tty structure
195 * @buf: buffer for output
197 * Convert a tty structure into a name. The name reflects the kernel
198 * naming policy and if udev is in use may not reflect user space
203 char *tty_name(struct tty_struct *tty, char *buf)
205 if (!tty) /* Hmm. NULL pointer. That's fun. */
206 strcpy(buf, "NULL tty");
208 strcpy(buf, tty->name);
212 EXPORT_SYMBOL(tty_name);
214 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
217 #ifdef TTY_PARANOIA_CHECK
220 "null TTY for (%d:%d) in %s\n",
221 imajor(inode), iminor(inode), routine);
224 if (tty->magic != TTY_MAGIC) {
226 "bad magic number for tty struct (%d:%d) in %s\n",
227 imajor(inode), iminor(inode), routine);
234 static int check_tty_count(struct tty_struct *tty, const char *routine)
236 #ifdef CHECK_TTY_COUNT
241 list_for_each(p, &tty->tty_files) {
245 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
246 tty->driver->subtype == PTY_TYPE_SLAVE &&
247 tty->link && tty->link->count)
249 if (tty->count != count) {
250 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
251 "!= #fd's(%d) in %s\n",
252 tty->name, tty->count, count, routine);
260 * Tty buffer allocation management
264 * tty_buffer_free_all - free buffers used by a tty
265 * @tty: tty to free from
267 * Remove all the buffers pending on a tty whether queued with data
268 * or in the free ring. Must be called when the tty is no longer in use
273 static void tty_buffer_free_all(struct tty_struct *tty)
275 struct tty_buffer *thead;
276 while((thead = tty->buf.head) != NULL) {
277 tty->buf.head = thead->next;
280 while((thead = tty->buf.free) != NULL) {
281 tty->buf.free = thead->next;
284 tty->buf.tail = NULL;
285 tty->buf.memory_used = 0;
289 * tty_buffer_init - prepare a tty buffer structure
290 * @tty: tty to initialise
292 * Set up the initial state of the buffer management for a tty device.
293 * Must be called before the other tty buffer functions are used.
298 static void tty_buffer_init(struct tty_struct *tty)
300 spin_lock_init(&tty->buf.lock);
301 tty->buf.head = NULL;
302 tty->buf.tail = NULL;
303 tty->buf.free = NULL;
304 tty->buf.memory_used = 0;
308 * tty_buffer_alloc - allocate a tty buffer
310 * @size: desired size (characters)
312 * Allocate a new tty buffer to hold the desired number of characters.
313 * Return NULL if out of memory or the allocation would exceed the
316 * Locking: Caller must hold tty->buf.lock
319 static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
321 struct tty_buffer *p;
323 if (tty->buf.memory_used + size > 65536)
325 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
333 p->char_buf_ptr = (char *)(p->data);
334 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
335 tty->buf.memory_used += size;
340 * tty_buffer_free - free a tty buffer
341 * @tty: tty owning the buffer
342 * @b: the buffer to free
344 * Free a tty buffer, or add it to the free list according to our
347 * Locking: Caller must hold tty->buf.lock
350 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
352 /* Dumb strategy for now - should keep some stats */
353 tty->buf.memory_used -= b->size;
354 WARN_ON(tty->buf.memory_used < 0);
359 b->next = tty->buf.free;
365 * tty_buffer_find - find a free tty buffer
366 * @tty: tty owning the buffer
367 * @size: characters wanted
369 * Locate an existing suitable tty buffer or if we are lacking one then
370 * allocate a new one. We round our buffers off in 256 character chunks
371 * to get better allocation behaviour.
373 * Locking: Caller must hold tty->buf.lock
376 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
378 struct tty_buffer **tbh = &tty->buf.free;
379 while((*tbh) != NULL) {
380 struct tty_buffer *t = *tbh;
381 if(t->size >= size) {
387 tty->buf.memory_used += t->size;
390 tbh = &((*tbh)->next);
392 /* Round the buffer size out */
393 size = (size + 0xFF) & ~ 0xFF;
394 return tty_buffer_alloc(tty, size);
395 /* Should possibly check if this fails for the largest buffer we
396 have queued and recycle that ? */
400 * tty_buffer_request_room - grow tty buffer if needed
401 * @tty: tty structure
402 * @size: size desired
404 * Make at least size bytes of linear space available for the tty
405 * buffer. If we fail return the size we managed to find.
407 * Locking: Takes tty->buf.lock
409 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
411 struct tty_buffer *b, *n;
415 spin_lock_irqsave(&tty->buf.lock, flags);
417 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
418 remove this conditional if its worth it. This would be invisible
420 if ((b = tty->buf.tail) != NULL)
421 left = b->size - b->used;
426 /* This is the slow path - looking for new buffers to use */
427 if ((n = tty_buffer_find(tty, size)) != NULL) {
438 spin_unlock_irqrestore(&tty->buf.lock, flags);
441 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
444 * tty_insert_flip_string - Add characters to the tty buffer
445 * @tty: tty structure
449 * Queue a series of bytes to the tty buffering. All the characters
450 * passed are marked as without error. Returns the number added.
452 * Locking: Called functions may take tty->buf.lock
455 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
460 int space = tty_buffer_request_room(tty, size - copied);
461 struct tty_buffer *tb = tty->buf.tail;
462 /* If there is no space then tb may be NULL */
463 if(unlikely(space == 0))
465 memcpy(tb->char_buf_ptr + tb->used, chars, space);
466 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
470 /* There is a small chance that we need to split the data over
471 several buffers. If this is the case we must loop */
472 } while (unlikely(size > copied));
475 EXPORT_SYMBOL(tty_insert_flip_string);
478 * tty_insert_flip_string_flags - Add characters to the tty buffer
479 * @tty: tty structure
484 * Queue a series of bytes to the tty buffering. For each character
485 * the flags array indicates the status of the character. Returns the
488 * Locking: Called functions may take tty->buf.lock
491 int tty_insert_flip_string_flags(struct tty_struct *tty,
492 const unsigned char *chars, const char *flags, size_t size)
496 int space = tty_buffer_request_room(tty, size - copied);
497 struct tty_buffer *tb = tty->buf.tail;
498 /* If there is no space then tb may be NULL */
499 if(unlikely(space == 0))
501 memcpy(tb->char_buf_ptr + tb->used, chars, space);
502 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
507 /* There is a small chance that we need to split the data over
508 several buffers. If this is the case we must loop */
509 } while (unlikely(size > copied));
512 EXPORT_SYMBOL(tty_insert_flip_string_flags);
515 * tty_schedule_flip - push characters to ldisc
516 * @tty: tty to push from
518 * Takes any pending buffers and transfers their ownership to the
519 * ldisc side of the queue. It then schedules those characters for
520 * processing by the line discipline.
522 * Locking: Takes tty->buf.lock
525 void tty_schedule_flip(struct tty_struct *tty)
528 spin_lock_irqsave(&tty->buf.lock, flags);
529 if (tty->buf.tail != NULL)
530 tty->buf.tail->commit = tty->buf.tail->used;
531 spin_unlock_irqrestore(&tty->buf.lock, flags);
532 schedule_delayed_work(&tty->buf.work, 1);
534 EXPORT_SYMBOL(tty_schedule_flip);
537 * tty_prepare_flip_string - make room for characters
539 * @chars: return pointer for character write area
540 * @size: desired size
542 * Prepare a block of space in the buffer for data. Returns the length
543 * available and buffer pointer to the space which is now allocated and
544 * accounted for as ready for normal characters. This is used for drivers
545 * that need their own block copy routines into the buffer. There is no
546 * guarantee the buffer is a DMA target!
548 * Locking: May call functions taking tty->buf.lock
551 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
553 int space = tty_buffer_request_room(tty, size);
555 struct tty_buffer *tb = tty->buf.tail;
556 *chars = tb->char_buf_ptr + tb->used;
557 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
563 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
566 * tty_prepare_flip_string_flags - make room for characters
568 * @chars: return pointer for character write area
569 * @flags: return pointer for status flag write area
570 * @size: desired size
572 * Prepare a block of space in the buffer for data. Returns the length
573 * available and buffer pointer to the space which is now allocated and
574 * accounted for as ready for characters. This is used for drivers
575 * that need their own block copy routines into the buffer. There is no
576 * guarantee the buffer is a DMA target!
578 * Locking: May call functions taking tty->buf.lock
581 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
583 int space = tty_buffer_request_room(tty, size);
585 struct tty_buffer *tb = tty->buf.tail;
586 *chars = tb->char_buf_ptr + tb->used;
587 *flags = tb->flag_buf_ptr + tb->used;
593 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
598 * tty_set_termios_ldisc - set ldisc field
599 * @tty: tty structure
600 * @num: line discipline number
602 * This is probably overkill for real world processors but
603 * they are not on hot paths so a little discipline won't do
606 * Locking: takes termios_mutex
609 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
611 mutex_lock(&tty->termios_mutex);
612 tty->termios->c_line = num;
613 mutex_unlock(&tty->termios_mutex);
617 * This guards the refcounted line discipline lists. The lock
618 * must be taken with irqs off because there are hangup path
619 * callers who will do ldisc lookups and cannot sleep.
622 static DEFINE_SPINLOCK(tty_ldisc_lock);
623 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
624 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
627 * tty_register_ldisc - install a line discipline
628 * @disc: ldisc number
629 * @new_ldisc: pointer to the ldisc object
631 * Installs a new line discipline into the kernel. The discipline
632 * is set up as unreferenced and then made available to the kernel
633 * from this point onwards.
636 * takes tty_ldisc_lock to guard against ldisc races
639 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
644 if (disc < N_TTY || disc >= NR_LDISCS)
647 spin_lock_irqsave(&tty_ldisc_lock, flags);
648 tty_ldiscs[disc] = *new_ldisc;
649 tty_ldiscs[disc].num = disc;
650 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
651 tty_ldiscs[disc].refcount = 0;
652 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
656 EXPORT_SYMBOL(tty_register_ldisc);
659 * tty_unregister_ldisc - unload a line discipline
660 * @disc: ldisc number
661 * @new_ldisc: pointer to the ldisc object
663 * Remove a line discipline from the kernel providing it is not
667 * takes tty_ldisc_lock to guard against ldisc races
670 int tty_unregister_ldisc(int disc)
675 if (disc < N_TTY || disc >= NR_LDISCS)
678 spin_lock_irqsave(&tty_ldisc_lock, flags);
679 if (tty_ldiscs[disc].refcount)
682 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
683 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
687 EXPORT_SYMBOL(tty_unregister_ldisc);
690 * tty_ldisc_get - take a reference to an ldisc
691 * @disc: ldisc number
693 * Takes a reference to a line discipline. Deals with refcounts and
694 * module locking counts. Returns NULL if the discipline is not available.
695 * Returns a pointer to the discipline and bumps the ref count if it is
699 * takes tty_ldisc_lock to guard against ldisc races
702 struct tty_ldisc *tty_ldisc_get(int disc)
705 struct tty_ldisc *ld;
707 if (disc < N_TTY || disc >= NR_LDISCS)
710 spin_lock_irqsave(&tty_ldisc_lock, flags);
712 ld = &tty_ldiscs[disc];
713 /* Check the entry is defined */
714 if(ld->flags & LDISC_FLAG_DEFINED)
716 /* If the module is being unloaded we can't use it */
717 if (!try_module_get(ld->owner))
724 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
728 EXPORT_SYMBOL_GPL(tty_ldisc_get);
731 * tty_ldisc_put - drop ldisc reference
732 * @disc: ldisc number
734 * Drop a reference to a line discipline. Manage refcounts and
735 * module usage counts
738 * takes tty_ldisc_lock to guard against ldisc races
741 void tty_ldisc_put(int disc)
743 struct tty_ldisc *ld;
746 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
748 spin_lock_irqsave(&tty_ldisc_lock, flags);
749 ld = &tty_ldiscs[disc];
750 BUG_ON(ld->refcount == 0);
752 module_put(ld->owner);
753 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
756 EXPORT_SYMBOL_GPL(tty_ldisc_put);
759 * tty_ldisc_assign - set ldisc on a tty
760 * @tty: tty to assign
761 * @ld: line discipline
763 * Install an instance of a line discipline into a tty structure. The
764 * ldisc must have a reference count above zero to ensure it remains/
765 * The tty instance refcount starts at zero.
768 * Caller must hold references
771 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
774 tty->ldisc.refcount = 0;
778 * tty_ldisc_try - internal helper
781 * Make a single attempt to grab and bump the refcount on
782 * the tty ldisc. Return 0 on failure or 1 on success. This is
783 * used to implement both the waiting and non waiting versions
786 * Locking: takes tty_ldisc_lock
789 static int tty_ldisc_try(struct tty_struct *tty)
792 struct tty_ldisc *ld;
795 spin_lock_irqsave(&tty_ldisc_lock, flags);
797 if(test_bit(TTY_LDISC, &tty->flags))
802 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
807 * tty_ldisc_ref_wait - wait for the tty ldisc
810 * Dereference the line discipline for the terminal and take a
811 * reference to it. If the line discipline is in flux then
812 * wait patiently until it changes.
814 * Note: Must not be called from an IRQ/timer context. The caller
815 * must also be careful not to hold other locks that will deadlock
816 * against a discipline change, such as an existing ldisc reference
817 * (which we check for)
819 * Locking: call functions take tty_ldisc_lock
822 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
824 /* wait_event is a macro */
825 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
826 if(tty->ldisc.refcount == 0)
827 printk(KERN_ERR "tty_ldisc_ref_wait\n");
831 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
834 * tty_ldisc_ref - get the tty ldisc
837 * Dereference the line discipline for the terminal and take a
838 * reference to it. If the line discipline is in flux then
839 * return NULL. Can be called from IRQ and timer functions.
841 * Locking: called functions take tty_ldisc_lock
844 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
846 if(tty_ldisc_try(tty))
851 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
854 * tty_ldisc_deref - free a tty ldisc reference
855 * @ld: reference to free up
857 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
858 * be called in IRQ context.
860 * Locking: takes tty_ldisc_lock
863 void tty_ldisc_deref(struct tty_ldisc *ld)
869 spin_lock_irqsave(&tty_ldisc_lock, flags);
870 if(ld->refcount == 0)
871 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
874 if(ld->refcount == 0)
875 wake_up(&tty_ldisc_wait);
876 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
879 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
882 * tty_ldisc_enable - allow ldisc use
883 * @tty: terminal to activate ldisc on
885 * Set the TTY_LDISC flag when the line discipline can be called
886 * again. Do neccessary wakeups for existing sleepers.
888 * Note: nobody should set this bit except via this function. Clearing
889 * directly is allowed.
892 static void tty_ldisc_enable(struct tty_struct *tty)
894 set_bit(TTY_LDISC, &tty->flags);
895 wake_up(&tty_ldisc_wait);
899 * tty_set_ldisc - set line discipline
900 * @tty: the terminal to set
901 * @ldisc: the line discipline
903 * Set the discipline of a tty line. Must be called from a process
906 * Locking: takes tty_ldisc_lock.
907 * called functions take termios_mutex
910 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
913 struct tty_ldisc o_ldisc;
917 struct tty_ldisc *ld;
918 struct tty_struct *o_tty;
920 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
925 ld = tty_ldisc_get(ldisc);
926 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
927 /* Cyrus Durgin <cider@speakeasy.org> */
929 request_module("tty-ldisc-%d", ldisc);
930 ld = tty_ldisc_get(ldisc);
936 * No more input please, we are switching. The new ldisc
937 * will update this value in the ldisc open function
940 tty->receive_room = 0;
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);
953 o_ldisc = tty->ldisc;
957 * Make sure we don't change while someone holds a
958 * reference to the line discipline. The TTY_LDISC bit
959 * prevents anyone taking a reference once it is clear.
960 * We need the lock to avoid racing reference takers.
963 spin_lock_irqsave(&tty_ldisc_lock, flags);
964 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
965 if(tty->ldisc.refcount) {
966 /* Free the new ldisc we grabbed. Must drop the lock
968 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
969 tty_ldisc_put(ldisc);
971 * There are several reasons we may be busy, including
972 * random momentary I/O traffic. We must therefore
973 * retry. We could distinguish between blocking ops
974 * and retries if we made tty_ldisc_wait() smarter. That
975 * is up for discussion.
977 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
981 if(o_tty && o_tty->ldisc.refcount) {
982 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
983 tty_ldisc_put(ldisc);
984 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
990 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
992 if (!test_bit(TTY_LDISC, &tty->flags)) {
993 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
994 tty_ldisc_put(ldisc);
995 ld = tty_ldisc_ref_wait(tty);
1000 clear_bit(TTY_LDISC, &tty->flags);
1002 clear_bit(TTY_LDISC, &o_tty->flags);
1003 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1006 * From this point on we know nobody has an ldisc
1007 * usage reference, nor can they obtain one until
1008 * we say so later on.
1011 work = cancel_delayed_work(&tty->buf.work);
1013 * Wait for ->hangup_work and ->buf.work handlers to terminate
1016 flush_scheduled_work();
1017 /* Shutdown the current discipline. */
1018 if (tty->ldisc.close)
1019 (tty->ldisc.close)(tty);
1021 /* Now set up the new line discipline. */
1022 tty_ldisc_assign(tty, ld);
1023 tty_set_termios_ldisc(tty, ldisc);
1024 if (tty->ldisc.open)
1025 retval = (tty->ldisc.open)(tty);
1027 tty_ldisc_put(ldisc);
1028 /* There is an outstanding reference here so this is safe */
1029 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1030 tty_set_termios_ldisc(tty, tty->ldisc.num);
1031 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1032 tty_ldisc_put(o_ldisc.num);
1033 /* This driver is always present */
1034 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1035 tty_set_termios_ldisc(tty, N_TTY);
1036 if (tty->ldisc.open) {
1037 int r = tty->ldisc.open(tty);
1040 panic("Couldn't open N_TTY ldisc for "
1042 tty_name(tty, buf), r);
1046 /* At this point we hold a reference to the new ldisc and a
1047 a reference to the old ldisc. If we ended up flipping back
1048 to the existing ldisc we have two references to it */
1050 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1051 tty->driver->set_ldisc(tty);
1053 tty_ldisc_put(o_ldisc.num);
1056 * Allow ldisc referencing to occur as soon as the driver
1057 * ldisc callback completes.
1060 tty_ldisc_enable(tty);
1062 tty_ldisc_enable(o_tty);
1064 /* Restart it in case no characters kick it off. Safe if
1067 schedule_delayed_work(&tty->buf.work, 1);
1072 * get_tty_driver - find device of a tty
1073 * @dev_t: device identifier
1074 * @index: returns the index of the tty
1076 * This routine returns a tty driver structure, given a device number
1077 * and also passes back the index number.
1079 * Locking: caller must hold tty_mutex
1082 static struct tty_driver *get_tty_driver(dev_t device, int *index)
1084 struct tty_driver *p;
1086 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1087 dev_t base = MKDEV(p->major, p->minor_start);
1088 if (device < base || device >= base + p->num)
1090 *index = device - base;
1097 * tty_check_change - check for POSIX terminal changes
1098 * @tty: tty to check
1100 * If we try to write to, or set the state of, a terminal and we're
1101 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1102 * ignored, go ahead and perform the operation. (POSIX 7.2)
1107 int tty_check_change(struct tty_struct * tty)
1109 if (current->signal->tty != tty)
1111 if (tty->pgrp <= 0) {
1112 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1115 if (process_group(current) == tty->pgrp)
1117 if (is_ignored(SIGTTOU))
1119 if (is_orphaned_pgrp(process_group(current)))
1121 (void) kill_pg(process_group(current), SIGTTOU, 1);
1122 return -ERESTARTSYS;
1125 EXPORT_SYMBOL(tty_check_change);
1127 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1128 size_t count, loff_t *ppos)
1133 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1134 size_t count, loff_t *ppos)
1139 /* No kernel lock held - none needed ;) */
1140 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1142 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1145 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1146 unsigned int cmd, unsigned long arg)
1148 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1151 static const struct file_operations tty_fops = {
1152 .llseek = no_llseek,
1158 .release = tty_release,
1159 .fasync = tty_fasync,
1162 #ifdef CONFIG_UNIX98_PTYS
1163 static const struct file_operations ptmx_fops = {
1164 .llseek = no_llseek,
1170 .release = tty_release,
1171 .fasync = tty_fasync,
1175 static const struct file_operations console_fops = {
1176 .llseek = no_llseek,
1178 .write = redirected_tty_write,
1182 .release = tty_release,
1183 .fasync = tty_fasync,
1186 static const struct file_operations hung_up_tty_fops = {
1187 .llseek = no_llseek,
1188 .read = hung_up_tty_read,
1189 .write = hung_up_tty_write,
1190 .poll = hung_up_tty_poll,
1191 .ioctl = hung_up_tty_ioctl,
1192 .release = tty_release,
1195 static DEFINE_SPINLOCK(redirect_lock);
1196 static struct file *redirect;
1199 * tty_wakeup - request more data
1202 * Internal and external helper for wakeups of tty. This function
1203 * informs the line discipline if present that the driver is ready
1204 * to receive more output data.
1207 void tty_wakeup(struct tty_struct *tty)
1209 struct tty_ldisc *ld;
1211 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1212 ld = tty_ldisc_ref(tty);
1214 if(ld->write_wakeup)
1215 ld->write_wakeup(tty);
1216 tty_ldisc_deref(ld);
1219 wake_up_interruptible(&tty->write_wait);
1222 EXPORT_SYMBOL_GPL(tty_wakeup);
1225 * tty_ldisc_flush - flush line discipline queue
1228 * Flush the line discipline queue (if any) for this tty. If there
1229 * is no line discipline active this is a no-op.
1232 void tty_ldisc_flush(struct tty_struct *tty)
1234 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1236 if(ld->flush_buffer)
1237 ld->flush_buffer(tty);
1238 tty_ldisc_deref(ld);
1242 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1245 * do_tty_hangup - actual handler for hangup events
1248 * This can be called by the "eventd" kernel thread. That is process
1249 * synchronous but doesn't hold any locks, so we need to make sure we
1250 * have the appropriate locks for what we're doing.
1252 * The hangup event clears any pending redirections onto the hung up
1253 * device. It ensures future writes will error and it does the needed
1254 * line discipline hangup and signal delivery. The tty object itself
1259 * redirect lock for undoing redirection
1260 * file list lock for manipulating list of ttys
1261 * tty_ldisc_lock from called functions
1262 * termios_mutex resetting termios data
1263 * tasklist_lock to walk task list for hangup event
1264 * ->siglock to protect ->signal/->sighand
1266 static void do_tty_hangup(void *data)
1268 struct tty_struct *tty = (struct tty_struct *) data;
1269 struct file * cons_filp = NULL;
1270 struct file *filp, *f = NULL;
1271 struct task_struct *p;
1272 struct tty_ldisc *ld;
1273 int closecount = 0, n;
1278 /* inuse_filps is protected by the single kernel lock */
1281 spin_lock(&redirect_lock);
1282 if (redirect && redirect->private_data == tty) {
1286 spin_unlock(&redirect_lock);
1288 check_tty_count(tty, "do_tty_hangup");
1290 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1291 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1292 if (filp->f_op->write == redirected_tty_write)
1294 if (filp->f_op->write != tty_write)
1297 tty_fasync(-1, filp, 0); /* can't block */
1298 filp->f_op = &hung_up_tty_fops;
1302 /* FIXME! What are the locking issues here? This may me overdoing things..
1303 * this question is especially important now that we've removed the irqlock. */
1305 ld = tty_ldisc_ref(tty);
1306 if(ld != NULL) /* We may have no line discipline at this point */
1308 if (ld->flush_buffer)
1309 ld->flush_buffer(tty);
1310 if (tty->driver->flush_buffer)
1311 tty->driver->flush_buffer(tty);
1312 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1314 ld->write_wakeup(tty);
1319 /* FIXME: Once we trust the LDISC code better we can wait here for
1320 ldisc completion and fix the driver call race */
1322 wake_up_interruptible(&tty->write_wait);
1323 wake_up_interruptible(&tty->read_wait);
1326 * Shutdown the current line discipline, and reset it to
1329 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1331 mutex_lock(&tty->termios_mutex);
1332 *tty->termios = tty->driver->init_termios;
1333 mutex_unlock(&tty->termios_mutex);
1336 /* Defer ldisc switch */
1337 /* tty_deferred_ldisc_switch(N_TTY);
1339 This should get done automatically when the port closes and
1340 tty_release is called */
1342 read_lock(&tasklist_lock);
1343 if (tty->session > 0) {
1344 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1345 spin_lock_irq(&p->sighand->siglock);
1346 if (p->signal->tty == tty)
1347 p->signal->tty = NULL;
1348 if (!p->signal->leader) {
1349 spin_unlock_irq(&p->sighand->siglock);
1352 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1353 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1355 p->signal->tty_old_pgrp = tty->pgrp;
1356 spin_unlock_irq(&p->sighand->siglock);
1357 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1359 read_unlock(&tasklist_lock);
1364 tty->ctrl_status = 0;
1366 * If one of the devices matches a console pointer, we
1367 * cannot just call hangup() because that will cause
1368 * tty->count and state->count to go out of sync.
1369 * So we just call close() the right number of times.
1372 if (tty->driver->close)
1373 for (n = 0; n < closecount; n++)
1374 tty->driver->close(tty, cons_filp);
1375 } else if (tty->driver->hangup)
1376 (tty->driver->hangup)(tty);
1378 /* We don't want to have driver/ldisc interactions beyond
1379 the ones we did here. The driver layer expects no
1380 calls after ->hangup() from the ldisc side. However we
1381 can't yet guarantee all that */
1383 set_bit(TTY_HUPPED, &tty->flags);
1385 tty_ldisc_enable(tty);
1386 tty_ldisc_deref(ld);
1394 * tty_hangup - trigger a hangup event
1395 * @tty: tty to hangup
1397 * A carrier loss (virtual or otherwise) has occurred on this like
1398 * schedule a hangup sequence to run after this event.
1401 void tty_hangup(struct tty_struct * tty)
1403 #ifdef TTY_DEBUG_HANGUP
1406 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1408 schedule_work(&tty->hangup_work);
1411 EXPORT_SYMBOL(tty_hangup);
1414 * tty_vhangup - process vhangup
1415 * @tty: tty to hangup
1417 * The user has asked via system call for the terminal to be hung up.
1418 * We do this synchronously so that when the syscall returns the process
1419 * is complete. That guarantee is neccessary for security reasons.
1422 void tty_vhangup(struct tty_struct * tty)
1424 #ifdef TTY_DEBUG_HANGUP
1427 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1429 do_tty_hangup((void *) tty);
1431 EXPORT_SYMBOL(tty_vhangup);
1434 * tty_hung_up_p - was tty hung up
1435 * @filp: file pointer of tty
1437 * Return true if the tty has been subject to a vhangup or a carrier
1441 int tty_hung_up_p(struct file * filp)
1443 return (filp->f_op == &hung_up_tty_fops);
1446 EXPORT_SYMBOL(tty_hung_up_p);
1448 static void session_clear_tty(pid_t session)
1450 struct task_struct *p;
1451 do_each_task_pid(session, PIDTYPE_SID, p) {
1453 } while_each_task_pid(session, PIDTYPE_SID, p);
1457 * disassociate_ctty - disconnect controlling tty
1458 * @on_exit: true if exiting so need to "hang up" the session
1460 * This function is typically called only by the session leader, when
1461 * it wants to disassociate itself from its controlling tty.
1463 * It performs the following functions:
1464 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1465 * (2) Clears the tty from being controlling the session
1466 * (3) Clears the controlling tty for all processes in the
1469 * The argument on_exit is set to 1 if called when a process is
1470 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1473 * BKL is taken for hysterical raisins
1474 * tty_mutex is taken to protect tty
1475 * ->siglock is taken to protect ->signal/->sighand
1476 * tasklist_lock is taken to walk process list for sessions
1477 * ->siglock is taken to protect ->signal/->sighand
1480 void disassociate_ctty(int on_exit)
1482 struct tty_struct *tty;
1488 mutex_lock(&tty_mutex);
1489 tty = get_current_tty();
1491 tty_pgrp = tty->pgrp;
1492 mutex_unlock(&tty_mutex);
1493 /* XXX: here we race, there is nothing protecting tty */
1494 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1497 pid_t old_pgrp = current->signal->tty_old_pgrp;
1499 kill_pg(old_pgrp, SIGHUP, on_exit);
1500 kill_pg(old_pgrp, SIGCONT, on_exit);
1502 mutex_unlock(&tty_mutex);
1507 kill_pg(tty_pgrp, SIGHUP, on_exit);
1509 kill_pg(tty_pgrp, SIGCONT, on_exit);
1512 spin_lock_irq(¤t->sighand->siglock);
1513 current->signal->tty_old_pgrp = 0;
1514 session = current->signal->session;
1515 spin_unlock_irq(¤t->sighand->siglock);
1517 mutex_lock(&tty_mutex);
1518 /* It is possible that do_tty_hangup has free'd this tty */
1519 tty = get_current_tty();
1524 #ifdef TTY_DEBUG_HANGUP
1525 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
1529 mutex_unlock(&tty_mutex);
1531 /* Now clear signal->tty under the lock */
1532 read_lock(&tasklist_lock);
1533 session_clear_tty(session);
1534 read_unlock(&tasklist_lock);
1540 * stop_tty - propogate flow control
1543 * Perform flow control to the driver. For PTY/TTY pairs we
1544 * must also propogate the TIOCKPKT status. May be called
1545 * on an already stopped device and will not re-call the driver
1548 * This functionality is used by both the line disciplines for
1549 * halting incoming flow and by the driver. It may therefore be
1550 * called from any context, may be under the tty atomic_write_lock
1554 * Broken. Relies on BKL which is unsafe here.
1557 void stop_tty(struct tty_struct *tty)
1562 if (tty->link && tty->link->packet) {
1563 tty->ctrl_status &= ~TIOCPKT_START;
1564 tty->ctrl_status |= TIOCPKT_STOP;
1565 wake_up_interruptible(&tty->link->read_wait);
1567 if (tty->driver->stop)
1568 (tty->driver->stop)(tty);
1571 EXPORT_SYMBOL(stop_tty);
1574 * start_tty - propogate flow control
1575 * @tty: tty to start
1577 * Start a tty that has been stopped if at all possible. Perform
1578 * any neccessary wakeups and propogate the TIOCPKT status. If this
1579 * is the tty was previous stopped and is being started then the
1580 * driver start method is invoked and the line discipline woken.
1583 * Broken. Relies on BKL which is unsafe here.
1586 void start_tty(struct tty_struct *tty)
1588 if (!tty->stopped || tty->flow_stopped)
1591 if (tty->link && tty->link->packet) {
1592 tty->ctrl_status &= ~TIOCPKT_STOP;
1593 tty->ctrl_status |= TIOCPKT_START;
1594 wake_up_interruptible(&tty->link->read_wait);
1596 if (tty->driver->start)
1597 (tty->driver->start)(tty);
1599 /* If we have a running line discipline it may need kicking */
1601 wake_up_interruptible(&tty->write_wait);
1604 EXPORT_SYMBOL(start_tty);
1607 * tty_read - read method for tty device files
1608 * @file: pointer to tty file
1610 * @count: size of user buffer
1613 * Perform the read system call function on this terminal device. Checks
1614 * for hung up devices before calling the line discipline method.
1617 * Locks the line discipline internally while needed
1618 * For historical reasons the line discipline read method is
1619 * invoked under the BKL. This will go away in time so do not rely on it
1620 * in new code. Multiple read calls may be outstanding in parallel.
1623 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1627 struct tty_struct * tty;
1628 struct inode *inode;
1629 struct tty_ldisc *ld;
1631 tty = (struct tty_struct *)file->private_data;
1632 inode = file->f_dentry->d_inode;
1633 if (tty_paranoia_check(tty, inode, "tty_read"))
1635 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1638 /* We want to wait for the line discipline to sort out in this
1640 ld = tty_ldisc_ref_wait(tty);
1643 i = (ld->read)(tty,file,buf,count);
1646 tty_ldisc_deref(ld);
1649 inode->i_atime = current_fs_time(inode->i_sb);
1654 * Split writes up in sane blocksizes to avoid
1655 * denial-of-service type attacks
1657 static inline ssize_t do_tty_write(
1658 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1659 struct tty_struct *tty,
1661 const char __user *buf,
1664 ssize_t ret = 0, written = 0;
1667 /* FIXME: O_NDELAY ... */
1668 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1669 return -ERESTARTSYS;
1673 * We chunk up writes into a temporary buffer. This
1674 * simplifies low-level drivers immensely, since they
1675 * don't have locking issues and user mode accesses.
1677 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1680 * The default chunk-size is 2kB, because the NTTY
1681 * layer has problems with bigger chunks. It will
1682 * claim to be able to handle more characters than
1685 * FIXME: This can probably go away now except that 64K chunks
1686 * are too likely to fail unless switched to vmalloc...
1689 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1694 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1695 if (tty->write_cnt < chunk) {
1701 buf = kmalloc(chunk, GFP_KERNEL);
1703 mutex_unlock(&tty->atomic_write_lock);
1706 kfree(tty->write_buf);
1707 tty->write_cnt = chunk;
1708 tty->write_buf = buf;
1711 /* Do the write .. */
1713 size_t size = count;
1717 if (copy_from_user(tty->write_buf, buf, size))
1720 ret = write(tty, file, tty->write_buf, size);
1730 if (signal_pending(current))
1735 struct inode *inode = file->f_dentry->d_inode;
1736 inode->i_mtime = current_fs_time(inode->i_sb);
1739 mutex_unlock(&tty->atomic_write_lock);
1745 * tty_write - write method for tty device file
1746 * @file: tty file pointer
1747 * @buf: user data to write
1748 * @count: bytes to write
1751 * Write data to a tty device via the line discipline.
1754 * Locks the line discipline as required
1755 * Writes to the tty driver are serialized by the atomic_write_lock
1756 * and are then processed in chunks to the device. The line discipline
1757 * write method will not be involked in parallel for each device
1758 * The line discipline write method is called under the big
1759 * kernel lock for historical reasons. New code should not rely on this.
1762 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1765 struct tty_struct * tty;
1766 struct inode *inode = file->f_dentry->d_inode;
1768 struct tty_ldisc *ld;
1770 tty = (struct tty_struct *)file->private_data;
1771 if (tty_paranoia_check(tty, inode, "tty_write"))
1773 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1776 ld = tty_ldisc_ref_wait(tty);
1780 ret = do_tty_write(ld->write, tty, file, buf, count);
1781 tty_ldisc_deref(ld);
1785 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1788 struct file *p = NULL;
1790 spin_lock(&redirect_lock);
1795 spin_unlock(&redirect_lock);
1799 res = vfs_write(p, buf, count, &p->f_pos);
1804 return tty_write(file, buf, count, ppos);
1807 static char ptychar[] = "pqrstuvwxyzabcde";
1810 * pty_line_name - generate name for a pty
1811 * @driver: the tty driver in use
1812 * @index: the minor number
1813 * @p: output buffer of at least 6 bytes
1815 * Generate a name from a driver reference and write it to the output
1820 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1822 int i = index + driver->name_base;
1823 /* ->name is initialized to "ttyp", but "tty" is expected */
1824 sprintf(p, "%s%c%x",
1825 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1826 ptychar[i >> 4 & 0xf], i & 0xf);
1830 * pty_line_name - generate name for a tty
1831 * @driver: the tty driver in use
1832 * @index: the minor number
1833 * @p: output buffer of at least 7 bytes
1835 * Generate a name from a driver reference and write it to the output
1840 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1842 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1846 * init_dev - initialise a tty device
1847 * @driver: tty driver we are opening a device on
1848 * @idx: device index
1849 * @tty: returned tty structure
1851 * Prepare a tty device. This may not be a "new" clean device but
1852 * could also be an active device. The pty drivers require special
1853 * handling because of this.
1856 * The function is called under the tty_mutex, which
1857 * protects us from the tty struct or driver itself going away.
1859 * On exit the tty device has the line discipline attached and
1860 * a reference count of 1. If a pair was created for pty/tty use
1861 * and the other was a pty master then it too has a reference count of 1.
1863 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1864 * failed open. The new code protects the open with a mutex, so it's
1865 * really quite straightforward. The mutex locking can probably be
1866 * relaxed for the (most common) case of reopening a tty.
1869 static int init_dev(struct tty_driver *driver, int idx,
1870 struct tty_struct **ret_tty)
1872 struct tty_struct *tty, *o_tty;
1873 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1874 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1877 /* check whether we're reopening an existing tty */
1878 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1879 tty = devpts_get_tty(idx);
1880 if (tty && driver->subtype == PTY_TYPE_MASTER)
1883 tty = driver->ttys[idx];
1885 if (tty) goto fast_track;
1888 * First time open is complex, especially for PTY devices.
1889 * This code guarantees that either everything succeeds and the
1890 * TTY is ready for operation, or else the table slots are vacated
1891 * and the allocated memory released. (Except that the termios
1892 * and locked termios may be retained.)
1895 if (!try_module_get(driver->owner)) {
1904 tty = alloc_tty_struct();
1907 initialize_tty_struct(tty);
1908 tty->driver = driver;
1910 tty_line_name(driver, idx, tty->name);
1912 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1913 tp_loc = &tty->termios;
1914 ltp_loc = &tty->termios_locked;
1916 tp_loc = &driver->termios[idx];
1917 ltp_loc = &driver->termios_locked[idx];
1921 tp = (struct termios *) kmalloc(sizeof(struct termios),
1925 *tp = driver->init_termios;
1929 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1933 memset(ltp, 0, sizeof(struct termios));
1936 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1937 o_tty = alloc_tty_struct();
1940 initialize_tty_struct(o_tty);
1941 o_tty->driver = driver->other;
1943 tty_line_name(driver->other, idx, o_tty->name);
1945 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1946 o_tp_loc = &o_tty->termios;
1947 o_ltp_loc = &o_tty->termios_locked;
1949 o_tp_loc = &driver->other->termios[idx];
1950 o_ltp_loc = &driver->other->termios_locked[idx];
1954 o_tp = (struct termios *)
1955 kmalloc(sizeof(struct termios), GFP_KERNEL);
1958 *o_tp = driver->other->init_termios;
1962 o_ltp = (struct termios *)
1963 kmalloc(sizeof(struct termios), GFP_KERNEL);
1966 memset(o_ltp, 0, sizeof(struct termios));
1970 * Everything allocated ... set up the o_tty structure.
1972 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1973 driver->other->ttys[idx] = o_tty;
1979 o_tty->termios = *o_tp_loc;
1980 o_tty->termios_locked = *o_ltp_loc;
1981 driver->other->refcount++;
1982 if (driver->subtype == PTY_TYPE_MASTER)
1985 /* Establish the links in both directions */
1991 * All structures have been allocated, so now we install them.
1992 * Failures after this point use release_mem to clean up, so
1993 * there's no need to null out the local pointers.
1995 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1996 driver->ttys[idx] = tty;
2003 tty->termios = *tp_loc;
2004 tty->termios_locked = *ltp_loc;
2009 * Structures all installed ... call the ldisc open routines.
2010 * If we fail here just call release_mem to clean up. No need
2011 * to decrement the use counts, as release_mem doesn't care.
2014 if (tty->ldisc.open) {
2015 retval = (tty->ldisc.open)(tty);
2017 goto release_mem_out;
2019 if (o_tty && o_tty->ldisc.open) {
2020 retval = (o_tty->ldisc.open)(o_tty);
2022 if (tty->ldisc.close)
2023 (tty->ldisc.close)(tty);
2024 goto release_mem_out;
2026 tty_ldisc_enable(o_tty);
2028 tty_ldisc_enable(tty);
2032 * This fast open can be used if the tty is already open.
2033 * No memory is allocated, and the only failures are from
2034 * attempting to open a closing tty or attempting multiple
2035 * opens on a pty master.
2038 if (test_bit(TTY_CLOSING, &tty->flags)) {
2042 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2043 driver->subtype == PTY_TYPE_MASTER) {
2045 * special case for PTY masters: only one open permitted,
2046 * and the slave side open count is incremented as well.
2055 tty->driver = driver; /* N.B. why do this every time?? */
2058 if(!test_bit(TTY_LDISC, &tty->flags))
2059 printk(KERN_ERR "init_dev but no ldisc\n");
2063 /* All paths come through here to release the mutex */
2067 /* Release locally allocated memory ... nothing placed in slots */
2071 free_tty_struct(o_tty);
2074 free_tty_struct(tty);
2077 module_put(driver->owner);
2081 /* call the tty release_mem routine to clean out this slot */
2083 printk(KERN_INFO "init_dev: ldisc open failed, "
2084 "clearing slot %d\n", idx);
2085 release_mem(tty, idx);
2090 * release_mem - release tty structure memory
2092 * Releases memory associated with a tty structure, and clears out the
2093 * driver table slots. This function is called when a device is no longer
2094 * in use. It also gets called when setup of a device fails.
2097 * tty_mutex - sometimes only
2098 * takes the file list lock internally when working on the list
2099 * of ttys that the driver keeps.
2100 * FIXME: should we require tty_mutex is held here ??
2103 static void release_mem(struct tty_struct *tty, int idx)
2105 struct tty_struct *o_tty;
2107 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2109 if ((o_tty = tty->link) != NULL) {
2111 o_tty->driver->ttys[idx] = NULL;
2112 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2113 tp = o_tty->termios;
2115 o_tty->driver->termios[idx] = NULL;
2118 tp = o_tty->termios_locked;
2120 o_tty->driver->termios_locked[idx] = NULL;
2124 o_tty->driver->refcount--;
2126 list_del_init(&o_tty->tty_files);
2128 free_tty_struct(o_tty);
2132 tty->driver->ttys[idx] = NULL;
2133 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2136 tty->driver->termios[idx] = NULL;
2139 tp = tty->termios_locked;
2141 tty->driver->termios_locked[idx] = NULL;
2146 tty->driver->refcount--;
2148 list_del_init(&tty->tty_files);
2150 module_put(tty->driver->owner);
2151 free_tty_struct(tty);
2155 * Even releasing the tty structures is a tricky business.. We have
2156 * to be very careful that the structures are all released at the
2157 * same time, as interrupts might otherwise get the wrong pointers.
2159 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2160 * lead to double frees or releasing memory still in use.
2162 static void release_dev(struct file * filp)
2164 struct tty_struct *tty, *o_tty;
2165 int pty_master, tty_closing, o_tty_closing, do_sleep;
2169 unsigned long flags;
2171 tty = (struct tty_struct *)filp->private_data;
2172 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2175 check_tty_count(tty, "release_dev");
2177 tty_fasync(-1, filp, 0);
2180 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2181 tty->driver->subtype == PTY_TYPE_MASTER);
2182 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2185 #ifdef TTY_PARANOIA_CHECK
2186 if (idx < 0 || idx >= tty->driver->num) {
2187 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2188 "free (%s)\n", tty->name);
2191 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2192 if (tty != tty->driver->ttys[idx]) {
2193 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2194 "for (%s)\n", idx, tty->name);
2197 if (tty->termios != tty->driver->termios[idx]) {
2198 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2203 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2204 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2205 "termios_locked for (%s)\n",
2212 #ifdef TTY_DEBUG_HANGUP
2213 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2214 tty_name(tty, buf), tty->count);
2217 #ifdef TTY_PARANOIA_CHECK
2218 if (tty->driver->other &&
2219 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2220 if (o_tty != tty->driver->other->ttys[idx]) {
2221 printk(KERN_DEBUG "release_dev: other->table[%d] "
2222 "not o_tty for (%s)\n",
2226 if (o_tty->termios != tty->driver->other->termios[idx]) {
2227 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2228 "not o_termios for (%s)\n",
2232 if (o_tty->termios_locked !=
2233 tty->driver->other->termios_locked[idx]) {
2234 printk(KERN_DEBUG "release_dev: other->termios_locked["
2235 "%d] not o_termios_locked for (%s)\n",
2239 if (o_tty->link != tty) {
2240 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2245 if (tty->driver->close)
2246 tty->driver->close(tty, filp);
2249 * Sanity check: if tty->count is going to zero, there shouldn't be
2250 * any waiters on tty->read_wait or tty->write_wait. We test the
2251 * wait queues and kick everyone out _before_ actually starting to
2252 * close. This ensures that we won't block while releasing the tty
2255 * The test for the o_tty closing is necessary, since the master and
2256 * slave sides may close in any order. If the slave side closes out
2257 * first, its count will be one, since the master side holds an open.
2258 * Thus this test wouldn't be triggered at the time the slave closes,
2261 * Note that it's possible for the tty to be opened again while we're
2262 * flushing out waiters. By recalculating the closing flags before
2263 * each iteration we avoid any problems.
2266 /* Guard against races with tty->count changes elsewhere and
2267 opens on /dev/tty */
2269 mutex_lock(&tty_mutex);
2270 tty_closing = tty->count <= 1;
2271 o_tty_closing = o_tty &&
2272 (o_tty->count <= (pty_master ? 1 : 0));
2276 if (waitqueue_active(&tty->read_wait)) {
2277 wake_up(&tty->read_wait);
2280 if (waitqueue_active(&tty->write_wait)) {
2281 wake_up(&tty->write_wait);
2285 if (o_tty_closing) {
2286 if (waitqueue_active(&o_tty->read_wait)) {
2287 wake_up(&o_tty->read_wait);
2290 if (waitqueue_active(&o_tty->write_wait)) {
2291 wake_up(&o_tty->write_wait);
2298 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2299 "active!\n", tty_name(tty, buf));
2300 mutex_unlock(&tty_mutex);
2305 * The closing flags are now consistent with the open counts on
2306 * both sides, and we've completed the last operation that could
2307 * block, so it's safe to proceed with closing.
2310 if (--o_tty->count < 0) {
2311 printk(KERN_WARNING "release_dev: bad pty slave count "
2313 o_tty->count, tty_name(o_tty, buf));
2317 if (--tty->count < 0) {
2318 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2319 tty->count, tty_name(tty, buf));
2324 * We've decremented tty->count, so we need to remove this file
2325 * descriptor off the tty->tty_files list; this serves two
2327 * - check_tty_count sees the correct number of file descriptors
2328 * associated with this tty.
2329 * - do_tty_hangup no longer sees this file descriptor as
2330 * something that needs to be handled for hangups.
2333 filp->private_data = NULL;
2336 * Perform some housekeeping before deciding whether to return.
2338 * Set the TTY_CLOSING flag if this was the last open. In the
2339 * case of a pty we may have to wait around for the other side
2340 * to close, and TTY_CLOSING makes sure we can't be reopened.
2343 set_bit(TTY_CLOSING, &tty->flags);
2345 set_bit(TTY_CLOSING, &o_tty->flags);
2348 * If _either_ side is closing, make sure there aren't any
2349 * processes that still think tty or o_tty is their controlling
2352 if (tty_closing || o_tty_closing) {
2353 read_lock(&tasklist_lock);
2354 session_clear_tty(tty->session);
2356 session_clear_tty(o_tty->session);
2357 read_unlock(&tasklist_lock);
2360 mutex_unlock(&tty_mutex);
2362 /* check whether both sides are closing ... */
2363 if (!tty_closing || (o_tty && !o_tty_closing))
2366 #ifdef TTY_DEBUG_HANGUP
2367 printk(KERN_DEBUG "freeing tty structure...");
2370 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2371 * kill any delayed work. As this is the final close it does not
2372 * race with the set_ldisc code path.
2374 clear_bit(TTY_LDISC, &tty->flags);
2375 cancel_delayed_work(&tty->buf.work);
2378 * Wait for ->hangup_work and ->buf.work handlers to terminate
2381 flush_scheduled_work();
2384 * Wait for any short term users (we know they are just driver
2385 * side waiters as the file is closing so user count on the file
2388 spin_lock_irqsave(&tty_ldisc_lock, flags);
2389 while(tty->ldisc.refcount)
2391 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2392 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2393 spin_lock_irqsave(&tty_ldisc_lock, flags);
2395 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2397 * Shutdown the current line discipline, and reset it to N_TTY.
2398 * N.B. why reset ldisc when we're releasing the memory??
2400 * FIXME: this MUST get fixed for the new reflocking
2402 if (tty->ldisc.close)
2403 (tty->ldisc.close)(tty);
2404 tty_ldisc_put(tty->ldisc.num);
2407 * Switch the line discipline back
2409 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2410 tty_set_termios_ldisc(tty,N_TTY);
2412 /* FIXME: could o_tty be in setldisc here ? */
2413 clear_bit(TTY_LDISC, &o_tty->flags);
2414 if (o_tty->ldisc.close)
2415 (o_tty->ldisc.close)(o_tty);
2416 tty_ldisc_put(o_tty->ldisc.num);
2417 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2418 tty_set_termios_ldisc(o_tty,N_TTY);
2421 * The release_mem function takes care of the details of clearing
2422 * the slots and preserving the termios structure.
2424 release_mem(tty, idx);
2426 #ifdef CONFIG_UNIX98_PTYS
2427 /* Make this pty number available for reallocation */
2429 down(&allocated_ptys_lock);
2430 idr_remove(&allocated_ptys, idx);
2431 up(&allocated_ptys_lock);
2438 * tty_open - open a tty device
2439 * @inode: inode of device file
2440 * @filp: file pointer to tty
2442 * tty_open and tty_release keep up the tty count that contains the
2443 * number of opens done on a tty. We cannot use the inode-count, as
2444 * different inodes might point to the same tty.
2446 * Open-counting is needed for pty masters, as well as for keeping
2447 * track of serial lines: DTR is dropped when the last close happens.
2448 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2450 * The termios state of a pty is reset on first open so that
2451 * settings don't persist across reuse.
2453 * Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2454 * tty->count should protect the rest.
2455 * ->siglock protects ->signal/->sighand
2458 static int tty_open(struct inode * inode, struct file * filp)
2460 struct tty_struct *tty;
2462 struct tty_driver *driver;
2464 dev_t device = inode->i_rdev;
2465 unsigned short saved_flags = filp->f_flags;
2467 nonseekable_open(inode, filp);
2470 noctty = filp->f_flags & O_NOCTTY;
2474 mutex_lock(&tty_mutex);
2476 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2477 tty = get_current_tty();
2479 mutex_unlock(&tty_mutex);
2482 driver = tty->driver;
2484 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2489 if (device == MKDEV(TTY_MAJOR,0)) {
2490 extern struct tty_driver *console_driver;
2491 driver = console_driver;
2497 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2498 driver = console_device(&index);
2500 /* Don't let /dev/console block */
2501 filp->f_flags |= O_NONBLOCK;
2505 mutex_unlock(&tty_mutex);
2509 driver = get_tty_driver(device, &index);
2511 mutex_unlock(&tty_mutex);
2515 retval = init_dev(driver, index, &tty);
2516 mutex_unlock(&tty_mutex);
2520 filp->private_data = tty;
2521 file_move(filp, &tty->tty_files);
2522 check_tty_count(tty, "tty_open");
2523 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2524 tty->driver->subtype == PTY_TYPE_MASTER)
2526 #ifdef TTY_DEBUG_HANGUP
2527 printk(KERN_DEBUG "opening %s...", tty->name);
2530 if (tty->driver->open)
2531 retval = tty->driver->open(tty, filp);
2535 filp->f_flags = saved_flags;
2537 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2541 #ifdef TTY_DEBUG_HANGUP
2542 printk(KERN_DEBUG "error %d in opening %s...", retval,
2546 if (retval != -ERESTARTSYS)
2548 if (signal_pending(current))
2552 * Need to reset f_op in case a hangup happened.
2554 if (filp->f_op == &hung_up_tty_fops)
2555 filp->f_op = &tty_fops;
2559 mutex_lock(&tty_mutex);
2560 spin_lock_irq(¤t->sighand->siglock);
2562 current->signal->leader &&
2563 !current->signal->tty &&
2565 __proc_set_tty(current, tty);
2566 spin_unlock_irq(¤t->sighand->siglock);
2567 mutex_unlock(&tty_mutex);
2571 #ifdef CONFIG_UNIX98_PTYS
2573 * ptmx_open - open a unix 98 pty master
2574 * @inode: inode of device file
2575 * @filp: file pointer to tty
2577 * Allocate a unix98 pty master device from the ptmx driver.
2579 * Locking: tty_mutex protects theinit_dev work. tty->count should
2581 * allocated_ptys_lock handles the list of free pty numbers
2584 static int ptmx_open(struct inode * inode, struct file * filp)
2586 struct tty_struct *tty;
2591 nonseekable_open(inode, filp);
2593 /* find a device that is not in use. */
2594 down(&allocated_ptys_lock);
2595 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2596 up(&allocated_ptys_lock);
2599 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2601 up(&allocated_ptys_lock);
2602 if (idr_ret == -EAGAIN)
2606 if (index >= pty_limit) {
2607 idr_remove(&allocated_ptys, index);
2608 up(&allocated_ptys_lock);
2611 up(&allocated_ptys_lock);
2613 mutex_lock(&tty_mutex);
2614 retval = init_dev(ptm_driver, index, &tty);
2615 mutex_unlock(&tty_mutex);
2620 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2621 filp->private_data = tty;
2622 file_move(filp, &tty->tty_files);
2625 if (devpts_pty_new(tty->link))
2628 check_tty_count(tty, "tty_open");
2629 retval = ptm_driver->open(tty, filp);
2636 down(&allocated_ptys_lock);
2637 idr_remove(&allocated_ptys, index);
2638 up(&allocated_ptys_lock);
2644 * tty_release - vfs callback for close
2645 * @inode: inode of tty
2646 * @filp: file pointer for handle to tty
2648 * Called the last time each file handle is closed that references
2649 * this tty. There may however be several such references.
2652 * Takes bkl. See release_dev
2655 static int tty_release(struct inode * inode, struct file * filp)
2664 * tty_poll - check tty status
2665 * @filp: file being polled
2666 * @wait: poll wait structures to update
2668 * Call the line discipline polling method to obtain the poll
2669 * status of the device.
2671 * Locking: locks called line discipline but ldisc poll method
2672 * may be re-entered freely by other callers.
2675 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2677 struct tty_struct * tty;
2678 struct tty_ldisc *ld;
2681 tty = (struct tty_struct *)filp->private_data;
2682 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2685 ld = tty_ldisc_ref_wait(tty);
2687 ret = (ld->poll)(tty, filp, wait);
2688 tty_ldisc_deref(ld);
2692 static int tty_fasync(int fd, struct file * filp, int on)
2694 struct tty_struct * tty;
2697 tty = (struct tty_struct *)filp->private_data;
2698 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2701 retval = fasync_helper(fd, filp, on, &tty->fasync);
2706 if (!waitqueue_active(&tty->read_wait))
2707 tty->minimum_to_wake = 1;
2708 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2712 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2713 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2719 * tiocsti - fake input character
2720 * @tty: tty to fake input into
2721 * @p: pointer to character
2723 * Fake input to a tty device. Does the neccessary locking and
2726 * FIXME: does not honour flow control ??
2729 * Called functions take tty_ldisc_lock
2730 * current->signal->tty check is safe without locks
2732 * FIXME: may race normal receive processing
2735 static int tiocsti(struct tty_struct *tty, char __user *p)
2738 struct tty_ldisc *ld;
2740 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2742 if (get_user(ch, p))
2744 ld = tty_ldisc_ref_wait(tty);
2745 ld->receive_buf(tty, &ch, &mbz, 1);
2746 tty_ldisc_deref(ld);
2751 * tiocgwinsz - implement window query ioctl
2753 * @arg: user buffer for result
2755 * Copies the kernel idea of the window size into the user buffer.
2757 * Locking: tty->termios_mutex is taken to ensure the winsize data
2761 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2765 mutex_lock(&tty->termios_mutex);
2766 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2767 mutex_unlock(&tty->termios_mutex);
2769 return err ? -EFAULT: 0;
2773 * tiocswinsz - implement window size set ioctl
2775 * @arg: user buffer for result
2777 * Copies the user idea of the window size to the kernel. Traditionally
2778 * this is just advisory information but for the Linux console it
2779 * actually has driver level meaning and triggers a VC resize.
2782 * Called function use the console_sem is used to ensure we do
2783 * not try and resize the console twice at once.
2784 * The tty->termios_mutex is used to ensure we don't double
2785 * resize and get confused. Lock order - tty->termios_mutex before
2789 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2790 struct winsize __user * arg)
2792 struct winsize tmp_ws;
2794 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2797 mutex_lock(&tty->termios_mutex);
2798 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2802 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2803 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2805 mutex_unlock(&tty->termios_mutex);
2811 kill_pg(tty->pgrp, SIGWINCH, 1);
2812 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2813 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2814 tty->winsize = tmp_ws;
2815 real_tty->winsize = tmp_ws;
2817 mutex_unlock(&tty->termios_mutex);
2822 * tioccons - allow admin to move logical console
2823 * @file: the file to become console
2825 * Allow the adminstrator to move the redirected console device
2827 * Locking: uses redirect_lock to guard the redirect information
2830 static int tioccons(struct file *file)
2832 if (!capable(CAP_SYS_ADMIN))
2834 if (file->f_op->write == redirected_tty_write) {
2836 spin_lock(&redirect_lock);
2839 spin_unlock(&redirect_lock);
2844 spin_lock(&redirect_lock);
2846 spin_unlock(&redirect_lock);
2851 spin_unlock(&redirect_lock);
2856 * fionbio - non blocking ioctl
2857 * @file: file to set blocking value
2858 * @p: user parameter
2860 * Historical tty interfaces had a blocking control ioctl before
2861 * the generic functionality existed. This piece of history is preserved
2862 * in the expected tty API of posix OS's.
2864 * Locking: none, the open fle handle ensures it won't go away.
2867 static int fionbio(struct file *file, int __user *p)
2871 if (get_user(nonblock, p))
2875 file->f_flags |= O_NONBLOCK;
2877 file->f_flags &= ~O_NONBLOCK;
2882 * tiocsctty - set controlling tty
2883 * @tty: tty structure
2884 * @arg: user argument
2886 * This ioctl is used to manage job control. It permits a session
2887 * leader to set this tty as the controlling tty for the session.
2890 * Takes tty_mutex() to protect tty instance
2891 * Takes tasklist_lock internally to walk sessions
2892 * Takes ->siglock() when updating signal->tty
2895 static int tiocsctty(struct tty_struct *tty, int arg)
2898 if (current->signal->leader &&
2899 (current->signal->session == tty->session))
2902 mutex_lock(&tty_mutex);
2904 * The process must be a session leader and
2905 * not have a controlling tty already.
2907 if (!current->signal->leader || current->signal->tty) {
2912 if (tty->session > 0) {
2914 * This tty is already the controlling
2915 * tty for another session group!
2917 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2921 read_lock(&tasklist_lock);
2922 session_clear_tty(tty->session);
2923 read_unlock(&tasklist_lock);
2929 proc_set_tty(current, tty);
2931 mutex_unlock(&tty_mutex);
2936 * tiocgpgrp - get process group
2937 * @tty: tty passed by user
2938 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2941 * Obtain the process group of the tty. If there is no process group
2944 * Locking: none. Reference to current->signal->tty is safe.
2947 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2951 * (tty == real_tty) is a cheap way of
2952 * testing if the tty is NOT a master pty.
2954 if (tty == real_tty && current->signal->tty != real_tty)
2957 pgrp = vx_map_pid(real_tty->pgrp);
2958 return put_user(pgrp, p);
2962 * tiocspgrp - attempt to set process group
2963 * @tty: tty passed by user
2964 * @real_tty: tty side device matching tty passed by user
2967 * Set the process group of the tty to the session passed. Only
2968 * permitted where the tty session is our session.
2973 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2976 int retval = tty_check_change(real_tty);
2982 if (!current->signal->tty ||
2983 (current->signal->tty != real_tty) ||
2984 (real_tty->session != current->signal->session))
2986 if (get_user(pgrp, p))
2989 pgrp = vx_rmap_pid(pgrp);
2992 if (session_of_pgrp(pgrp) != current->signal->session)
2994 real_tty->pgrp = pgrp;
2999 * tiocgsid - get session id
3000 * @tty: tty passed by user
3001 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3002 * @p: pointer to returned session id
3004 * Obtain the session id of the tty. If there is no session
3007 * Locking: none. Reference to current->signal->tty is safe.
3010 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3013 * (tty == real_tty) is a cheap way of
3014 * testing if the tty is NOT a master pty.
3016 if (tty == real_tty && current->signal->tty != real_tty)
3018 if (real_tty->session <= 0)
3020 return put_user(real_tty->session, p);
3024 * tiocsetd - set line discipline
3026 * @p: pointer to user data
3028 * Set the line discipline according to user request.
3030 * Locking: see tty_set_ldisc, this function is just a helper
3033 static int tiocsetd(struct tty_struct *tty, int __user *p)
3037 if (get_user(ldisc, p))
3039 return tty_set_ldisc(tty, ldisc);
3043 * send_break - performed time break
3044 * @tty: device to break on
3045 * @duration: timeout in mS
3047 * Perform a timed break on hardware that lacks its own driver level
3048 * timed break functionality.
3051 * atomic_write_lock serializes
3055 static int send_break(struct tty_struct *tty, unsigned int duration)
3057 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3059 tty->driver->break_ctl(tty, -1);
3060 if (!signal_pending(current)) {
3061 msleep_interruptible(duration);
3063 tty->driver->break_ctl(tty, 0);
3064 mutex_unlock(&tty->atomic_write_lock);
3065 if (signal_pending(current))
3071 * tiocmget - get modem status
3073 * @file: user file pointer
3074 * @p: pointer to result
3076 * Obtain the modem status bits from the tty driver if the feature
3077 * is supported. Return -EINVAL if it is not available.
3079 * Locking: none (up to the driver)
3082 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3084 int retval = -EINVAL;
3086 if (tty->driver->tiocmget) {
3087 retval = tty->driver->tiocmget(tty, file);
3090 retval = put_user(retval, p);
3096 * tiocmset - set modem status
3098 * @file: user file pointer
3099 * @cmd: command - clear bits, set bits or set all
3100 * @p: pointer to desired bits
3102 * Set the modem status bits from the tty driver if the feature
3103 * is supported. Return -EINVAL if it is not available.
3105 * Locking: none (up to the driver)
3108 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3111 int retval = -EINVAL;
3113 if (tty->driver->tiocmset) {
3114 unsigned int set, clear, val;
3116 retval = get_user(val, p);
3134 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3135 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3137 retval = tty->driver->tiocmset(tty, file, set, clear);
3143 * Split this up, as gcc can choke on it otherwise..
3145 int tty_ioctl(struct inode * inode, struct file * file,
3146 unsigned int cmd, unsigned long arg)
3148 struct tty_struct *tty, *real_tty;
3149 void __user *p = (void __user *)arg;
3151 struct tty_ldisc *ld;
3153 tty = (struct tty_struct *)file->private_data;
3154 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3157 /* CHECKME: is this safe as one end closes ? */
3160 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3161 tty->driver->subtype == PTY_TYPE_MASTER)
3162 real_tty = tty->link;
3165 * Break handling by driver
3167 if (!tty->driver->break_ctl) {
3171 if (tty->driver->ioctl)
3172 return tty->driver->ioctl(tty, file, cmd, arg);
3175 /* These two ioctl's always return success; even if */
3176 /* the driver doesn't support them. */
3179 if (!tty->driver->ioctl)
3181 retval = tty->driver->ioctl(tty, file, cmd, arg);
3182 if (retval == -ENOIOCTLCMD)
3189 * Factor out some common prep work
3197 retval = tty_check_change(tty);
3200 if (cmd != TIOCCBRK) {
3201 tty_wait_until_sent(tty, 0);
3202 if (signal_pending(current))
3210 return tiocsti(tty, p);
3212 return tiocgwinsz(tty, p);
3214 return tiocswinsz(tty, real_tty, p);
3216 return real_tty!=tty ? -EINVAL : tioccons(file);
3218 return fionbio(file, p);
3220 set_bit(TTY_EXCLUSIVE, &tty->flags);
3223 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3226 if (current->signal->tty != tty)
3228 if (current->signal->leader)
3229 disassociate_ctty(0);
3230 proc_clear_tty(current);
3233 return tiocsctty(tty, arg);
3235 return tiocgpgrp(tty, real_tty, p);
3237 return tiocspgrp(tty, real_tty, p);
3239 return tiocgsid(tty, real_tty, p);
3241 /* FIXME: check this is ok */
3242 return put_user(tty->ldisc.num, (int __user *)p);
3244 return tiocsetd(tty, p);
3247 return tioclinux(tty, arg);
3252 case TIOCSBRK: /* Turn break on, unconditionally */
3253 tty->driver->break_ctl(tty, -1);
3256 case TIOCCBRK: /* Turn break off, unconditionally */
3257 tty->driver->break_ctl(tty, 0);
3259 case TCSBRK: /* SVID version: non-zero arg --> no break */
3260 /* non-zero arg means wait for all output data
3261 * to be sent (performed above) but don't send break.
3262 * This is used by the tcdrain() termios function.
3265 return send_break(tty, 250);
3267 case TCSBRKP: /* support for POSIX tcsendbreak() */
3268 return send_break(tty, arg ? arg*100 : 250);
3271 return tty_tiocmget(tty, file, p);
3276 return tty_tiocmset(tty, file, cmd, p);
3278 if (tty->driver->ioctl) {
3279 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3280 if (retval != -ENOIOCTLCMD)
3283 ld = tty_ldisc_ref_wait(tty);
3286 retval = ld->ioctl(tty, file, cmd, arg);
3287 if (retval == -ENOIOCTLCMD)
3290 tty_ldisc_deref(ld);
3296 * This implements the "Secure Attention Key" --- the idea is to
3297 * prevent trojan horses by killing all processes associated with this
3298 * tty when the user hits the "Secure Attention Key". Required for
3299 * super-paranoid applications --- see the Orange Book for more details.
3301 * This code could be nicer; ideally it should send a HUP, wait a few
3302 * seconds, then send a INT, and then a KILL signal. But you then
3303 * have to coordinate with the init process, since all processes associated
3304 * with the current tty must be dead before the new getty is allowed
3307 * Now, if it would be correct ;-/ The current code has a nasty hole -
3308 * it doesn't catch files in flight. We may send the descriptor to ourselves
3309 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3311 * Nasty bug: do_SAK is being called in interrupt context. This can
3312 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3314 static void __do_SAK(void *arg)
3319 struct tty_struct *tty = arg;
3320 struct task_struct *g, *p;
3324 struct tty_ldisc *disc;
3325 struct fdtable *fdt;
3329 session = tty->session;
3331 /* We don't want an ldisc switch during this */
3332 disc = tty_ldisc_ref(tty);
3333 if (disc && disc->flush_buffer)
3334 disc->flush_buffer(tty);
3335 tty_ldisc_deref(disc);
3337 if (tty->driver->flush_buffer)
3338 tty->driver->flush_buffer(tty);
3340 read_lock(&tasklist_lock);
3341 /* Kill the entire session */
3342 do_each_task_pid(session, PIDTYPE_SID, p) {
3343 printk(KERN_NOTICE "SAK: killed process %d"
3344 " (%s): p->signal->session==tty->session\n",
3346 send_sig(SIGKILL, p, 1);
3347 } while_each_task_pid(session, PIDTYPE_SID, p);
3348 /* Now kill any processes that happen to have the
3351 do_each_thread(g, p) {
3352 if (p->signal->tty == tty) {
3353 printk(KERN_NOTICE "SAK: killed process %d"
3354 " (%s): p->signal->session==tty->session\n",
3356 send_sig(SIGKILL, p, 1);
3362 * We don't take a ref to the file, so we must
3363 * hold ->file_lock instead.
3365 spin_lock(&p->files->file_lock);
3366 fdt = files_fdtable(p->files);
3367 for (i=0; i < fdt->max_fds; i++) {
3368 filp = fcheck_files(p->files, i);
3371 if (filp->f_op->read == tty_read &&
3372 filp->private_data == tty) {
3373 printk(KERN_NOTICE "SAK: killed process %d"
3374 " (%s): fd#%d opened to the tty\n",
3375 p->pid, p->comm, i);
3376 force_sig(SIGKILL, p);
3380 spin_unlock(&p->files->file_lock);
3383 } while_each_thread(g, p);
3384 read_unlock(&tasklist_lock);
3389 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3390 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3391 * the values which we write to it will be identical to the values which it
3392 * already has. --akpm
3394 void do_SAK(struct tty_struct *tty)
3398 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
3399 schedule_work(&tty->SAK_work);
3402 EXPORT_SYMBOL(do_SAK);
3406 * @private_: tty structure passed from work queue.
3408 * This routine is called out of the software interrupt to flush data
3409 * from the buffer chain to the line discipline.
3411 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3412 * while invoking the line discipline receive_buf method. The
3413 * receive_buf method is single threaded for each tty instance.
3416 static void flush_to_ldisc(void *private_)
3418 struct tty_struct *tty = (struct tty_struct *) private_;
3419 unsigned long flags;
3420 struct tty_ldisc *disc;
3421 struct tty_buffer *tbuf, *head;
3423 unsigned char *flag_buf;
3425 disc = tty_ldisc_ref(tty);
3426 if (disc == NULL) /* !TTY_LDISC */
3429 spin_lock_irqsave(&tty->buf.lock, flags);
3430 head = tty->buf.head;
3432 tty->buf.head = NULL;
3434 int count = head->commit - head->read;
3436 if (head->next == NULL)
3440 tty_buffer_free(tty, tbuf);
3443 if (!tty->receive_room) {
3444 schedule_delayed_work(&tty->buf.work, 1);
3447 if (count > tty->receive_room)
3448 count = tty->receive_room;
3449 char_buf = head->char_buf_ptr + head->read;
3450 flag_buf = head->flag_buf_ptr + head->read;
3451 head->read += count;
3452 spin_unlock_irqrestore(&tty->buf.lock, flags);
3453 disc->receive_buf(tty, char_buf, flag_buf, count);
3454 spin_lock_irqsave(&tty->buf.lock, flags);
3456 tty->buf.head = head;
3458 spin_unlock_irqrestore(&tty->buf.lock, flags);
3460 tty_ldisc_deref(disc);
3464 * Routine which returns the baud rate of the tty
3466 * Note that the baud_table needs to be kept in sync with the
3467 * include/asm/termbits.h file.
3469 static int baud_table[] = {
3470 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3471 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3473 76800, 153600, 307200, 614400, 921600
3475 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3476 2500000, 3000000, 3500000, 4000000
3480 static int n_baud_table = ARRAY_SIZE(baud_table);
3483 * tty_termios_baud_rate
3484 * @termios: termios structure
3486 * Convert termios baud rate data into a speed. This should be called
3487 * with the termios lock held if this termios is a terminal termios
3488 * structure. May change the termios data.
3493 int tty_termios_baud_rate(struct termios *termios)
3497 cbaud = termios->c_cflag & CBAUD;
3499 if (cbaud & CBAUDEX) {
3502 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3503 termios->c_cflag &= ~CBAUDEX;
3507 return baud_table[cbaud];
3510 EXPORT_SYMBOL(tty_termios_baud_rate);
3513 * tty_get_baud_rate - get tty bit rates
3514 * @tty: tty to query
3516 * Returns the baud rate as an integer for this terminal. The
3517 * termios lock must be held by the caller and the terminal bit
3518 * flags may be updated.
3523 int tty_get_baud_rate(struct tty_struct *tty)
3525 int baud = tty_termios_baud_rate(tty->termios);
3527 if (baud == 38400 && tty->alt_speed) {
3529 printk(KERN_WARNING "Use of setserial/setrocket to "
3530 "set SPD_* flags is deprecated\n");
3533 baud = tty->alt_speed;
3539 EXPORT_SYMBOL(tty_get_baud_rate);
3542 * tty_flip_buffer_push - terminal
3545 * Queue a push of the terminal flip buffers to the line discipline. This
3546 * function must not be called from IRQ context if tty->low_latency is set.
3548 * In the event of the queue being busy for flipping the work will be
3549 * held off and retried later.
3551 * Locking: tty buffer lock. Driver locks in low latency mode.
3554 void tty_flip_buffer_push(struct tty_struct *tty)
3556 unsigned long flags;
3557 spin_lock_irqsave(&tty->buf.lock, flags);
3558 if (tty->buf.tail != NULL)
3559 tty->buf.tail->commit = tty->buf.tail->used;
3560 spin_unlock_irqrestore(&tty->buf.lock, flags);
3562 if (tty->low_latency)
3563 flush_to_ldisc((void *) tty);
3565 schedule_delayed_work(&tty->buf.work, 1);
3568 EXPORT_SYMBOL(tty_flip_buffer_push);
3572 * initialize_tty_struct
3573 * @tty: tty to initialize
3575 * This subroutine initializes a tty structure that has been newly
3578 * Locking: none - tty in question must not be exposed at this point
3581 static void initialize_tty_struct(struct tty_struct *tty)
3583 memset(tty, 0, sizeof(struct tty_struct));
3584 tty->magic = TTY_MAGIC;
3585 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3587 tty->overrun_time = jiffies;
3588 tty->buf.head = tty->buf.tail = NULL;
3589 tty_buffer_init(tty);
3590 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
3591 init_MUTEX(&tty->buf.pty_sem);
3592 mutex_init(&tty->termios_mutex);
3593 init_waitqueue_head(&tty->write_wait);
3594 init_waitqueue_head(&tty->read_wait);
3595 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
3596 mutex_init(&tty->atomic_read_lock);
3597 mutex_init(&tty->atomic_write_lock);
3598 spin_lock_init(&tty->read_lock);
3599 INIT_LIST_HEAD(&tty->tty_files);
3600 INIT_WORK(&tty->SAK_work, NULL, NULL);
3604 * The default put_char routine if the driver did not define one.
3607 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3609 tty->driver->write(tty, &ch, 1);
3612 static struct class *tty_class;
3615 * tty_register_device - register a tty device
3616 * @driver: the tty driver that describes the tty device
3617 * @index: the index in the tty driver for this tty device
3618 * @device: a struct device that is associated with this tty device.
3619 * This field is optional, if there is no known struct device
3620 * for this tty device it can be set to NULL safely.
3622 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
3624 * This call is required to be made to register an individual tty device
3625 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3626 * that bit is not set, this function should not be called by a tty
3632 struct class_device *tty_register_device(struct tty_driver *driver,
3633 unsigned index, struct device *device)
3636 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3638 if (index >= driver->num) {
3639 printk(KERN_ERR "Attempt to register invalid tty line number "
3641 return ERR_PTR(-EINVAL);
3644 if (driver->type == TTY_DRIVER_TYPE_PTY)
3645 pty_line_name(driver, index, name);
3647 tty_line_name(driver, index, name);
3649 return class_device_create(tty_class, NULL, dev, device, "%s", name);
3653 * tty_unregister_device - unregister a tty device
3654 * @driver: the tty driver that describes the tty device
3655 * @index: the index in the tty driver for this tty device
3657 * If a tty device is registered with a call to tty_register_device() then
3658 * this function must be called when the tty device is gone.
3663 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3665 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3668 EXPORT_SYMBOL(tty_register_device);
3669 EXPORT_SYMBOL(tty_unregister_device);
3671 struct tty_driver *alloc_tty_driver(int lines)
3673 struct tty_driver *driver;
3675 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3677 memset(driver, 0, sizeof(struct tty_driver));
3678 driver->magic = TTY_DRIVER_MAGIC;
3679 driver->num = lines;
3680 /* later we'll move allocation of tables here */
3685 void put_tty_driver(struct tty_driver *driver)
3690 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3692 driver->open = op->open;
3693 driver->close = op->close;
3694 driver->write = op->write;
3695 driver->put_char = op->put_char;
3696 driver->flush_chars = op->flush_chars;
3697 driver->write_room = op->write_room;
3698 driver->chars_in_buffer = op->chars_in_buffer;
3699 driver->ioctl = op->ioctl;
3700 driver->set_termios = op->set_termios;
3701 driver->throttle = op->throttle;
3702 driver->unthrottle = op->unthrottle;
3703 driver->stop = op->stop;
3704 driver->start = op->start;
3705 driver->hangup = op->hangup;
3706 driver->break_ctl = op->break_ctl;
3707 driver->flush_buffer = op->flush_buffer;
3708 driver->set_ldisc = op->set_ldisc;
3709 driver->wait_until_sent = op->wait_until_sent;
3710 driver->send_xchar = op->send_xchar;
3711 driver->read_proc = op->read_proc;
3712 driver->write_proc = op->write_proc;
3713 driver->tiocmget = op->tiocmget;
3714 driver->tiocmset = op->tiocmset;
3718 EXPORT_SYMBOL(alloc_tty_driver);
3719 EXPORT_SYMBOL(put_tty_driver);
3720 EXPORT_SYMBOL(tty_set_operations);
3723 * Called by a tty driver to register itself.
3725 int tty_register_driver(struct tty_driver *driver)
3732 if (driver->flags & TTY_DRIVER_INSTALLED)
3735 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3736 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3739 memset(p, 0, driver->num * 3 * sizeof(void *));
3742 if (!driver->major) {
3743 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3744 (char*)driver->name);
3746 driver->major = MAJOR(dev);
3747 driver->minor_start = MINOR(dev);
3750 dev = MKDEV(driver->major, driver->minor_start);
3751 error = register_chrdev_region(dev, driver->num,
3752 (char*)driver->name);
3760 driver->ttys = (struct tty_struct **)p;
3761 driver->termios = (struct termios **)(p + driver->num);
3762 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3764 driver->ttys = NULL;
3765 driver->termios = NULL;
3766 driver->termios_locked = NULL;
3769 cdev_init(&driver->cdev, &tty_fops);
3770 driver->cdev.owner = driver->owner;
3771 error = cdev_add(&driver->cdev, dev, driver->num);
3773 unregister_chrdev_region(dev, driver->num);
3774 driver->ttys = NULL;
3775 driver->termios = driver->termios_locked = NULL;
3780 if (!driver->put_char)
3781 driver->put_char = tty_default_put_char;
3783 list_add(&driver->tty_drivers, &tty_drivers);
3785 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3786 for(i = 0; i < driver->num; i++)
3787 tty_register_device(driver, i, NULL);
3789 proc_tty_register_driver(driver);
3793 EXPORT_SYMBOL(tty_register_driver);
3796 * Called by a tty driver to unregister itself.
3798 int tty_unregister_driver(struct tty_driver *driver)
3804 if (driver->refcount)
3807 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3810 list_del(&driver->tty_drivers);
3813 * Free the termios and termios_locked structures because
3814 * we don't want to get memory leaks when modular tty
3815 * drivers are removed from the kernel.
3817 for (i = 0; i < driver->num; i++) {
3818 tp = driver->termios[i];
3820 driver->termios[i] = NULL;
3823 tp = driver->termios_locked[i];
3825 driver->termios_locked[i] = NULL;
3828 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3829 tty_unregister_device(driver, i);
3832 proc_tty_unregister_driver(driver);
3833 driver->ttys = NULL;
3834 driver->termios = driver->termios_locked = NULL;
3836 cdev_del(&driver->cdev);
3840 EXPORT_SYMBOL(tty_unregister_driver);
3844 * Initialize the console device. This is called *early*, so
3845 * we can't necessarily depend on lots of kernel help here.
3846 * Just do some early initializations, and do the complex setup
3849 void __init console_init(void)
3853 /* Setup the default TTY line discipline. */
3854 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3857 * set up the console device so that later boot sequences can
3858 * inform about problems etc..
3860 #ifdef CONFIG_EARLY_PRINTK
3861 disable_early_printk();
3863 call = __con_initcall_start;
3864 while (call < __con_initcall_end) {
3871 extern int vty_init(void);
3874 static int __init tty_class_init(void)
3876 tty_class = class_create(THIS_MODULE, "tty");
3877 if (IS_ERR(tty_class))
3878 return PTR_ERR(tty_class);
3882 postcore_initcall(tty_class_init);
3884 /* 3/2004 jmc: why do these devices exist? */
3886 static struct cdev tty_cdev, console_cdev;
3887 #ifdef CONFIG_UNIX98_PTYS
3888 static struct cdev ptmx_cdev;
3891 static struct cdev vc0_cdev;
3895 * Ok, now we can initialize the rest of the tty devices and can count
3896 * on memory allocations, interrupts etc..
3898 static int __init tty_init(void)
3900 cdev_init(&tty_cdev, &tty_fops);
3901 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3902 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3903 panic("Couldn't register /dev/tty driver\n");
3904 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3906 cdev_init(&console_cdev, &console_fops);
3907 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3908 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3909 panic("Couldn't register /dev/console driver\n");
3910 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3912 #ifdef CONFIG_UNIX98_PTYS
3913 cdev_init(&ptmx_cdev, &ptmx_fops);
3914 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3915 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3916 panic("Couldn't register /dev/ptmx driver\n");
3917 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3921 cdev_init(&vc0_cdev, &console_fops);
3922 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3923 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3924 panic("Couldn't register /dev/tty0 driver\n");
3925 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3932 module_init(tty_init);