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 termios 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,
121 EXPORT_SYMBOL(tty_std_termios);
123 /* This list gets poked at by procfs and various bits of boot up code. This
124 could do with some rationalisation such as pulling the tty proc function
127 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
129 /* Semaphore to protect creating and releasing a tty. This is shared with
130 vt.c for deeply disgusting hack reasons */
131 DEFINE_MUTEX(tty_mutex);
133 #ifdef CONFIG_UNIX98_PTYS
134 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
135 extern int pty_limit; /* Config limit on Unix98 ptys */
136 static DEFINE_IDR(allocated_ptys);
137 static DECLARE_MUTEX(allocated_ptys_lock);
138 static int ptmx_open(struct inode *, struct file *);
141 extern void disable_early_printk(void);
143 static void initialize_tty_struct(struct tty_struct *tty);
145 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
146 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
147 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
148 static unsigned int tty_poll(struct file *, poll_table *);
149 static int tty_open(struct inode *, struct file *);
150 static int tty_release(struct inode *, struct file *);
151 int tty_ioctl(struct inode * inode, struct file * file,
152 unsigned int cmd, unsigned long arg);
153 static int tty_fasync(int fd, struct file * filp, int on);
154 static void release_mem(struct tty_struct *tty, int idx);
157 * alloc_tty_struct - allocate a tty object
159 * Return a new empty tty structure. The data fields have not
160 * been initialized in any way but has been zeroed
165 static struct tty_struct *alloc_tty_struct(void)
167 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
170 static void tty_buffer_free_all(struct tty_struct *);
173 * free_tty_struct - free a disused tty
174 * @tty: tty struct to free
176 * Free the write buffers, tty queue and tty memory itself.
178 * Locking: none. Must be called after tty is definitely unused
181 static inline void free_tty_struct(struct tty_struct *tty)
183 kfree(tty->write_buf);
184 tty_buffer_free_all(tty);
188 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
191 * tty_name - return tty naming
192 * @tty: tty structure
193 * @buf: buffer for output
195 * Convert a tty structure into a name. The name reflects the kernel
196 * naming policy and if udev is in use may not reflect user space
201 char *tty_name(struct tty_struct *tty, char *buf)
203 if (!tty) /* Hmm. NULL pointer. That's fun. */
204 strcpy(buf, "NULL tty");
206 strcpy(buf, tty->name);
210 EXPORT_SYMBOL(tty_name);
212 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
215 #ifdef TTY_PARANOIA_CHECK
218 "null TTY for (%d:%d) in %s\n",
219 imajor(inode), iminor(inode), routine);
222 if (tty->magic != TTY_MAGIC) {
224 "bad magic number for tty struct (%d:%d) in %s\n",
225 imajor(inode), iminor(inode), routine);
232 static int check_tty_count(struct tty_struct *tty, const char *routine)
234 #ifdef CHECK_TTY_COUNT
239 list_for_each(p, &tty->tty_files) {
243 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
244 tty->driver->subtype == PTY_TYPE_SLAVE &&
245 tty->link && tty->link->count)
247 if (tty->count != count) {
248 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
249 "!= #fd's(%d) in %s\n",
250 tty->name, tty->count, count, routine);
258 * Tty buffer allocation management
263 * tty_buffer_free_all - free buffers used by a tty
264 * @tty: tty to free from
266 * Remove all the buffers pending on a tty whether queued with data
267 * or in the free ring. Must be called when the tty is no longer in use
274 * tty_buffer_free_all - free buffers used by a tty
275 * @tty: tty to free from
277 * Remove all the buffers pending on a tty whether queued with data
278 * or in the free ring. Must be called when the tty is no longer in use
283 static void tty_buffer_free_all(struct tty_struct *tty)
285 struct tty_buffer *thead;
286 while((thead = tty->buf.head) != NULL) {
287 tty->buf.head = thead->next;
290 while((thead = tty->buf.free) != NULL) {
291 tty->buf.free = thead->next;
294 tty->buf.tail = NULL;
295 tty->buf.memory_used = 0;
299 * tty_buffer_init - prepare a tty buffer structure
300 * @tty: tty to initialise
302 * Set up the initial state of the buffer management for a tty device.
303 * Must be called before the other tty buffer functions are used.
308 static void tty_buffer_init(struct tty_struct *tty)
310 spin_lock_init(&tty->buf.lock);
311 tty->buf.head = NULL;
312 tty->buf.tail = NULL;
313 tty->buf.free = NULL;
314 tty->buf.memory_used = 0;
318 * tty_buffer_alloc - allocate a tty buffer
320 * @size: desired size (characters)
322 * Allocate a new tty buffer to hold the desired number of characters.
323 * Return NULL if out of memory or the allocation would exceed the
326 * Locking: Caller must hold tty->buf.lock
329 static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
331 struct tty_buffer *p;
333 if (tty->buf.memory_used + size > 65536)
335 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
343 p->char_buf_ptr = (char *)(p->data);
344 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
345 tty->buf.memory_used += size;
350 * tty_buffer_free - free a tty buffer
351 * @tty: tty owning the buffer
352 * @b: the buffer to free
354 * Free a tty buffer, or add it to the free list according to our
357 * Locking: Caller must hold tty->buf.lock
360 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
362 /* Dumb strategy for now - should keep some stats */
363 tty->buf.memory_used -= b->size;
364 WARN_ON(tty->buf.memory_used < 0);
369 b->next = tty->buf.free;
375 * tty_buffer_find - find a free tty buffer
376 * @tty: tty owning the buffer
377 * @size: characters wanted
379 * Locate an existing suitable tty buffer or if we are lacking one then
380 * allocate a new one. We round our buffers off in 256 character chunks
381 * to get better allocation behaviour.
383 * Locking: Caller must hold tty->buf.lock
386 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
388 struct tty_buffer **tbh = &tty->buf.free;
389 while((*tbh) != NULL) {
390 struct tty_buffer *t = *tbh;
391 if(t->size >= size) {
397 tty->buf.memory_used += t->size;
400 tbh = &((*tbh)->next);
402 /* Round the buffer size out */
403 size = (size + 0xFF) & ~ 0xFF;
404 return tty_buffer_alloc(tty, size);
405 /* Should possibly check if this fails for the largest buffer we
406 have queued and recycle that ? */
410 * tty_buffer_request_room - grow tty buffer if needed
411 * @tty: tty structure
412 * @size: size desired
414 * Make at least size bytes of linear space available for the tty
415 * buffer. If we fail return the size we managed to find.
417 * Locking: Takes tty->buf.lock
419 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
421 struct tty_buffer *b, *n;
425 spin_lock_irqsave(&tty->buf.lock, flags);
427 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
428 remove this conditional if its worth it. This would be invisible
430 if ((b = tty->buf.tail) != NULL)
431 left = b->size - b->used;
436 /* This is the slow path - looking for new buffers to use */
437 if ((n = tty_buffer_find(tty, size)) != NULL) {
448 spin_unlock_irqrestore(&tty->buf.lock, flags);
451 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
454 * tty_insert_flip_string - Add characters to the tty buffer
455 * @tty: tty structure
459 * Queue a series of bytes to the tty buffering. All the characters
460 * passed are marked as without error. Returns the number added.
462 * Locking: Called functions may take tty->buf.lock
465 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
470 int space = tty_buffer_request_room(tty, size - copied);
471 struct tty_buffer *tb = tty->buf.tail;
472 /* If there is no space then tb may be NULL */
473 if(unlikely(space == 0))
475 memcpy(tb->char_buf_ptr + tb->used, chars, space);
476 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
480 /* There is a small chance that we need to split the data over
481 several buffers. If this is the case we must loop */
482 } while (unlikely(size > copied));
485 EXPORT_SYMBOL(tty_insert_flip_string);
488 * tty_insert_flip_string_flags - Add characters to the tty buffer
489 * @tty: tty structure
494 * Queue a series of bytes to the tty buffering. For each character
495 * the flags array indicates the status of the character. Returns the
498 * Locking: Called functions may take tty->buf.lock
501 int tty_insert_flip_string_flags(struct tty_struct *tty,
502 const unsigned char *chars, const char *flags, size_t size)
506 int space = tty_buffer_request_room(tty, size - copied);
507 struct tty_buffer *tb = tty->buf.tail;
508 /* If there is no space then tb may be NULL */
509 if(unlikely(space == 0))
511 memcpy(tb->char_buf_ptr + tb->used, chars, space);
512 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
517 /* There is a small chance that we need to split the data over
518 several buffers. If this is the case we must loop */
519 } while (unlikely(size > copied));
522 EXPORT_SYMBOL(tty_insert_flip_string_flags);
525 * tty_schedule_flip - push characters to ldisc
526 * @tty: tty to push from
528 * Takes any pending buffers and transfers their ownership to the
529 * ldisc side of the queue. It then schedules those characters for
530 * processing by the line discipline.
532 * Locking: Takes tty->buf.lock
535 void tty_schedule_flip(struct tty_struct *tty)
538 spin_lock_irqsave(&tty->buf.lock, flags);
539 if (tty->buf.tail != NULL)
540 tty->buf.tail->commit = tty->buf.tail->used;
541 spin_unlock_irqrestore(&tty->buf.lock, flags);
542 schedule_delayed_work(&tty->buf.work, 1);
544 EXPORT_SYMBOL(tty_schedule_flip);
547 * tty_prepare_flip_string - make room for characters
549 * @chars: return pointer for character write area
550 * @size: desired size
552 * Prepare a block of space in the buffer for data. Returns the length
553 * available and buffer pointer to the space which is now allocated and
554 * accounted for as ready for normal characters. This is used for drivers
555 * that need their own block copy routines into the buffer. There is no
556 * guarantee the buffer is a DMA target!
558 * Locking: May call functions taking tty->buf.lock
561 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
563 int space = tty_buffer_request_room(tty, size);
565 struct tty_buffer *tb = tty->buf.tail;
566 *chars = tb->char_buf_ptr + tb->used;
567 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
573 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
576 * tty_prepare_flip_string_flags - make room for characters
578 * @chars: return pointer for character write area
579 * @flags: return pointer for status flag write area
580 * @size: desired size
582 * Prepare a block of space in the buffer for data. Returns the length
583 * available and buffer pointer to the space which is now allocated and
584 * accounted for as ready for characters. This is used for drivers
585 * that need their own block copy routines into the buffer. There is no
586 * guarantee the buffer is a DMA target!
588 * Locking: May call functions taking tty->buf.lock
591 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
593 int space = tty_buffer_request_room(tty, size);
595 struct tty_buffer *tb = tty->buf.tail;
596 *chars = tb->char_buf_ptr + tb->used;
597 *flags = tb->flag_buf_ptr + tb->used;
603 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
608 * tty_set_termios_ldisc - set ldisc field
609 * @tty: tty structure
610 * @num: line discipline number
612 * This is probably overkill for real world processors but
613 * they are not on hot paths so a little discipline won't do
616 * Locking: takes termios_sem
619 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
621 mutex_lock(&tty->termios_mutex);
622 tty->termios->c_line = num;
623 mutex_unlock(&tty->termios_mutex);
627 * This guards the refcounted line discipline lists. The lock
628 * must be taken with irqs off because there are hangup path
629 * callers who will do ldisc lookups and cannot sleep.
632 static DEFINE_SPINLOCK(tty_ldisc_lock);
633 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
634 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
637 * tty_register_ldisc - install a line discipline
638 * @disc: ldisc number
639 * @new_ldisc: pointer to the ldisc object
641 * Installs a new line discipline into the kernel. The discipline
642 * is set up as unreferenced and then made available to the kernel
643 * from this point onwards.
646 * takes tty_ldisc_lock to guard against ldisc races
649 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
654 if (disc < N_TTY || disc >= NR_LDISCS)
657 spin_lock_irqsave(&tty_ldisc_lock, flags);
658 tty_ldiscs[disc] = *new_ldisc;
659 tty_ldiscs[disc].num = disc;
660 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
661 tty_ldiscs[disc].refcount = 0;
662 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
666 EXPORT_SYMBOL(tty_register_ldisc);
669 * tty_unregister_ldisc - unload a line discipline
670 * @disc: ldisc number
671 * @new_ldisc: pointer to the ldisc object
673 * Remove a line discipline from the kernel providing it is not
677 * takes tty_ldisc_lock to guard against ldisc races
680 int tty_unregister_ldisc(int disc)
685 if (disc < N_TTY || disc >= NR_LDISCS)
688 spin_lock_irqsave(&tty_ldisc_lock, flags);
689 if (tty_ldiscs[disc].refcount)
692 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
693 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
697 EXPORT_SYMBOL(tty_unregister_ldisc);
700 * tty_ldisc_get - take a reference to an ldisc
701 * @disc: ldisc number
703 * Takes a reference to a line discipline. Deals with refcounts and
704 * module locking counts. Returns NULL if the discipline is not available.
705 * Returns a pointer to the discipline and bumps the ref count if it is
709 * takes tty_ldisc_lock to guard against ldisc races
712 struct tty_ldisc *tty_ldisc_get(int disc)
715 struct tty_ldisc *ld;
717 if (disc < N_TTY || disc >= NR_LDISCS)
720 spin_lock_irqsave(&tty_ldisc_lock, flags);
722 ld = &tty_ldiscs[disc];
723 /* Check the entry is defined */
724 if(ld->flags & LDISC_FLAG_DEFINED)
726 /* If the module is being unloaded we can't use it */
727 if (!try_module_get(ld->owner))
734 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
738 EXPORT_SYMBOL_GPL(tty_ldisc_get);
741 * tty_ldisc_put - drop ldisc reference
742 * @disc: ldisc number
744 * Drop a reference to a line discipline. Manage refcounts and
745 * module usage counts
748 * takes tty_ldisc_lock to guard against ldisc races
751 void tty_ldisc_put(int disc)
753 struct tty_ldisc *ld;
756 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
758 spin_lock_irqsave(&tty_ldisc_lock, flags);
759 ld = &tty_ldiscs[disc];
760 BUG_ON(ld->refcount == 0);
762 module_put(ld->owner);
763 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
766 EXPORT_SYMBOL_GPL(tty_ldisc_put);
769 * tty_ldisc_assign - set ldisc on a tty
770 * @tty: tty to assign
771 * @ld: line discipline
773 * Install an instance of a line discipline into a tty structure. The
774 * ldisc must have a reference count above zero to ensure it remains/
775 * The tty instance refcount starts at zero.
778 * Caller must hold references
781 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
784 tty->ldisc.refcount = 0;
788 * tty_ldisc_try - internal helper
791 * Make a single attempt to grab and bump the refcount on
792 * the tty ldisc. Return 0 on failure or 1 on success. This is
793 * used to implement both the waiting and non waiting versions
796 * Locking: takes tty_ldisc_lock
799 static int tty_ldisc_try(struct tty_struct *tty)
802 struct tty_ldisc *ld;
805 spin_lock_irqsave(&tty_ldisc_lock, flags);
807 if(test_bit(TTY_LDISC, &tty->flags))
812 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
817 * tty_ldisc_ref_wait - wait for the tty ldisc
820 * Dereference the line discipline for the terminal and take a
821 * reference to it. If the line discipline is in flux then
822 * wait patiently until it changes.
824 * Note: Must not be called from an IRQ/timer context. The caller
825 * must also be careful not to hold other locks that will deadlock
826 * against a discipline change, such as an existing ldisc reference
827 * (which we check for)
829 * Locking: call functions take tty_ldisc_lock
832 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
834 /* wait_event is a macro */
835 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
836 if(tty->ldisc.refcount == 0)
837 printk(KERN_ERR "tty_ldisc_ref_wait\n");
841 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
844 * tty_ldisc_ref - get the tty ldisc
847 * Dereference the line discipline for the terminal and take a
848 * reference to it. If the line discipline is in flux then
849 * return NULL. Can be called from IRQ and timer functions.
851 * Locking: called functions take tty_ldisc_lock
854 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
856 if(tty_ldisc_try(tty))
861 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
864 * tty_ldisc_deref - free a tty ldisc reference
865 * @ld: reference to free up
867 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
868 * be called in IRQ context.
870 * Locking: takes tty_ldisc_lock
873 void tty_ldisc_deref(struct tty_ldisc *ld)
879 spin_lock_irqsave(&tty_ldisc_lock, flags);
880 if(ld->refcount == 0)
881 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
884 if(ld->refcount == 0)
885 wake_up(&tty_ldisc_wait);
886 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
889 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
892 * tty_ldisc_enable - allow ldisc use
893 * @tty: terminal to activate ldisc on
895 * Set the TTY_LDISC flag when the line discipline can be called
896 * again. Do neccessary wakeups for existing sleepers.
898 * Note: nobody should set this bit except via this function. Clearing
899 * directly is allowed.
902 static void tty_ldisc_enable(struct tty_struct *tty)
904 set_bit(TTY_LDISC, &tty->flags);
905 wake_up(&tty_ldisc_wait);
909 * tty_set_ldisc - set line discipline
910 * @tty: the terminal to set
911 * @ldisc: the line discipline
913 * Set the discipline of a tty line. Must be called from a process
916 * Locking: takes tty_ldisc_lock.
917 * called functions take termios_sem
920 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
923 struct tty_ldisc o_ldisc;
927 struct tty_ldisc *ld;
928 struct tty_struct *o_tty;
930 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
935 ld = tty_ldisc_get(ldisc);
936 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
937 /* Cyrus Durgin <cider@speakeasy.org> */
939 request_module("tty-ldisc-%d", ldisc);
940 ld = tty_ldisc_get(ldisc);
946 * No more input please, we are switching. The new ldisc
947 * will update this value in the ldisc open function
950 tty->receive_room = 0;
953 * Problem: What do we do if this blocks ?
956 tty_wait_until_sent(tty, 0);
958 if (tty->ldisc.num == ldisc) {
959 tty_ldisc_put(ldisc);
963 o_ldisc = tty->ldisc;
967 * Make sure we don't change while someone holds a
968 * reference to the line discipline. The TTY_LDISC bit
969 * prevents anyone taking a reference once it is clear.
970 * We need the lock to avoid racing reference takers.
973 spin_lock_irqsave(&tty_ldisc_lock, flags);
974 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
975 if(tty->ldisc.refcount) {
976 /* Free the new ldisc we grabbed. Must drop the lock
978 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
979 tty_ldisc_put(ldisc);
981 * There are several reasons we may be busy, including
982 * random momentary I/O traffic. We must therefore
983 * retry. We could distinguish between blocking ops
984 * and retries if we made tty_ldisc_wait() smarter. That
985 * is up for discussion.
987 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
991 if(o_tty && o_tty->ldisc.refcount) {
992 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
993 tty_ldisc_put(ldisc);
994 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
1000 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
1002 if (!test_bit(TTY_LDISC, &tty->flags)) {
1003 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1004 tty_ldisc_put(ldisc);
1005 ld = tty_ldisc_ref_wait(tty);
1006 tty_ldisc_deref(ld);
1010 clear_bit(TTY_LDISC, &tty->flags);
1012 clear_bit(TTY_LDISC, &o_tty->flags);
1013 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1016 * From this point on we know nobody has an ldisc
1017 * usage reference, nor can they obtain one until
1018 * we say so later on.
1021 work = cancel_delayed_work(&tty->buf.work);
1023 * Wait for ->hangup_work and ->buf.work handlers to terminate
1026 flush_scheduled_work();
1027 /* Shutdown the current discipline. */
1028 if (tty->ldisc.close)
1029 (tty->ldisc.close)(tty);
1031 /* Now set up the new line discipline. */
1032 tty_ldisc_assign(tty, ld);
1033 tty_set_termios_ldisc(tty, ldisc);
1034 if (tty->ldisc.open)
1035 retval = (tty->ldisc.open)(tty);
1037 tty_ldisc_put(ldisc);
1038 /* There is an outstanding reference here so this is safe */
1039 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1040 tty_set_termios_ldisc(tty, tty->ldisc.num);
1041 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1042 tty_ldisc_put(o_ldisc.num);
1043 /* This driver is always present */
1044 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1045 tty_set_termios_ldisc(tty, N_TTY);
1046 if (tty->ldisc.open) {
1047 int r = tty->ldisc.open(tty);
1050 panic("Couldn't open N_TTY ldisc for "
1052 tty_name(tty, buf), r);
1056 /* At this point we hold a reference to the new ldisc and a
1057 a reference to the old ldisc. If we ended up flipping back
1058 to the existing ldisc we have two references to it */
1060 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1061 tty->driver->set_ldisc(tty);
1063 tty_ldisc_put(o_ldisc.num);
1066 * Allow ldisc referencing to occur as soon as the driver
1067 * ldisc callback completes.
1070 tty_ldisc_enable(tty);
1072 tty_ldisc_enable(o_tty);
1074 /* Restart it in case no characters kick it off. Safe if
1077 schedule_delayed_work(&tty->buf.work, 1);
1082 * get_tty_driver - find device of a tty
1083 * @dev_t: device identifier
1084 * @index: returns the index of the tty
1086 * This routine returns a tty driver structure, given a device number
1087 * and also passes back the index number.
1089 * Locking: caller must hold tty_mutex
1092 static struct tty_driver *get_tty_driver(dev_t device, int *index)
1094 struct tty_driver *p;
1096 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1097 dev_t base = MKDEV(p->major, p->minor_start);
1098 if (device < base || device >= base + p->num)
1100 *index = device - base;
1107 * tty_check_change - check for POSIX terminal changes
1108 * @tty: tty to check
1110 * If we try to write to, or set the state of, a terminal and we're
1111 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1112 * ignored, go ahead and perform the operation. (POSIX 7.2)
1117 int tty_check_change(struct tty_struct * tty)
1119 if (current->signal->tty != tty)
1121 if (tty->pgrp <= 0) {
1122 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1125 if (process_group(current) == tty->pgrp)
1127 if (is_ignored(SIGTTOU))
1129 if (is_orphaned_pgrp(process_group(current)))
1131 (void) kill_pg(process_group(current), SIGTTOU, 1);
1132 return -ERESTARTSYS;
1135 EXPORT_SYMBOL(tty_check_change);
1137 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1138 size_t count, loff_t *ppos)
1143 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1144 size_t count, loff_t *ppos)
1149 /* No kernel lock held - none needed ;) */
1150 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1152 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1155 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1156 unsigned int cmd, unsigned long arg)
1158 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1161 static const struct file_operations tty_fops = {
1162 .llseek = no_llseek,
1168 .release = tty_release,
1169 .fasync = tty_fasync,
1172 #ifdef CONFIG_UNIX98_PTYS
1173 static const struct file_operations ptmx_fops = {
1174 .llseek = no_llseek,
1180 .release = tty_release,
1181 .fasync = tty_fasync,
1185 static const struct file_operations console_fops = {
1186 .llseek = no_llseek,
1188 .write = redirected_tty_write,
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 .ioctl = hung_up_tty_ioctl,
1202 .release = tty_release,
1205 static DEFINE_SPINLOCK(redirect_lock);
1206 static struct file *redirect;
1209 * tty_wakeup - request more data
1212 * Internal and external helper for wakeups of tty. This function
1213 * informs the line discipline if present that the driver is ready
1214 * to receive more output data.
1217 void tty_wakeup(struct tty_struct *tty)
1219 struct tty_ldisc *ld;
1221 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1222 ld = tty_ldisc_ref(tty);
1224 if(ld->write_wakeup)
1225 ld->write_wakeup(tty);
1226 tty_ldisc_deref(ld);
1229 wake_up_interruptible(&tty->write_wait);
1232 EXPORT_SYMBOL_GPL(tty_wakeup);
1235 * tty_ldisc_flush - flush line discipline queue
1238 * Flush the line discipline queue (if any) for this tty. If there
1239 * is no line discipline active this is a no-op.
1242 void tty_ldisc_flush(struct tty_struct *tty)
1244 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1246 if(ld->flush_buffer)
1247 ld->flush_buffer(tty);
1248 tty_ldisc_deref(ld);
1252 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1255 * do_tty_hangup - actual handler for hangup events
1258 * This can be called by the "eventd" kernel thread. That is process
1259 * synchronous but doesn't hold any locks, so we need to make sure we
1260 * have the appropriate locks for what we're doing.
1262 * The hangup event clears any pending redirections onto the hung up
1263 * device. It ensures future writes will error and it does the needed
1264 * line discipline hangup and signal delivery. The tty object itself
1269 * redirect lock for undoing redirection
1270 * file list lock for manipulating list of ttys
1271 * tty_ldisc_lock from called functions
1272 * termios_sem resetting termios data
1273 * tasklist_lock to walk task list for hangup event
1276 static void do_tty_hangup(void *data)
1278 struct tty_struct *tty = (struct tty_struct *) data;
1279 struct file * cons_filp = NULL;
1280 struct file *filp, *f = NULL;
1281 struct task_struct *p;
1282 struct tty_ldisc *ld;
1283 int closecount = 0, n;
1288 /* inuse_filps is protected by the single kernel lock */
1291 spin_lock(&redirect_lock);
1292 if (redirect && redirect->private_data == tty) {
1296 spin_unlock(&redirect_lock);
1298 check_tty_count(tty, "do_tty_hangup");
1300 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1301 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1302 if (filp->f_op->write == redirected_tty_write)
1304 if (filp->f_op->write != tty_write)
1307 tty_fasync(-1, filp, 0); /* can't block */
1308 filp->f_op = &hung_up_tty_fops;
1312 /* FIXME! What are the locking issues here? This may me overdoing things..
1313 * this question is especially important now that we've removed the irqlock. */
1315 ld = tty_ldisc_ref(tty);
1316 if(ld != NULL) /* We may have no line discipline at this point */
1318 if (ld->flush_buffer)
1319 ld->flush_buffer(tty);
1320 if (tty->driver->flush_buffer)
1321 tty->driver->flush_buffer(tty);
1322 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1324 ld->write_wakeup(tty);
1329 /* FIXME: Once we trust the LDISC code better we can wait here for
1330 ldisc completion and fix the driver call race */
1332 wake_up_interruptible(&tty->write_wait);
1333 wake_up_interruptible(&tty->read_wait);
1336 * Shutdown the current line discipline, and reset it to
1339 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1341 mutex_lock(&tty->termios_mutex);
1342 *tty->termios = tty->driver->init_termios;
1343 mutex_unlock(&tty->termios_mutex);
1346 /* Defer ldisc switch */
1347 /* tty_deferred_ldisc_switch(N_TTY);
1349 This should get done automatically when the port closes and
1350 tty_release is called */
1352 read_lock(&tasklist_lock);
1353 if (tty->session > 0) {
1354 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1355 if (p->signal->tty == tty)
1356 p->signal->tty = NULL;
1357 if (!p->signal->leader)
1359 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1360 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1362 p->signal->tty_old_pgrp = tty->pgrp;
1363 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1365 read_unlock(&tasklist_lock);
1370 tty->ctrl_status = 0;
1372 * If one of the devices matches a console pointer, we
1373 * cannot just call hangup() because that will cause
1374 * tty->count and state->count to go out of sync.
1375 * So we just call close() the right number of times.
1378 if (tty->driver->close)
1379 for (n = 0; n < closecount; n++)
1380 tty->driver->close(tty, cons_filp);
1381 } else if (tty->driver->hangup)
1382 (tty->driver->hangup)(tty);
1384 /* We don't want to have driver/ldisc interactions beyond
1385 the ones we did here. The driver layer expects no
1386 calls after ->hangup() from the ldisc side. However we
1387 can't yet guarantee all that */
1389 set_bit(TTY_HUPPED, &tty->flags);
1391 tty_ldisc_enable(tty);
1392 tty_ldisc_deref(ld);
1400 * tty_hangup - trigger a hangup event
1401 * @tty: tty to hangup
1403 * A carrier loss (virtual or otherwise) has occurred on this like
1404 * schedule a hangup sequence to run after this event.
1407 void tty_hangup(struct tty_struct * tty)
1409 #ifdef TTY_DEBUG_HANGUP
1412 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1414 schedule_work(&tty->hangup_work);
1417 EXPORT_SYMBOL(tty_hangup);
1420 * tty_vhangup - process vhangup
1421 * @tty: tty to hangup
1423 * The user has asked via system call for the terminal to be hung up.
1424 * We do this synchronously so that when the syscall returns the process
1425 * is complete. That guarantee is neccessary for security reasons.
1428 void tty_vhangup(struct tty_struct * tty)
1430 #ifdef TTY_DEBUG_HANGUP
1433 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1435 do_tty_hangup((void *) tty);
1437 EXPORT_SYMBOL(tty_vhangup);
1440 * tty_hung_up_p - was tty hung up
1441 * @filp: file pointer of tty
1443 * Return true if the tty has been subject to a vhangup or a carrier
1447 int tty_hung_up_p(struct file * filp)
1449 return (filp->f_op == &hung_up_tty_fops);
1452 EXPORT_SYMBOL(tty_hung_up_p);
1455 * disassociate_ctty - disconnect controlling tty
1456 * @on_exit: true if exiting so need to "hang up" the session
1458 * This function is typically called only by the session leader, when
1459 * it wants to disassociate itself from its controlling tty.
1461 * It performs the following functions:
1462 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1463 * (2) Clears the tty from being controlling the session
1464 * (3) Clears the controlling tty for all processes in the
1467 * The argument on_exit is set to 1 if called when a process is
1468 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1470 * Locking: tty_mutex is taken to protect current->signal->tty
1471 * BKL is taken for hysterical raisins
1472 * Tasklist lock is taken (under tty_mutex) to walk process
1473 * lists for the session.
1476 void disassociate_ctty(int on_exit)
1478 struct tty_struct *tty;
1479 struct task_struct *p;
1484 mutex_lock(&tty_mutex);
1485 tty = current->signal->tty;
1487 tty_pgrp = tty->pgrp;
1488 mutex_unlock(&tty_mutex);
1489 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1492 if (current->signal->tty_old_pgrp) {
1493 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1494 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1496 mutex_unlock(&tty_mutex);
1501 kill_pg(tty_pgrp, SIGHUP, on_exit);
1503 kill_pg(tty_pgrp, SIGCONT, on_exit);
1506 /* Must lock changes to tty_old_pgrp */
1507 mutex_lock(&tty_mutex);
1508 current->signal->tty_old_pgrp = 0;
1512 /* Now clear signal->tty under the lock */
1513 read_lock(&tasklist_lock);
1514 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1515 p->signal->tty = NULL;
1516 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1517 read_unlock(&tasklist_lock);
1518 mutex_unlock(&tty_mutex);
1524 * stop_tty - propogate flow control
1527 * Perform flow control to the driver. For PTY/TTY pairs we
1528 * must also propogate the TIOCKPKT status. May be called
1529 * on an already stopped device and will not re-call the driver
1532 * This functionality is used by both the line disciplines for
1533 * halting incoming flow and by the driver. It may therefore be
1534 * called from any context, may be under the tty atomic_write_lock
1538 * Broken. Relies on BKL which is unsafe here.
1541 void stop_tty(struct tty_struct *tty)
1546 if (tty->link && tty->link->packet) {
1547 tty->ctrl_status &= ~TIOCPKT_START;
1548 tty->ctrl_status |= TIOCPKT_STOP;
1549 wake_up_interruptible(&tty->link->read_wait);
1551 if (tty->driver->stop)
1552 (tty->driver->stop)(tty);
1555 EXPORT_SYMBOL(stop_tty);
1558 * start_tty - propogate flow control
1559 * @tty: tty to start
1561 * Start a tty that has been stopped if at all possible. Perform
1562 * any neccessary wakeups and propogate the TIOCPKT status. If this
1563 * is the tty was previous stopped and is being started then the
1564 * driver start method is invoked and the line discipline woken.
1567 * Broken. Relies on BKL which is unsafe here.
1570 void start_tty(struct tty_struct *tty)
1572 if (!tty->stopped || tty->flow_stopped)
1575 if (tty->link && tty->link->packet) {
1576 tty->ctrl_status &= ~TIOCPKT_STOP;
1577 tty->ctrl_status |= TIOCPKT_START;
1578 wake_up_interruptible(&tty->link->read_wait);
1580 if (tty->driver->start)
1581 (tty->driver->start)(tty);
1583 /* If we have a running line discipline it may need kicking */
1585 wake_up_interruptible(&tty->write_wait);
1588 EXPORT_SYMBOL(start_tty);
1591 * tty_read - read method for tty device files
1592 * @file: pointer to tty file
1594 * @count: size of user buffer
1597 * Perform the read system call function on this terminal device. Checks
1598 * for hung up devices before calling the line discipline method.
1601 * Locks the line discipline internally while needed
1602 * For historical reasons the line discipline read method is
1603 * invoked under the BKL. This will go away in time so do not rely on it
1604 * in new code. Multiple read calls may be outstanding in parallel.
1607 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1611 struct tty_struct * tty;
1612 struct inode *inode;
1613 struct tty_ldisc *ld;
1615 tty = (struct tty_struct *)file->private_data;
1616 inode = file->f_dentry->d_inode;
1617 if (tty_paranoia_check(tty, inode, "tty_read"))
1619 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1622 /* We want to wait for the line discipline to sort out in this
1624 ld = tty_ldisc_ref_wait(tty);
1627 i = (ld->read)(tty,file,buf,count);
1630 tty_ldisc_deref(ld);
1633 inode->i_atime = current_fs_time(inode->i_sb);
1638 * Split writes up in sane blocksizes to avoid
1639 * denial-of-service type attacks
1641 static inline ssize_t do_tty_write(
1642 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1643 struct tty_struct *tty,
1645 const char __user *buf,
1648 ssize_t ret = 0, written = 0;
1651 /* FIXME: O_NDELAY ... */
1652 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1653 return -ERESTARTSYS;
1657 * We chunk up writes into a temporary buffer. This
1658 * simplifies low-level drivers immensely, since they
1659 * don't have locking issues and user mode accesses.
1661 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1664 * The default chunk-size is 2kB, because the NTTY
1665 * layer has problems with bigger chunks. It will
1666 * claim to be able to handle more characters than
1669 * FIXME: This can probably go away now except that 64K chunks
1670 * are too likely to fail unless switched to vmalloc...
1673 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1678 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1679 if (tty->write_cnt < chunk) {
1685 buf = kmalloc(chunk, GFP_KERNEL);
1687 mutex_unlock(&tty->atomic_write_lock);
1690 kfree(tty->write_buf);
1691 tty->write_cnt = chunk;
1692 tty->write_buf = buf;
1695 /* Do the write .. */
1697 size_t size = count;
1701 if (copy_from_user(tty->write_buf, buf, size))
1704 ret = write(tty, file, tty->write_buf, size);
1714 if (signal_pending(current))
1719 struct inode *inode = file->f_dentry->d_inode;
1720 inode->i_mtime = current_fs_time(inode->i_sb);
1723 mutex_unlock(&tty->atomic_write_lock);
1729 * tty_write - write method for tty device file
1730 * @file: tty file pointer
1731 * @buf: user data to write
1732 * @count: bytes to write
1735 * Write data to a tty device via the line discipline.
1738 * Locks the line discipline as required
1739 * Writes to the tty driver are serialized by the atomic_write_lock
1740 * and are then processed in chunks to the device. The line discipline
1741 * write method will not be involked in parallel for each device
1742 * The line discipline write method is called under the big
1743 * kernel lock for historical reasons. New code should not rely on this.
1746 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1749 struct tty_struct * tty;
1750 struct inode *inode = file->f_dentry->d_inode;
1752 struct tty_ldisc *ld;
1754 tty = (struct tty_struct *)file->private_data;
1755 if (tty_paranoia_check(tty, inode, "tty_write"))
1757 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1760 ld = tty_ldisc_ref_wait(tty);
1764 ret = do_tty_write(ld->write, tty, file, buf, count);
1765 tty_ldisc_deref(ld);
1769 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1772 struct file *p = NULL;
1774 spin_lock(&redirect_lock);
1779 spin_unlock(&redirect_lock);
1783 res = vfs_write(p, buf, count, &p->f_pos);
1788 return tty_write(file, buf, count, ppos);
1791 static char ptychar[] = "pqrstuvwxyzabcde";
1794 * pty_line_name - generate name for a pty
1795 * @driver: the tty driver in use
1796 * @index: the minor number
1797 * @p: output buffer of at least 6 bytes
1799 * Generate a name from a driver reference and write it to the output
1804 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1806 int i = index + driver->name_base;
1807 /* ->name is initialized to "ttyp", but "tty" is expected */
1808 sprintf(p, "%s%c%x",
1809 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1810 ptychar[i >> 4 & 0xf], i & 0xf);
1814 * pty_line_name - generate name for a tty
1815 * @driver: the tty driver in use
1816 * @index: the minor number
1817 * @p: output buffer of at least 7 bytes
1819 * Generate a name from a driver reference and write it to the output
1824 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1826 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1830 * init_dev - initialise a tty device
1831 * @driver: tty driver we are opening a device on
1832 * @idx: device index
1833 * @tty: returned tty structure
1835 * Prepare a tty device. This may not be a "new" clean device but
1836 * could also be an active device. The pty drivers require special
1837 * handling because of this.
1840 * The function is called under the tty_mutex, which
1841 * protects us from the tty struct or driver itself going away.
1843 * On exit the tty device has the line discipline attached and
1844 * a reference count of 1. If a pair was created for pty/tty use
1845 * and the other was a pty master then it too has a reference count of 1.
1847 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1848 * failed open. The new code protects the open with a mutex, so it's
1849 * really quite straightforward. The mutex locking can probably be
1850 * relaxed for the (most common) case of reopening a tty.
1853 static int init_dev(struct tty_driver *driver, int idx,
1854 struct tty_struct **ret_tty)
1856 struct tty_struct *tty, *o_tty;
1857 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1858 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1861 /* check whether we're reopening an existing tty */
1862 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1863 tty = devpts_get_tty(idx);
1864 if (tty && driver->subtype == PTY_TYPE_MASTER)
1867 tty = driver->ttys[idx];
1869 if (tty) goto fast_track;
1872 * First time open is complex, especially for PTY devices.
1873 * This code guarantees that either everything succeeds and the
1874 * TTY is ready for operation, or else the table slots are vacated
1875 * and the allocated memory released. (Except that the termios
1876 * and locked termios may be retained.)
1879 if (!try_module_get(driver->owner)) {
1888 tty = alloc_tty_struct();
1891 initialize_tty_struct(tty);
1892 tty->driver = driver;
1894 tty_line_name(driver, idx, tty->name);
1896 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1897 tp_loc = &tty->termios;
1898 ltp_loc = &tty->termios_locked;
1900 tp_loc = &driver->termios[idx];
1901 ltp_loc = &driver->termios_locked[idx];
1905 tp = (struct termios *) kmalloc(sizeof(struct termios),
1909 *tp = driver->init_termios;
1913 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1917 memset(ltp, 0, sizeof(struct termios));
1920 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1921 o_tty = alloc_tty_struct();
1924 initialize_tty_struct(o_tty);
1925 o_tty->driver = driver->other;
1927 tty_line_name(driver->other, idx, o_tty->name);
1929 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1930 o_tp_loc = &o_tty->termios;
1931 o_ltp_loc = &o_tty->termios_locked;
1933 o_tp_loc = &driver->other->termios[idx];
1934 o_ltp_loc = &driver->other->termios_locked[idx];
1938 o_tp = (struct termios *)
1939 kmalloc(sizeof(struct termios), GFP_KERNEL);
1942 *o_tp = driver->other->init_termios;
1946 o_ltp = (struct termios *)
1947 kmalloc(sizeof(struct termios), GFP_KERNEL);
1950 memset(o_ltp, 0, sizeof(struct termios));
1954 * Everything allocated ... set up the o_tty structure.
1956 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1957 driver->other->ttys[idx] = o_tty;
1963 o_tty->termios = *o_tp_loc;
1964 o_tty->termios_locked = *o_ltp_loc;
1965 driver->other->refcount++;
1966 if (driver->subtype == PTY_TYPE_MASTER)
1969 /* Establish the links in both directions */
1975 * All structures have been allocated, so now we install them.
1976 * Failures after this point use release_mem to clean up, so
1977 * there's no need to null out the local pointers.
1979 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1980 driver->ttys[idx] = tty;
1987 tty->termios = *tp_loc;
1988 tty->termios_locked = *ltp_loc;
1993 * Structures all installed ... call the ldisc open routines.
1994 * If we fail here just call release_mem to clean up. No need
1995 * to decrement the use counts, as release_mem doesn't care.
1998 if (tty->ldisc.open) {
1999 retval = (tty->ldisc.open)(tty);
2001 goto release_mem_out;
2003 if (o_tty && o_tty->ldisc.open) {
2004 retval = (o_tty->ldisc.open)(o_tty);
2006 if (tty->ldisc.close)
2007 (tty->ldisc.close)(tty);
2008 goto release_mem_out;
2010 tty_ldisc_enable(o_tty);
2012 tty_ldisc_enable(tty);
2016 * This fast open can be used if the tty is already open.
2017 * No memory is allocated, and the only failures are from
2018 * attempting to open a closing tty or attempting multiple
2019 * opens on a pty master.
2022 if (test_bit(TTY_CLOSING, &tty->flags)) {
2026 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2027 driver->subtype == PTY_TYPE_MASTER) {
2029 * special case for PTY masters: only one open permitted,
2030 * and the slave side open count is incremented as well.
2039 tty->driver = driver; /* N.B. why do this every time?? */
2042 if(!test_bit(TTY_LDISC, &tty->flags))
2043 printk(KERN_ERR "init_dev but no ldisc\n");
2047 /* All paths come through here to release the mutex */
2051 /* Release locally allocated memory ... nothing placed in slots */
2055 free_tty_struct(o_tty);
2058 free_tty_struct(tty);
2061 module_put(driver->owner);
2065 /* call the tty release_mem routine to clean out this slot */
2067 printk(KERN_INFO "init_dev: ldisc open failed, "
2068 "clearing slot %d\n", idx);
2069 release_mem(tty, idx);
2074 * release_mem - release tty structure memory
2076 * Releases memory associated with a tty structure, and clears out the
2077 * driver table slots. This function is called when a device is no longer
2078 * in use. It also gets called when setup of a device fails.
2081 * tty_mutex - sometimes only
2082 * takes the file list lock internally when working on the list
2083 * of ttys that the driver keeps.
2084 * FIXME: should we require tty_mutex is held here ??
2087 static void release_mem(struct tty_struct *tty, int idx)
2089 struct tty_struct *o_tty;
2091 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2093 if ((o_tty = tty->link) != NULL) {
2095 o_tty->driver->ttys[idx] = NULL;
2096 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2097 tp = o_tty->termios;
2099 o_tty->driver->termios[idx] = NULL;
2102 tp = o_tty->termios_locked;
2104 o_tty->driver->termios_locked[idx] = NULL;
2108 o_tty->driver->refcount--;
2110 list_del_init(&o_tty->tty_files);
2112 free_tty_struct(o_tty);
2116 tty->driver->ttys[idx] = NULL;
2117 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2120 tty->driver->termios[idx] = NULL;
2123 tp = tty->termios_locked;
2125 tty->driver->termios_locked[idx] = NULL;
2130 tty->driver->refcount--;
2132 list_del_init(&tty->tty_files);
2134 module_put(tty->driver->owner);
2135 free_tty_struct(tty);
2139 * Even releasing the tty structures is a tricky business.. We have
2140 * to be very careful that the structures are all released at the
2141 * same time, as interrupts might otherwise get the wrong pointers.
2143 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2144 * lead to double frees or releasing memory still in use.
2146 static void release_dev(struct file * filp)
2148 struct tty_struct *tty, *o_tty;
2149 int pty_master, tty_closing, o_tty_closing, do_sleep;
2153 unsigned long flags;
2155 tty = (struct tty_struct *)filp->private_data;
2156 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2159 check_tty_count(tty, "release_dev");
2161 tty_fasync(-1, filp, 0);
2164 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2165 tty->driver->subtype == PTY_TYPE_MASTER);
2166 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2169 #ifdef TTY_PARANOIA_CHECK
2170 if (idx < 0 || idx >= tty->driver->num) {
2171 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2172 "free (%s)\n", tty->name);
2175 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2176 if (tty != tty->driver->ttys[idx]) {
2177 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2178 "for (%s)\n", idx, tty->name);
2181 if (tty->termios != tty->driver->termios[idx]) {
2182 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2187 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2188 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2189 "termios_locked for (%s)\n",
2196 #ifdef TTY_DEBUG_HANGUP
2197 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2198 tty_name(tty, buf), tty->count);
2201 #ifdef TTY_PARANOIA_CHECK
2202 if (tty->driver->other &&
2203 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2204 if (o_tty != tty->driver->other->ttys[idx]) {
2205 printk(KERN_DEBUG "release_dev: other->table[%d] "
2206 "not o_tty for (%s)\n",
2210 if (o_tty->termios != tty->driver->other->termios[idx]) {
2211 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2212 "not o_termios for (%s)\n",
2216 if (o_tty->termios_locked !=
2217 tty->driver->other->termios_locked[idx]) {
2218 printk(KERN_DEBUG "release_dev: other->termios_locked["
2219 "%d] not o_termios_locked for (%s)\n",
2223 if (o_tty->link != tty) {
2224 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2229 if (tty->driver->close)
2230 tty->driver->close(tty, filp);
2233 * Sanity check: if tty->count is going to zero, there shouldn't be
2234 * any waiters on tty->read_wait or tty->write_wait. We test the
2235 * wait queues and kick everyone out _before_ actually starting to
2236 * close. This ensures that we won't block while releasing the tty
2239 * The test for the o_tty closing is necessary, since the master and
2240 * slave sides may close in any order. If the slave side closes out
2241 * first, its count will be one, since the master side holds an open.
2242 * Thus this test wouldn't be triggered at the time the slave closes,
2245 * Note that it's possible for the tty to be opened again while we're
2246 * flushing out waiters. By recalculating the closing flags before
2247 * each iteration we avoid any problems.
2250 /* Guard against races with tty->count changes elsewhere and
2251 opens on /dev/tty */
2253 mutex_lock(&tty_mutex);
2254 tty_closing = tty->count <= 1;
2255 o_tty_closing = o_tty &&
2256 (o_tty->count <= (pty_master ? 1 : 0));
2260 if (waitqueue_active(&tty->read_wait)) {
2261 wake_up(&tty->read_wait);
2264 if (waitqueue_active(&tty->write_wait)) {
2265 wake_up(&tty->write_wait);
2269 if (o_tty_closing) {
2270 if (waitqueue_active(&o_tty->read_wait)) {
2271 wake_up(&o_tty->read_wait);
2274 if (waitqueue_active(&o_tty->write_wait)) {
2275 wake_up(&o_tty->write_wait);
2282 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2283 "active!\n", tty_name(tty, buf));
2284 mutex_unlock(&tty_mutex);
2289 * The closing flags are now consistent with the open counts on
2290 * both sides, and we've completed the last operation that could
2291 * block, so it's safe to proceed with closing.
2294 if (--o_tty->count < 0) {
2295 printk(KERN_WARNING "release_dev: bad pty slave count "
2297 o_tty->count, tty_name(o_tty, buf));
2301 if (--tty->count < 0) {
2302 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2303 tty->count, tty_name(tty, buf));
2308 * We've decremented tty->count, so we need to remove this file
2309 * descriptor off the tty->tty_files list; this serves two
2311 * - check_tty_count sees the correct number of file descriptors
2312 * associated with this tty.
2313 * - do_tty_hangup no longer sees this file descriptor as
2314 * something that needs to be handled for hangups.
2317 filp->private_data = NULL;
2320 * Perform some housekeeping before deciding whether to return.
2322 * Set the TTY_CLOSING flag if this was the last open. In the
2323 * case of a pty we may have to wait around for the other side
2324 * to close, and TTY_CLOSING makes sure we can't be reopened.
2327 set_bit(TTY_CLOSING, &tty->flags);
2329 set_bit(TTY_CLOSING, &o_tty->flags);
2332 * If _either_ side is closing, make sure there aren't any
2333 * processes that still think tty or o_tty is their controlling
2336 if (tty_closing || o_tty_closing) {
2337 struct task_struct *p;
2339 read_lock(&tasklist_lock);
2340 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2341 p->signal->tty = NULL;
2342 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2344 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
2345 p->signal->tty = NULL;
2346 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
2347 read_unlock(&tasklist_lock);
2350 mutex_unlock(&tty_mutex);
2352 /* check whether both sides are closing ... */
2353 if (!tty_closing || (o_tty && !o_tty_closing))
2356 #ifdef TTY_DEBUG_HANGUP
2357 printk(KERN_DEBUG "freeing tty structure...");
2360 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2361 * kill any delayed work. As this is the final close it does not
2362 * race with the set_ldisc code path.
2364 clear_bit(TTY_LDISC, &tty->flags);
2365 cancel_delayed_work(&tty->buf.work);
2368 * Wait for ->hangup_work and ->buf.work handlers to terminate
2371 flush_scheduled_work();
2374 * Wait for any short term users (we know they are just driver
2375 * side waiters as the file is closing so user count on the file
2378 spin_lock_irqsave(&tty_ldisc_lock, flags);
2379 while(tty->ldisc.refcount)
2381 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2382 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2383 spin_lock_irqsave(&tty_ldisc_lock, flags);
2385 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2387 * Shutdown the current line discipline, and reset it to N_TTY.
2388 * N.B. why reset ldisc when we're releasing the memory??
2390 * FIXME: this MUST get fixed for the new reflocking
2392 if (tty->ldisc.close)
2393 (tty->ldisc.close)(tty);
2394 tty_ldisc_put(tty->ldisc.num);
2397 * Switch the line discipline back
2399 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2400 tty_set_termios_ldisc(tty,N_TTY);
2402 /* FIXME: could o_tty be in setldisc here ? */
2403 clear_bit(TTY_LDISC, &o_tty->flags);
2404 if (o_tty->ldisc.close)
2405 (o_tty->ldisc.close)(o_tty);
2406 tty_ldisc_put(o_tty->ldisc.num);
2407 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2408 tty_set_termios_ldisc(o_tty,N_TTY);
2411 * The release_mem function takes care of the details of clearing
2412 * the slots and preserving the termios structure.
2414 release_mem(tty, idx);
2416 #ifdef CONFIG_UNIX98_PTYS
2417 /* Make this pty number available for reallocation */
2419 down(&allocated_ptys_lock);
2420 idr_remove(&allocated_ptys, idx);
2421 up(&allocated_ptys_lock);
2428 * tty_open - open a tty device
2429 * @inode: inode of device file
2430 * @filp: file pointer to tty
2432 * tty_open and tty_release keep up the tty count that contains the
2433 * number of opens done on a tty. We cannot use the inode-count, as
2434 * different inodes might point to the same tty.
2436 * Open-counting is needed for pty masters, as well as for keeping
2437 * track of serial lines: DTR is dropped when the last close happens.
2438 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2440 * The termios state of a pty is reset on first open so that
2441 * settings don't persist across reuse.
2443 * Locking: tty_mutex protects current->signal->tty, get_tty_driver and
2444 * init_dev work. tty->count should protect the rest.
2445 * task_lock is held to update task details for sessions
2448 static int tty_open(struct inode * inode, struct file * filp)
2450 struct tty_struct *tty;
2452 struct tty_driver *driver;
2454 dev_t device = inode->i_rdev;
2455 unsigned short saved_flags = filp->f_flags;
2457 nonseekable_open(inode, filp);
2460 noctty = filp->f_flags & O_NOCTTY;
2464 mutex_lock(&tty_mutex);
2466 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2467 if (!current->signal->tty) {
2468 mutex_unlock(&tty_mutex);
2471 driver = current->signal->tty->driver;
2472 index = current->signal->tty->index;
2473 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2478 if (device == MKDEV(TTY_MAJOR,0)) {
2479 extern struct tty_driver *console_driver;
2480 driver = console_driver;
2486 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2487 driver = console_device(&index);
2489 /* Don't let /dev/console block */
2490 filp->f_flags |= O_NONBLOCK;
2494 mutex_unlock(&tty_mutex);
2498 driver = get_tty_driver(device, &index);
2500 mutex_unlock(&tty_mutex);
2504 retval = init_dev(driver, index, &tty);
2505 mutex_unlock(&tty_mutex);
2509 filp->private_data = tty;
2510 file_move(filp, &tty->tty_files);
2511 check_tty_count(tty, "tty_open");
2512 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2513 tty->driver->subtype == PTY_TYPE_MASTER)
2515 #ifdef TTY_DEBUG_HANGUP
2516 printk(KERN_DEBUG "opening %s...", tty->name);
2519 if (tty->driver->open)
2520 retval = tty->driver->open(tty, filp);
2524 filp->f_flags = saved_flags;
2526 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2530 #ifdef TTY_DEBUG_HANGUP
2531 printk(KERN_DEBUG "error %d in opening %s...", retval,
2535 if (retval != -ERESTARTSYS)
2537 if (signal_pending(current))
2541 * Need to reset f_op in case a hangup happened.
2543 if (filp->f_op == &hung_up_tty_fops)
2544 filp->f_op = &tty_fops;
2548 current->signal->leader &&
2549 !current->signal->tty &&
2550 tty->session == 0) {
2552 current->signal->tty = tty;
2553 task_unlock(current);
2554 current->signal->tty_old_pgrp = 0;
2555 tty->session = current->signal->session;
2556 tty->pgrp = process_group(current);
2561 #ifdef CONFIG_UNIX98_PTYS
2563 * ptmx_open - open a unix 98 pty master
2564 * @inode: inode of device file
2565 * @filp: file pointer to tty
2567 * Allocate a unix98 pty master device from the ptmx driver.
2569 * Locking: tty_mutex protects theinit_dev work. tty->count should
2571 * allocated_ptys_lock handles the list of free pty numbers
2574 static int ptmx_open(struct inode * inode, struct file * filp)
2576 struct tty_struct *tty;
2581 nonseekable_open(inode, filp);
2583 /* find a device that is not in use. */
2584 down(&allocated_ptys_lock);
2585 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2586 up(&allocated_ptys_lock);
2589 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2591 up(&allocated_ptys_lock);
2592 if (idr_ret == -EAGAIN)
2596 if (index >= pty_limit) {
2597 idr_remove(&allocated_ptys, index);
2598 up(&allocated_ptys_lock);
2601 up(&allocated_ptys_lock);
2603 mutex_lock(&tty_mutex);
2604 retval = init_dev(ptm_driver, index, &tty);
2605 mutex_unlock(&tty_mutex);
2610 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2611 filp->private_data = tty;
2612 file_move(filp, &tty->tty_files);
2615 if (devpts_pty_new(tty->link))
2618 check_tty_count(tty, "tty_open");
2619 retval = ptm_driver->open(tty, filp);
2626 down(&allocated_ptys_lock);
2627 idr_remove(&allocated_ptys, index);
2628 up(&allocated_ptys_lock);
2634 * tty_release - vfs callback for close
2635 * @inode: inode of tty
2636 * @filp: file pointer for handle to tty
2638 * Called the last time each file handle is closed that references
2639 * this tty. There may however be several such references.
2642 * Takes bkl. See release_dev
2645 static int tty_release(struct inode * inode, struct file * filp)
2654 * tty_poll - check tty status
2655 * @filp: file being polled
2656 * @wait: poll wait structures to update
2658 * Call the line discipline polling method to obtain the poll
2659 * status of the device.
2661 * Locking: locks called line discipline but ldisc poll method
2662 * may be re-entered freely by other callers.
2665 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2667 struct tty_struct * tty;
2668 struct tty_ldisc *ld;
2671 tty = (struct tty_struct *)filp->private_data;
2672 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2675 ld = tty_ldisc_ref_wait(tty);
2677 ret = (ld->poll)(tty, filp, wait);
2678 tty_ldisc_deref(ld);
2682 static int tty_fasync(int fd, struct file * filp, int on)
2684 struct tty_struct * tty;
2687 tty = (struct tty_struct *)filp->private_data;
2688 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2691 retval = fasync_helper(fd, filp, on, &tty->fasync);
2696 if (!waitqueue_active(&tty->read_wait))
2697 tty->minimum_to_wake = 1;
2698 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2702 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2703 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2709 * tiocsti - fake input character
2710 * @tty: tty to fake input into
2711 * @p: pointer to character
2713 * Fake input to a tty device. Does the neccessary locking and
2716 * FIXME: does not honour flow control ??
2719 * Called functions take tty_ldisc_lock
2720 * current->signal->tty check is safe without locks
2723 static int tiocsti(struct tty_struct *tty, char __user *p)
2726 struct tty_ldisc *ld;
2728 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2730 if (get_user(ch, p))
2732 ld = tty_ldisc_ref_wait(tty);
2733 ld->receive_buf(tty, &ch, &mbz, 1);
2734 tty_ldisc_deref(ld);
2739 * tiocgwinsz - implement window query ioctl
2741 * @arg: user buffer for result
2743 * Copies the kernel idea of the window size into the user buffer.
2745 * Locking: tty->termios_sem is taken to ensure the winsize data
2749 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2753 mutex_lock(&tty->termios_mutex);
2754 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2755 mutex_unlock(&tty->termios_mutex);
2757 return err ? -EFAULT: 0;
2761 * tiocswinsz - implement window size set ioctl
2763 * @arg: user buffer for result
2765 * Copies the user idea of the window size to the kernel. Traditionally
2766 * this is just advisory information but for the Linux console it
2767 * actually has driver level meaning and triggers a VC resize.
2770 * Called function use the console_sem is used to ensure we do
2771 * not try and resize the console twice at once.
2772 * The tty->termios_sem is used to ensure we don't double
2773 * resize and get confused. Lock order - tty->termios.sem before
2777 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2778 struct winsize __user * arg)
2780 struct winsize tmp_ws;
2782 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2785 mutex_lock(&tty->termios_mutex);
2786 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2790 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2791 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2793 mutex_unlock(&tty->termios_mutex);
2799 kill_pg(tty->pgrp, SIGWINCH, 1);
2800 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2801 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2802 tty->winsize = tmp_ws;
2803 real_tty->winsize = tmp_ws;
2805 mutex_unlock(&tty->termios_mutex);
2810 * tioccons - allow admin to move logical console
2811 * @file: the file to become console
2813 * Allow the adminstrator to move the redirected console device
2815 * Locking: uses redirect_lock to guard the redirect information
2818 static int tioccons(struct file *file)
2820 if (!capable(CAP_SYS_ADMIN))
2822 if (file->f_op->write == redirected_tty_write) {
2824 spin_lock(&redirect_lock);
2827 spin_unlock(&redirect_lock);
2832 spin_lock(&redirect_lock);
2834 spin_unlock(&redirect_lock);
2839 spin_unlock(&redirect_lock);
2844 * fionbio - non blocking ioctl
2845 * @file: file to set blocking value
2846 * @p: user parameter
2848 * Historical tty interfaces had a blocking control ioctl before
2849 * the generic functionality existed. This piece of history is preserved
2850 * in the expected tty API of posix OS's.
2852 * Locking: none, the open fle handle ensures it won't go away.
2855 static int fionbio(struct file *file, int __user *p)
2859 if (get_user(nonblock, p))
2863 file->f_flags |= O_NONBLOCK;
2865 file->f_flags &= ~O_NONBLOCK;
2870 * tiocsctty - set controlling tty
2871 * @tty: tty structure
2872 * @arg: user argument
2874 * This ioctl is used to manage job control. It permits a session
2875 * leader to set this tty as the controlling tty for the session.
2878 * Takes tasklist lock internally to walk sessions
2879 * Takes task_lock() when updating signal->tty
2881 * FIXME: tty_mutex is needed to protect signal->tty references.
2882 * FIXME: why task_lock on the signal->tty reference ??
2886 static int tiocsctty(struct tty_struct *tty, int arg)
2888 struct task_struct *p;
2890 if (current->signal->leader &&
2891 (current->signal->session == tty->session))
2894 * The process must be a session leader and
2895 * not have a controlling tty already.
2897 if (!current->signal->leader || current->signal->tty)
2899 if (tty->session > 0) {
2901 * This tty is already the controlling
2902 * tty for another session group!
2904 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2909 read_lock(&tasklist_lock);
2910 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2911 p->signal->tty = NULL;
2912 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2913 read_unlock(&tasklist_lock);
2918 current->signal->tty = tty;
2919 task_unlock(current);
2920 current->signal->tty_old_pgrp = 0;
2921 tty->session = current->signal->session;
2922 tty->pgrp = process_group(current);
2927 * tiocgpgrp - get process group
2928 * @tty: tty passed by user
2929 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2932 * Obtain the process group of the tty. If there is no process group
2935 * Locking: none. Reference to ->signal->tty is safe.
2938 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2941 * (tty == real_tty) is a cheap way of
2942 * testing if the tty is NOT a master pty.
2944 if (tty == real_tty && current->signal->tty != real_tty)
2946 return put_user(real_tty->pgrp, p);
2950 * tiocspgrp - attempt to set process group
2951 * @tty: tty passed by user
2952 * @real_tty: tty side device matching tty passed by user
2955 * Set the process group of the tty to the session passed. Only
2956 * permitted where the tty session is our session.
2960 * FIXME: current->signal->tty referencing is unsafe.
2963 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2966 int retval = tty_check_change(real_tty);
2972 if (!current->signal->tty ||
2973 (current->signal->tty != real_tty) ||
2974 (real_tty->session != current->signal->session))
2976 if (get_user(pgrp, p))
2980 if (session_of_pgrp(pgrp) != current->signal->session)
2982 real_tty->pgrp = pgrp;
2987 * tiocgsid - get session id
2988 * @tty: tty passed by user
2989 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2990 * @p: pointer to returned session id
2992 * Obtain the session id of the tty. If there is no session
2995 * Locking: none. Reference to ->signal->tty is safe.
2998 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3001 * (tty == real_tty) is a cheap way of
3002 * testing if the tty is NOT a master pty.
3004 if (tty == real_tty && current->signal->tty != real_tty)
3006 if (real_tty->session <= 0)
3008 return put_user(real_tty->session, p);
3012 * tiocsetd - set line discipline
3014 * @p: pointer to user data
3016 * Set the line discipline according to user request.
3018 * Locking: see tty_set_ldisc, this function is just a helper
3021 static int tiocsetd(struct tty_struct *tty, int __user *p)
3025 if (get_user(ldisc, p))
3027 return tty_set_ldisc(tty, ldisc);
3031 * send_break - performed time break
3032 * @tty: device to break on
3033 * @duration: timeout in mS
3035 * Perform a timed break on hardware that lacks its own driver level
3036 * timed break functionality.
3042 * What if two overlap
3045 static int send_break(struct tty_struct *tty, unsigned int duration)
3047 tty->driver->break_ctl(tty, -1);
3048 if (!signal_pending(current)) {
3049 msleep_interruptible(duration);
3051 tty->driver->break_ctl(tty, 0);
3052 if (signal_pending(current))
3058 * tiocmget - get modem status
3060 * @file: user file pointer
3061 * @p: pointer to result
3063 * Obtain the modem status bits from the tty driver if the feature
3064 * is supported. Return -EINVAL if it is not available.
3066 * Locking: none (up to the driver)
3069 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3071 int retval = -EINVAL;
3073 if (tty->driver->tiocmget) {
3074 retval = tty->driver->tiocmget(tty, file);
3077 retval = put_user(retval, p);
3083 * tiocmset - set modem status
3085 * @file: user file pointer
3086 * @cmd: command - clear bits, set bits or set all
3087 * @p: pointer to desired bits
3089 * Set the modem status bits from the tty driver if the feature
3090 * is supported. Return -EINVAL if it is not available.
3092 * Locking: none (up to the driver)
3095 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3098 int retval = -EINVAL;
3100 if (tty->driver->tiocmset) {
3101 unsigned int set, clear, val;
3103 retval = get_user(val, p);
3121 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3122 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3124 retval = tty->driver->tiocmset(tty, file, set, clear);
3130 * Split this up, as gcc can choke on it otherwise..
3132 int tty_ioctl(struct inode * inode, struct file * file,
3133 unsigned int cmd, unsigned long arg)
3135 struct tty_struct *tty, *real_tty;
3136 void __user *p = (void __user *)arg;
3138 struct tty_ldisc *ld;
3140 tty = (struct tty_struct *)file->private_data;
3141 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3145 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3146 tty->driver->subtype == PTY_TYPE_MASTER)
3147 real_tty = tty->link;
3150 * Break handling by driver
3152 if (!tty->driver->break_ctl) {
3156 if (tty->driver->ioctl)
3157 return tty->driver->ioctl(tty, file, cmd, arg);
3160 /* These two ioctl's always return success; even if */
3161 /* the driver doesn't support them. */
3164 if (!tty->driver->ioctl)
3166 retval = tty->driver->ioctl(tty, file, cmd, arg);
3167 if (retval == -ENOIOCTLCMD)
3174 * Factor out some common prep work
3182 retval = tty_check_change(tty);
3185 if (cmd != TIOCCBRK) {
3186 tty_wait_until_sent(tty, 0);
3187 if (signal_pending(current))
3195 return tiocsti(tty, p);
3197 return tiocgwinsz(tty, p);
3199 return tiocswinsz(tty, real_tty, p);
3201 return real_tty!=tty ? -EINVAL : tioccons(file);
3203 return fionbio(file, p);
3205 set_bit(TTY_EXCLUSIVE, &tty->flags);
3208 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3211 /* FIXME: taks lock or tty_mutex ? */
3212 if (current->signal->tty != tty)
3214 if (current->signal->leader)
3215 disassociate_ctty(0);
3217 current->signal->tty = NULL;
3218 task_unlock(current);
3221 return tiocsctty(tty, arg);
3223 return tiocgpgrp(tty, real_tty, p);
3225 return tiocspgrp(tty, real_tty, p);
3227 return tiocgsid(tty, real_tty, p);
3229 /* FIXME: check this is ok */
3230 return put_user(tty->ldisc.num, (int __user *)p);
3232 return tiocsetd(tty, p);
3235 return tioclinux(tty, arg);
3240 case TIOCSBRK: /* Turn break on, unconditionally */
3241 tty->driver->break_ctl(tty, -1);
3244 case TIOCCBRK: /* Turn break off, unconditionally */
3245 tty->driver->break_ctl(tty, 0);
3247 case TCSBRK: /* SVID version: non-zero arg --> no break */
3248 /* non-zero arg means wait for all output data
3249 * to be sent (performed above) but don't send break.
3250 * This is used by the tcdrain() termios function.
3253 return send_break(tty, 250);
3255 case TCSBRKP: /* support for POSIX tcsendbreak() */
3256 return send_break(tty, arg ? arg*100 : 250);
3259 return tty_tiocmget(tty, file, p);
3264 return tty_tiocmset(tty, file, cmd, p);
3266 if (tty->driver->ioctl) {
3267 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3268 if (retval != -ENOIOCTLCMD)
3271 ld = tty_ldisc_ref_wait(tty);
3274 retval = ld->ioctl(tty, file, cmd, arg);
3275 if (retval == -ENOIOCTLCMD)
3278 tty_ldisc_deref(ld);
3284 * This implements the "Secure Attention Key" --- the idea is to
3285 * prevent trojan horses by killing all processes associated with this
3286 * tty when the user hits the "Secure Attention Key". Required for
3287 * super-paranoid applications --- see the Orange Book for more details.
3289 * This code could be nicer; ideally it should send a HUP, wait a few
3290 * seconds, then send a INT, and then a KILL signal. But you then
3291 * have to coordinate with the init process, since all processes associated
3292 * with the current tty must be dead before the new getty is allowed
3295 * Now, if it would be correct ;-/ The current code has a nasty hole -
3296 * it doesn't catch files in flight. We may send the descriptor to ourselves
3297 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3299 * Nasty bug: do_SAK is being called in interrupt context. This can
3300 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3302 static void __do_SAK(void *arg)
3307 struct tty_struct *tty = arg;
3308 struct task_struct *g, *p;
3312 struct tty_ldisc *disc;
3313 struct fdtable *fdt;
3317 session = tty->session;
3319 /* We don't want an ldisc switch during this */
3320 disc = tty_ldisc_ref(tty);
3321 if (disc && disc->flush_buffer)
3322 disc->flush_buffer(tty);
3323 tty_ldisc_deref(disc);
3325 if (tty->driver->flush_buffer)
3326 tty->driver->flush_buffer(tty);
3328 read_lock(&tasklist_lock);
3329 /* Kill the entire session */
3330 do_each_task_pid(session, PIDTYPE_SID, p) {
3331 printk(KERN_NOTICE "SAK: killed process %d"
3332 " (%s): p->signal->session==tty->session\n",
3334 send_sig(SIGKILL, p, 1);
3335 } while_each_task_pid(session, PIDTYPE_SID, p);
3336 /* Now kill any processes that happen to have the
3339 do_each_thread(g, p) {
3340 if (p->signal->tty == tty) {
3341 printk(KERN_NOTICE "SAK: killed process %d"
3342 " (%s): p->signal->session==tty->session\n",
3344 send_sig(SIGKILL, p, 1);
3350 * We don't take a ref to the file, so we must
3351 * hold ->file_lock instead.
3353 spin_lock(&p->files->file_lock);
3354 fdt = files_fdtable(p->files);
3355 for (i=0; i < fdt->max_fds; i++) {
3356 filp = fcheck_files(p->files, i);
3359 if (filp->f_op->read == tty_read &&
3360 filp->private_data == tty) {
3361 printk(KERN_NOTICE "SAK: killed process %d"
3362 " (%s): fd#%d opened to the tty\n",
3363 p->pid, p->comm, i);
3364 force_sig(SIGKILL, p);
3368 spin_unlock(&p->files->file_lock);
3371 } while_each_thread(g, p);
3372 read_unlock(&tasklist_lock);
3377 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3378 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3379 * the values which we write to it will be identical to the values which it
3380 * already has. --akpm
3382 void do_SAK(struct tty_struct *tty)
3386 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
3387 schedule_work(&tty->SAK_work);
3390 EXPORT_SYMBOL(do_SAK);
3394 * @private_: tty structure passed from work queue.
3396 * This routine is called out of the software interrupt to flush data
3397 * from the buffer chain to the line discipline.
3399 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3400 * while invoking the line discipline receive_buf method. The
3401 * receive_buf method is single threaded for each tty instance.
3404 static void flush_to_ldisc(void *private_)
3406 struct tty_struct *tty = (struct tty_struct *) private_;
3407 unsigned long flags;
3408 struct tty_ldisc *disc;
3409 struct tty_buffer *tbuf, *head;
3411 unsigned char *flag_buf;
3413 disc = tty_ldisc_ref(tty);
3414 if (disc == NULL) /* !TTY_LDISC */
3417 spin_lock_irqsave(&tty->buf.lock, flags);
3418 head = tty->buf.head;
3420 tty->buf.head = NULL;
3422 int count = head->commit - head->read;
3424 if (head->next == NULL)
3428 tty_buffer_free(tty, tbuf);
3431 if (!tty->receive_room) {
3432 schedule_delayed_work(&tty->buf.work, 1);
3435 if (count > tty->receive_room)
3436 count = tty->receive_room;
3437 char_buf = head->char_buf_ptr + head->read;
3438 flag_buf = head->flag_buf_ptr + head->read;
3439 head->read += count;
3440 spin_unlock_irqrestore(&tty->buf.lock, flags);
3441 disc->receive_buf(tty, char_buf, flag_buf, count);
3442 spin_lock_irqsave(&tty->buf.lock, flags);
3444 tty->buf.head = head;
3446 spin_unlock_irqrestore(&tty->buf.lock, flags);
3448 tty_ldisc_deref(disc);
3452 * Routine which returns the baud rate of the tty
3454 * Note that the baud_table needs to be kept in sync with the
3455 * include/asm/termbits.h file.
3457 static int baud_table[] = {
3458 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3459 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3461 76800, 153600, 307200, 614400, 921600
3463 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3464 2500000, 3000000, 3500000, 4000000
3468 static int n_baud_table = ARRAY_SIZE(baud_table);
3471 * tty_termios_baud_rate
3472 * @termios: termios structure
3474 * Convert termios baud rate data into a speed. This should be called
3475 * with the termios lock held if this termios is a terminal termios
3476 * structure. May change the termios data.
3481 int tty_termios_baud_rate(struct termios *termios)
3485 cbaud = termios->c_cflag & CBAUD;
3487 if (cbaud & CBAUDEX) {
3490 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3491 termios->c_cflag &= ~CBAUDEX;
3495 return baud_table[cbaud];
3498 EXPORT_SYMBOL(tty_termios_baud_rate);
3501 * tty_get_baud_rate - get tty bit rates
3502 * @tty: tty to query
3504 * Returns the baud rate as an integer for this terminal. The
3505 * termios lock must be held by the caller and the terminal bit
3506 * flags may be updated.
3511 int tty_get_baud_rate(struct tty_struct *tty)
3513 int baud = tty_termios_baud_rate(tty->termios);
3515 if (baud == 38400 && tty->alt_speed) {
3517 printk(KERN_WARNING "Use of setserial/setrocket to "
3518 "set SPD_* flags is deprecated\n");
3521 baud = tty->alt_speed;
3527 EXPORT_SYMBOL(tty_get_baud_rate);
3530 * tty_flip_buffer_push - terminal
3533 * Queue a push of the terminal flip buffers to the line discipline. This
3534 * function must not be called from IRQ context if tty->low_latency is set.
3536 * In the event of the queue being busy for flipping the work will be
3537 * held off and retried later.
3539 * Locking: tty buffer lock. Driver locks in low latency mode.
3542 void tty_flip_buffer_push(struct tty_struct *tty)
3544 unsigned long flags;
3545 spin_lock_irqsave(&tty->buf.lock, flags);
3546 if (tty->buf.tail != NULL)
3547 tty->buf.tail->commit = tty->buf.tail->used;
3548 spin_unlock_irqrestore(&tty->buf.lock, flags);
3550 if (tty->low_latency)
3551 flush_to_ldisc((void *) tty);
3553 schedule_delayed_work(&tty->buf.work, 1);
3556 EXPORT_SYMBOL(tty_flip_buffer_push);
3560 * initialize_tty_struct
3561 * @tty: tty to initialize
3563 * This subroutine initializes a tty structure that has been newly
3566 * Locking: none - tty in question must not be exposed at this point
3569 static void initialize_tty_struct(struct tty_struct *tty)
3571 memset(tty, 0, sizeof(struct tty_struct));
3572 tty->magic = TTY_MAGIC;
3573 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3575 tty->overrun_time = jiffies;
3576 tty->buf.head = tty->buf.tail = NULL;
3577 tty_buffer_init(tty);
3578 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
3579 init_MUTEX(&tty->buf.pty_sem);
3580 mutex_init(&tty->termios_mutex);
3581 init_waitqueue_head(&tty->write_wait);
3582 init_waitqueue_head(&tty->read_wait);
3583 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
3584 mutex_init(&tty->atomic_read_lock);
3585 mutex_init(&tty->atomic_write_lock);
3586 spin_lock_init(&tty->read_lock);
3587 INIT_LIST_HEAD(&tty->tty_files);
3588 INIT_WORK(&tty->SAK_work, NULL, NULL);
3592 * The default put_char routine if the driver did not define one.
3595 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3597 tty->driver->write(tty, &ch, 1);
3600 static struct class *tty_class;
3603 * tty_register_device - register a tty device
3604 * @driver: the tty driver that describes the tty device
3605 * @index: the index in the tty driver for this tty device
3606 * @device: a struct device that is associated with this tty device.
3607 * This field is optional, if there is no known struct device
3608 * for this tty device it can be set to NULL safely.
3610 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
3612 * This call is required to be made to register an individual tty device
3613 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3614 * that bit is not set, this function should not be called by a tty
3620 struct class_device *tty_register_device(struct tty_driver *driver,
3621 unsigned index, struct device *device)
3624 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3626 if (index >= driver->num) {
3627 printk(KERN_ERR "Attempt to register invalid tty line number "
3629 return ERR_PTR(-EINVAL);
3632 if (driver->type == TTY_DRIVER_TYPE_PTY)
3633 pty_line_name(driver, index, name);
3635 tty_line_name(driver, index, name);
3637 return class_device_create(tty_class, NULL, dev, device, "%s", name);
3641 * tty_unregister_device - unregister 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
3645 * If a tty device is registered with a call to tty_register_device() then
3646 * this function must be called when the tty device is gone.
3651 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3653 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3656 EXPORT_SYMBOL(tty_register_device);
3657 EXPORT_SYMBOL(tty_unregister_device);
3659 struct tty_driver *alloc_tty_driver(int lines)
3661 struct tty_driver *driver;
3663 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3665 memset(driver, 0, sizeof(struct tty_driver));
3666 driver->magic = TTY_DRIVER_MAGIC;
3667 driver->num = lines;
3668 /* later we'll move allocation of tables here */
3673 void put_tty_driver(struct tty_driver *driver)
3678 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3680 driver->open = op->open;
3681 driver->close = op->close;
3682 driver->write = op->write;
3683 driver->put_char = op->put_char;
3684 driver->flush_chars = op->flush_chars;
3685 driver->write_room = op->write_room;
3686 driver->chars_in_buffer = op->chars_in_buffer;
3687 driver->ioctl = op->ioctl;
3688 driver->set_termios = op->set_termios;
3689 driver->throttle = op->throttle;
3690 driver->unthrottle = op->unthrottle;
3691 driver->stop = op->stop;
3692 driver->start = op->start;
3693 driver->hangup = op->hangup;
3694 driver->break_ctl = op->break_ctl;
3695 driver->flush_buffer = op->flush_buffer;
3696 driver->set_ldisc = op->set_ldisc;
3697 driver->wait_until_sent = op->wait_until_sent;
3698 driver->send_xchar = op->send_xchar;
3699 driver->read_proc = op->read_proc;
3700 driver->write_proc = op->write_proc;
3701 driver->tiocmget = op->tiocmget;
3702 driver->tiocmset = op->tiocmset;
3706 EXPORT_SYMBOL(alloc_tty_driver);
3707 EXPORT_SYMBOL(put_tty_driver);
3708 EXPORT_SYMBOL(tty_set_operations);
3711 * Called by a tty driver to register itself.
3713 int tty_register_driver(struct tty_driver *driver)
3720 if (driver->flags & TTY_DRIVER_INSTALLED)
3723 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3724 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3727 memset(p, 0, driver->num * 3 * sizeof(void *));
3730 if (!driver->major) {
3731 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3732 (char*)driver->name);
3734 driver->major = MAJOR(dev);
3735 driver->minor_start = MINOR(dev);
3738 dev = MKDEV(driver->major, driver->minor_start);
3739 error = register_chrdev_region(dev, driver->num,
3740 (char*)driver->name);
3748 driver->ttys = (struct tty_struct **)p;
3749 driver->termios = (struct termios **)(p + driver->num);
3750 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3752 driver->ttys = NULL;
3753 driver->termios = NULL;
3754 driver->termios_locked = NULL;
3757 cdev_init(&driver->cdev, &tty_fops);
3758 driver->cdev.owner = driver->owner;
3759 error = cdev_add(&driver->cdev, dev, driver->num);
3761 unregister_chrdev_region(dev, driver->num);
3762 driver->ttys = NULL;
3763 driver->termios = driver->termios_locked = NULL;
3768 if (!driver->put_char)
3769 driver->put_char = tty_default_put_char;
3771 list_add(&driver->tty_drivers, &tty_drivers);
3773 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3774 for(i = 0; i < driver->num; i++)
3775 tty_register_device(driver, i, NULL);
3777 proc_tty_register_driver(driver);
3781 EXPORT_SYMBOL(tty_register_driver);
3784 * Called by a tty driver to unregister itself.
3786 int tty_unregister_driver(struct tty_driver *driver)
3792 if (driver->refcount)
3795 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3798 list_del(&driver->tty_drivers);
3801 * Free the termios and termios_locked structures because
3802 * we don't want to get memory leaks when modular tty
3803 * drivers are removed from the kernel.
3805 for (i = 0; i < driver->num; i++) {
3806 tp = driver->termios[i];
3808 driver->termios[i] = NULL;
3811 tp = driver->termios_locked[i];
3813 driver->termios_locked[i] = NULL;
3816 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3817 tty_unregister_device(driver, i);
3820 proc_tty_unregister_driver(driver);
3821 driver->ttys = NULL;
3822 driver->termios = driver->termios_locked = NULL;
3824 cdev_del(&driver->cdev);
3828 EXPORT_SYMBOL(tty_unregister_driver);
3832 * Initialize the console device. This is called *early*, so
3833 * we can't necessarily depend on lots of kernel help here.
3834 * Just do some early initializations, and do the complex setup
3837 void __init console_init(void)
3841 /* Setup the default TTY line discipline. */
3842 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3845 * set up the console device so that later boot sequences can
3846 * inform about problems etc..
3848 #ifdef CONFIG_EARLY_PRINTK
3849 disable_early_printk();
3851 call = __con_initcall_start;
3852 while (call < __con_initcall_end) {
3859 extern int vty_init(void);
3862 static int __init tty_class_init(void)
3864 tty_class = class_create(THIS_MODULE, "tty");
3865 if (IS_ERR(tty_class))
3866 return PTR_ERR(tty_class);
3870 postcore_initcall(tty_class_init);
3872 /* 3/2004 jmc: why do these devices exist? */
3874 static struct cdev tty_cdev, console_cdev;
3875 #ifdef CONFIG_UNIX98_PTYS
3876 static struct cdev ptmx_cdev;
3879 static struct cdev vc0_cdev;
3883 * Ok, now we can initialize the rest of the tty devices and can count
3884 * on memory allocations, interrupts etc..
3886 static int __init tty_init(void)
3888 cdev_init(&tty_cdev, &tty_fops);
3889 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3890 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3891 panic("Couldn't register /dev/tty driver\n");
3892 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3894 cdev_init(&console_cdev, &console_fops);
3895 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3896 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3897 panic("Couldn't register /dev/console driver\n");
3898 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3900 #ifdef CONFIG_UNIX98_PTYS
3901 cdev_init(&ptmx_cdev, &ptmx_fops);
3902 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3903 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3904 panic("Couldn't register /dev/ptmx driver\n");
3905 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3909 cdev_init(&vc0_cdev, &console_fops);
3910 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3911 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3912 panic("Couldn't register /dev/tty0 driver\n");
3913 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3919 module_init(tty_init);