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 down(&tty->termios_sem);
622 tty->termios->c_line = num;
623 up(&tty->termios_sem);
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 down(&tty->termios_sem);
1342 *tty->termios = tty->driver->init_termios;
1343 up(&tty->termios_sem);
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. No
2746 * FIXME: Returning random values racing a window size set is wrong
2747 * should lock here against that
2750 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2752 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2758 * tiocswinsz - implement window size set ioctl
2760 * @arg: user buffer for result
2762 * Copies the user idea of the window size to the kernel. Traditionally
2763 * this is just advisory information but for the Linux console it
2764 * actually has driver level meaning and triggers a VC resize.
2767 * Called function use the console_sem is used to ensure we do
2768 * not try and resize the console twice at once.
2769 * The tty->termios_sem is used to ensure we don't double
2770 * resize and get confused. Lock order - tty->termios.sem before
2774 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2775 struct winsize __user * arg)
2777 struct winsize tmp_ws;
2779 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2782 down(&tty->termios_sem);
2783 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2787 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2788 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row)) {
2789 up(&tty->termios_sem);
2795 kill_pg(tty->pgrp, SIGWINCH, 1);
2796 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2797 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2798 tty->winsize = tmp_ws;
2799 real_tty->winsize = tmp_ws;
2801 up(&tty->termios_sem);
2806 * tioccons - allow admin to move logical console
2807 * @file: the file to become console
2809 * Allow the adminstrator to move the redirected console device
2811 * Locking: uses redirect_lock to guard the redirect information
2814 static int tioccons(struct file *file)
2816 if (!capable(CAP_SYS_ADMIN))
2818 if (file->f_op->write == redirected_tty_write) {
2820 spin_lock(&redirect_lock);
2823 spin_unlock(&redirect_lock);
2828 spin_lock(&redirect_lock);
2830 spin_unlock(&redirect_lock);
2835 spin_unlock(&redirect_lock);
2840 * fionbio - non blocking ioctl
2841 * @file: file to set blocking value
2842 * @p: user parameter
2844 * Historical tty interfaces had a blocking control ioctl before
2845 * the generic functionality existed. This piece of history is preserved
2846 * in the expected tty API of posix OS's.
2848 * Locking: none, the open fle handle ensures it won't go away.
2851 static int fionbio(struct file *file, int __user *p)
2855 if (get_user(nonblock, p))
2859 file->f_flags |= O_NONBLOCK;
2861 file->f_flags &= ~O_NONBLOCK;
2866 * tiocsctty - set controlling tty
2867 * @tty: tty structure
2868 * @arg: user argument
2870 * This ioctl is used to manage job control. It permits a session
2871 * leader to set this tty as the controlling tty for the session.
2874 * Takes tasklist lock internally to walk sessions
2875 * Takes task_lock() when updating signal->tty
2877 * FIXME: tty_mutex is needed to protect signal->tty references.
2878 * FIXME: why task_lock on the signal->tty reference ??
2882 static int tiocsctty(struct tty_struct *tty, int arg)
2884 struct task_struct *p;
2886 if (current->signal->leader &&
2887 (current->signal->session == tty->session))
2890 * The process must be a session leader and
2891 * not have a controlling tty already.
2893 if (!current->signal->leader || current->signal->tty)
2895 if (tty->session > 0) {
2897 * This tty is already the controlling
2898 * tty for another session group!
2900 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2905 read_lock(&tasklist_lock);
2906 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2907 p->signal->tty = NULL;
2908 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2909 read_unlock(&tasklist_lock);
2914 current->signal->tty = tty;
2915 task_unlock(current);
2916 current->signal->tty_old_pgrp = 0;
2917 tty->session = current->signal->session;
2918 tty->pgrp = process_group(current);
2923 * tiocgpgrp - get process group
2924 * @tty: tty passed by user
2925 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2928 * Obtain the process group of the tty. If there is no process group
2931 * Locking: none. Reference to ->signal->tty is safe.
2934 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2937 * (tty == real_tty) is a cheap way of
2938 * testing if the tty is NOT a master pty.
2940 if (tty == real_tty && current->signal->tty != real_tty)
2942 return put_user(real_tty->pgrp, p);
2946 * tiocspgrp - attempt to set process group
2947 * @tty: tty passed by user
2948 * @real_tty: tty side device matching tty passed by user
2951 * Set the process group of the tty to the session passed. Only
2952 * permitted where the tty session is our session.
2956 * FIXME: current->signal->tty referencing is unsafe.
2959 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2962 int retval = tty_check_change(real_tty);
2968 if (!current->signal->tty ||
2969 (current->signal->tty != real_tty) ||
2970 (real_tty->session != current->signal->session))
2972 if (get_user(pgrp, p))
2976 if (session_of_pgrp(pgrp) != current->signal->session)
2978 real_tty->pgrp = pgrp;
2983 * tiocgsid - get session id
2984 * @tty: tty passed by user
2985 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2986 * @p: pointer to returned session id
2988 * Obtain the session id of the tty. If there is no session
2991 * Locking: none. Reference to ->signal->tty is safe.
2994 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2997 * (tty == real_tty) is a cheap way of
2998 * testing if the tty is NOT a master pty.
3000 if (tty == real_tty && current->signal->tty != real_tty)
3002 if (real_tty->session <= 0)
3004 return put_user(real_tty->session, p);
3008 * tiocsetd - set line discipline
3010 * @p: pointer to user data
3012 * Set the line discipline according to user request.
3014 * Locking: see tty_set_ldisc, this function is just a helper
3017 static int tiocsetd(struct tty_struct *tty, int __user *p)
3021 if (get_user(ldisc, p))
3023 return tty_set_ldisc(tty, ldisc);
3027 * send_break - performed time break
3028 * @tty: device to break on
3029 * @duration: timeout in mS
3031 * Perform a timed break on hardware that lacks its own driver level
3032 * timed break functionality.
3038 * What if two overlap
3041 static int send_break(struct tty_struct *tty, unsigned int duration)
3043 tty->driver->break_ctl(tty, -1);
3044 if (!signal_pending(current)) {
3045 msleep_interruptible(duration);
3047 tty->driver->break_ctl(tty, 0);
3048 if (signal_pending(current))
3054 * tiocmget - get modem status
3056 * @file: user file pointer
3057 * @p: pointer to result
3059 * Obtain the modem status bits from the tty driver if the feature
3060 * is supported. Return -EINVAL if it is not available.
3062 * Locking: none (up to the driver)
3065 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3067 int retval = -EINVAL;
3069 if (tty->driver->tiocmget) {
3070 retval = tty->driver->tiocmget(tty, file);
3073 retval = put_user(retval, p);
3079 * tiocmset - set modem status
3081 * @file: user file pointer
3082 * @cmd: command - clear bits, set bits or set all
3083 * @p: pointer to desired bits
3085 * Set the modem status bits from the tty driver if the feature
3086 * is supported. Return -EINVAL if it is not available.
3088 * Locking: none (up to the driver)
3091 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3094 int retval = -EINVAL;
3096 if (tty->driver->tiocmset) {
3097 unsigned int set, clear, val;
3099 retval = get_user(val, p);
3117 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3118 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3120 retval = tty->driver->tiocmset(tty, file, set, clear);
3126 * Split this up, as gcc can choke on it otherwise..
3128 int tty_ioctl(struct inode * inode, struct file * file,
3129 unsigned int cmd, unsigned long arg)
3131 struct tty_struct *tty, *real_tty;
3132 void __user *p = (void __user *)arg;
3134 struct tty_ldisc *ld;
3136 tty = (struct tty_struct *)file->private_data;
3137 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3141 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3142 tty->driver->subtype == PTY_TYPE_MASTER)
3143 real_tty = tty->link;
3146 * Break handling by driver
3148 if (!tty->driver->break_ctl) {
3152 if (tty->driver->ioctl)
3153 return tty->driver->ioctl(tty, file, cmd, arg);
3156 /* These two ioctl's always return success; even if */
3157 /* the driver doesn't support them. */
3160 if (!tty->driver->ioctl)
3162 retval = tty->driver->ioctl(tty, file, cmd, arg);
3163 if (retval == -ENOIOCTLCMD)
3170 * Factor out some common prep work
3178 retval = tty_check_change(tty);
3181 if (cmd != TIOCCBRK) {
3182 tty_wait_until_sent(tty, 0);
3183 if (signal_pending(current))
3191 return tiocsti(tty, p);
3193 return tiocgwinsz(tty, p);
3195 return tiocswinsz(tty, real_tty, p);
3197 return real_tty!=tty ? -EINVAL : tioccons(file);
3199 return fionbio(file, p);
3201 set_bit(TTY_EXCLUSIVE, &tty->flags);
3204 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3207 /* FIXME: taks lock or tty_mutex ? */
3208 if (current->signal->tty != tty)
3210 if (current->signal->leader)
3211 disassociate_ctty(0);
3213 current->signal->tty = NULL;
3214 task_unlock(current);
3217 return tiocsctty(tty, arg);
3219 return tiocgpgrp(tty, real_tty, p);
3221 return tiocspgrp(tty, real_tty, p);
3223 return tiocgsid(tty, real_tty, p);
3225 /* FIXME: check this is ok */
3226 return put_user(tty->ldisc.num, (int __user *)p);
3228 return tiocsetd(tty, p);
3231 return tioclinux(tty, arg);
3236 case TIOCSBRK: /* Turn break on, unconditionally */
3237 tty->driver->break_ctl(tty, -1);
3240 case TIOCCBRK: /* Turn break off, unconditionally */
3241 tty->driver->break_ctl(tty, 0);
3243 case TCSBRK: /* SVID version: non-zero arg --> no break */
3244 /* non-zero arg means wait for all output data
3245 * to be sent (performed above) but don't send break.
3246 * This is used by the tcdrain() termios function.
3249 return send_break(tty, 250);
3251 case TCSBRKP: /* support for POSIX tcsendbreak() */
3252 return send_break(tty, arg ? arg*100 : 250);
3255 return tty_tiocmget(tty, file, p);
3260 return tty_tiocmset(tty, file, cmd, p);
3262 if (tty->driver->ioctl) {
3263 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3264 if (retval != -ENOIOCTLCMD)
3267 ld = tty_ldisc_ref_wait(tty);
3270 retval = ld->ioctl(tty, file, cmd, arg);
3271 if (retval == -ENOIOCTLCMD)
3274 tty_ldisc_deref(ld);
3280 * This implements the "Secure Attention Key" --- the idea is to
3281 * prevent trojan horses by killing all processes associated with this
3282 * tty when the user hits the "Secure Attention Key". Required for
3283 * super-paranoid applications --- see the Orange Book for more details.
3285 * This code could be nicer; ideally it should send a HUP, wait a few
3286 * seconds, then send a INT, and then a KILL signal. But you then
3287 * have to coordinate with the init process, since all processes associated
3288 * with the current tty must be dead before the new getty is allowed
3291 * Now, if it would be correct ;-/ The current code has a nasty hole -
3292 * it doesn't catch files in flight. We may send the descriptor to ourselves
3293 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3295 * Nasty bug: do_SAK is being called in interrupt context. This can
3296 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3298 static void __do_SAK(void *arg)
3303 struct tty_struct *tty = arg;
3304 struct task_struct *g, *p;
3308 struct tty_ldisc *disc;
3309 struct fdtable *fdt;
3313 session = tty->session;
3315 /* We don't want an ldisc switch during this */
3316 disc = tty_ldisc_ref(tty);
3317 if (disc && disc->flush_buffer)
3318 disc->flush_buffer(tty);
3319 tty_ldisc_deref(disc);
3321 if (tty->driver->flush_buffer)
3322 tty->driver->flush_buffer(tty);
3324 read_lock(&tasklist_lock);
3325 /* Kill the entire session */
3326 do_each_task_pid(session, PIDTYPE_SID, p) {
3327 printk(KERN_NOTICE "SAK: killed process %d"
3328 " (%s): p->signal->session==tty->session\n",
3330 send_sig(SIGKILL, p, 1);
3331 } while_each_task_pid(session, PIDTYPE_SID, p);
3332 /* Now kill any processes that happen to have the
3335 do_each_thread(g, p) {
3336 if (p->signal->tty == tty) {
3337 printk(KERN_NOTICE "SAK: killed process %d"
3338 " (%s): p->signal->session==tty->session\n",
3340 send_sig(SIGKILL, p, 1);
3346 * We don't take a ref to the file, so we must
3347 * hold ->file_lock instead.
3349 spin_lock(&p->files->file_lock);
3350 fdt = files_fdtable(p->files);
3351 for (i=0; i < fdt->max_fds; i++) {
3352 filp = fcheck_files(p->files, i);
3355 if (filp->f_op->read == tty_read &&
3356 filp->private_data == tty) {
3357 printk(KERN_NOTICE "SAK: killed process %d"
3358 " (%s): fd#%d opened to the tty\n",
3359 p->pid, p->comm, i);
3360 force_sig(SIGKILL, p);
3364 spin_unlock(&p->files->file_lock);
3367 } while_each_thread(g, p);
3368 read_unlock(&tasklist_lock);
3373 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3374 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3375 * the values which we write to it will be identical to the values which it
3376 * already has. --akpm
3378 void do_SAK(struct tty_struct *tty)
3382 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
3383 schedule_work(&tty->SAK_work);
3386 EXPORT_SYMBOL(do_SAK);
3390 * @private_: tty structure passed from work queue.
3392 * This routine is called out of the software interrupt to flush data
3393 * from the buffer chain to the line discipline.
3395 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3396 * while invoking the line discipline receive_buf method. The
3397 * receive_buf method is single threaded for each tty instance.
3400 static void flush_to_ldisc(void *private_)
3402 struct tty_struct *tty = (struct tty_struct *) private_;
3403 unsigned long flags;
3404 struct tty_ldisc *disc;
3405 struct tty_buffer *tbuf, *head;
3407 unsigned char *flag_buf;
3409 disc = tty_ldisc_ref(tty);
3410 if (disc == NULL) /* !TTY_LDISC */
3413 spin_lock_irqsave(&tty->buf.lock, flags);
3414 head = tty->buf.head;
3416 tty->buf.head = NULL;
3418 int count = head->commit - head->read;
3420 if (head->next == NULL)
3424 tty_buffer_free(tty, tbuf);
3427 if (!tty->receive_room) {
3428 schedule_delayed_work(&tty->buf.work, 1);
3431 if (count > tty->receive_room)
3432 count = tty->receive_room;
3433 char_buf = head->char_buf_ptr + head->read;
3434 flag_buf = head->flag_buf_ptr + head->read;
3435 head->read += count;
3436 spin_unlock_irqrestore(&tty->buf.lock, flags);
3437 disc->receive_buf(tty, char_buf, flag_buf, count);
3438 spin_lock_irqsave(&tty->buf.lock, flags);
3440 tty->buf.head = head;
3442 spin_unlock_irqrestore(&tty->buf.lock, flags);
3444 tty_ldisc_deref(disc);
3448 * Routine which returns the baud rate of the tty
3450 * Note that the baud_table needs to be kept in sync with the
3451 * include/asm/termbits.h file.
3453 static int baud_table[] = {
3454 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3455 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3457 76800, 153600, 307200, 614400, 921600
3459 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3460 2500000, 3000000, 3500000, 4000000
3464 static int n_baud_table = ARRAY_SIZE(baud_table);
3467 * tty_termios_baud_rate
3468 * @termios: termios structure
3470 * Convert termios baud rate data into a speed. This should be called
3471 * with the termios lock held if this termios is a terminal termios
3472 * structure. May change the termios data.
3477 int tty_termios_baud_rate(struct termios *termios)
3481 cbaud = termios->c_cflag & CBAUD;
3483 if (cbaud & CBAUDEX) {
3486 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3487 termios->c_cflag &= ~CBAUDEX;
3491 return baud_table[cbaud];
3494 EXPORT_SYMBOL(tty_termios_baud_rate);
3497 * tty_get_baud_rate - get tty bit rates
3498 * @tty: tty to query
3500 * Returns the baud rate as an integer for this terminal. The
3501 * termios lock must be held by the caller and the terminal bit
3502 * flags may be updated.
3507 int tty_get_baud_rate(struct tty_struct *tty)
3509 int baud = tty_termios_baud_rate(tty->termios);
3511 if (baud == 38400 && tty->alt_speed) {
3513 printk(KERN_WARNING "Use of setserial/setrocket to "
3514 "set SPD_* flags is deprecated\n");
3517 baud = tty->alt_speed;
3523 EXPORT_SYMBOL(tty_get_baud_rate);
3526 * tty_flip_buffer_push - terminal
3529 * Queue a push of the terminal flip buffers to the line discipline. This
3530 * function must not be called from IRQ context if tty->low_latency is set.
3532 * In the event of the queue being busy for flipping the work will be
3533 * held off and retried later.
3535 * Locking: tty buffer lock. Driver locks in low latency mode.
3538 void tty_flip_buffer_push(struct tty_struct *tty)
3540 unsigned long flags;
3541 spin_lock_irqsave(&tty->buf.lock, flags);
3542 if (tty->buf.tail != NULL)
3543 tty->buf.tail->commit = tty->buf.tail->used;
3544 spin_unlock_irqrestore(&tty->buf.lock, flags);
3546 if (tty->low_latency)
3547 flush_to_ldisc((void *) tty);
3549 schedule_delayed_work(&tty->buf.work, 1);
3552 EXPORT_SYMBOL(tty_flip_buffer_push);
3556 * initialize_tty_struct
3557 * @tty: tty to initialize
3559 * This subroutine initializes a tty structure that has been newly
3562 * Locking: none - tty in question must not be exposed at this point
3565 static void initialize_tty_struct(struct tty_struct *tty)
3567 memset(tty, 0, sizeof(struct tty_struct));
3568 tty->magic = TTY_MAGIC;
3569 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3571 tty->overrun_time = jiffies;
3572 tty->buf.head = tty->buf.tail = NULL;
3573 tty_buffer_init(tty);
3574 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
3575 init_MUTEX(&tty->buf.pty_sem);
3576 init_MUTEX(&tty->termios_sem);
3577 init_waitqueue_head(&tty->write_wait);
3578 init_waitqueue_head(&tty->read_wait);
3579 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
3580 mutex_init(&tty->atomic_read_lock);
3581 mutex_init(&tty->atomic_write_lock);
3582 spin_lock_init(&tty->read_lock);
3583 INIT_LIST_HEAD(&tty->tty_files);
3584 INIT_WORK(&tty->SAK_work, NULL, NULL);
3588 * The default put_char routine if the driver did not define one.
3591 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3593 tty->driver->write(tty, &ch, 1);
3596 static struct class *tty_class;
3599 * tty_register_device - register a tty device
3600 * @driver: the tty driver that describes the tty device
3601 * @index: the index in the tty driver for this tty device
3602 * @device: a struct device that is associated with this tty device.
3603 * This field is optional, if there is no known struct device
3604 * for this tty device it can be set to NULL safely.
3606 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
3608 * This call is required to be made to register an individual tty device
3609 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3610 * that bit is not set, this function should not be called by a tty
3616 struct class_device *tty_register_device(struct tty_driver *driver,
3617 unsigned index, struct device *device)
3620 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3622 if (index >= driver->num) {
3623 printk(KERN_ERR "Attempt to register invalid tty line number "
3625 return ERR_PTR(-EINVAL);
3628 if (driver->type == TTY_DRIVER_TYPE_PTY)
3629 pty_line_name(driver, index, name);
3631 tty_line_name(driver, index, name);
3633 return class_device_create(tty_class, NULL, dev, device, "%s", name);
3637 * tty_unregister_device - unregister a tty device
3638 * @driver: the tty driver that describes the tty device
3639 * @index: the index in the tty driver for this tty device
3641 * If a tty device is registered with a call to tty_register_device() then
3642 * this function must be called when the tty device is gone.
3647 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3649 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3652 EXPORT_SYMBOL(tty_register_device);
3653 EXPORT_SYMBOL(tty_unregister_device);
3655 struct tty_driver *alloc_tty_driver(int lines)
3657 struct tty_driver *driver;
3659 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3661 memset(driver, 0, sizeof(struct tty_driver));
3662 driver->magic = TTY_DRIVER_MAGIC;
3663 driver->num = lines;
3664 /* later we'll move allocation of tables here */
3669 void put_tty_driver(struct tty_driver *driver)
3674 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3676 driver->open = op->open;
3677 driver->close = op->close;
3678 driver->write = op->write;
3679 driver->put_char = op->put_char;
3680 driver->flush_chars = op->flush_chars;
3681 driver->write_room = op->write_room;
3682 driver->chars_in_buffer = op->chars_in_buffer;
3683 driver->ioctl = op->ioctl;
3684 driver->set_termios = op->set_termios;
3685 driver->throttle = op->throttle;
3686 driver->unthrottle = op->unthrottle;
3687 driver->stop = op->stop;
3688 driver->start = op->start;
3689 driver->hangup = op->hangup;
3690 driver->break_ctl = op->break_ctl;
3691 driver->flush_buffer = op->flush_buffer;
3692 driver->set_ldisc = op->set_ldisc;
3693 driver->wait_until_sent = op->wait_until_sent;
3694 driver->send_xchar = op->send_xchar;
3695 driver->read_proc = op->read_proc;
3696 driver->write_proc = op->write_proc;
3697 driver->tiocmget = op->tiocmget;
3698 driver->tiocmset = op->tiocmset;
3702 EXPORT_SYMBOL(alloc_tty_driver);
3703 EXPORT_SYMBOL(put_tty_driver);
3704 EXPORT_SYMBOL(tty_set_operations);
3707 * Called by a tty driver to register itself.
3709 int tty_register_driver(struct tty_driver *driver)
3716 if (driver->flags & TTY_DRIVER_INSTALLED)
3719 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3720 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3723 memset(p, 0, driver->num * 3 * sizeof(void *));
3726 if (!driver->major) {
3727 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3728 (char*)driver->name);
3730 driver->major = MAJOR(dev);
3731 driver->minor_start = MINOR(dev);
3734 dev = MKDEV(driver->major, driver->minor_start);
3735 error = register_chrdev_region(dev, driver->num,
3736 (char*)driver->name);
3744 driver->ttys = (struct tty_struct **)p;
3745 driver->termios = (struct termios **)(p + driver->num);
3746 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3748 driver->ttys = NULL;
3749 driver->termios = NULL;
3750 driver->termios_locked = NULL;
3753 cdev_init(&driver->cdev, &tty_fops);
3754 driver->cdev.owner = driver->owner;
3755 error = cdev_add(&driver->cdev, dev, driver->num);
3757 unregister_chrdev_region(dev, driver->num);
3758 driver->ttys = NULL;
3759 driver->termios = driver->termios_locked = NULL;
3764 if (!driver->put_char)
3765 driver->put_char = tty_default_put_char;
3767 list_add(&driver->tty_drivers, &tty_drivers);
3769 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3770 for(i = 0; i < driver->num; i++)
3771 tty_register_device(driver, i, NULL);
3773 proc_tty_register_driver(driver);
3777 EXPORT_SYMBOL(tty_register_driver);
3780 * Called by a tty driver to unregister itself.
3782 int tty_unregister_driver(struct tty_driver *driver)
3788 if (driver->refcount)
3791 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3794 list_del(&driver->tty_drivers);
3797 * Free the termios and termios_locked structures because
3798 * we don't want to get memory leaks when modular tty
3799 * drivers are removed from the kernel.
3801 for (i = 0; i < driver->num; i++) {
3802 tp = driver->termios[i];
3804 driver->termios[i] = NULL;
3807 tp = driver->termios_locked[i];
3809 driver->termios_locked[i] = NULL;
3812 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3813 tty_unregister_device(driver, i);
3816 proc_tty_unregister_driver(driver);
3817 driver->ttys = NULL;
3818 driver->termios = driver->termios_locked = NULL;
3820 cdev_del(&driver->cdev);
3824 EXPORT_SYMBOL(tty_unregister_driver);
3828 * Initialize the console device. This is called *early*, so
3829 * we can't necessarily depend on lots of kernel help here.
3830 * Just do some early initializations, and do the complex setup
3833 void __init console_init(void)
3837 /* Setup the default TTY line discipline. */
3838 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3841 * set up the console device so that later boot sequences can
3842 * inform about problems etc..
3844 #ifdef CONFIG_EARLY_PRINTK
3845 disable_early_printk();
3847 call = __con_initcall_start;
3848 while (call < __con_initcall_end) {
3855 extern int vty_init(void);
3858 static int __init tty_class_init(void)
3860 tty_class = class_create(THIS_MODULE, "tty");
3861 if (IS_ERR(tty_class))
3862 return PTR_ERR(tty_class);
3866 postcore_initcall(tty_class_init);
3868 /* 3/2004 jmc: why do these devices exist? */
3870 static struct cdev tty_cdev, console_cdev;
3871 #ifdef CONFIG_UNIX98_PTYS
3872 static struct cdev ptmx_cdev;
3875 static struct cdev vc0_cdev;
3879 * Ok, now we can initialize the rest of the tty devices and can count
3880 * on memory allocations, interrupts etc..
3882 static int __init tty_init(void)
3884 cdev_init(&tty_cdev, &tty_fops);
3885 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3886 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3887 panic("Couldn't register /dev/tty driver\n");
3888 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3890 cdev_init(&console_cdev, &console_fops);
3891 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3892 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3893 panic("Couldn't register /dev/console driver\n");
3894 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3896 #ifdef CONFIG_UNIX98_PTYS
3897 cdev_init(&ptmx_cdev, &ptmx_fops);
3898 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3899 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3900 panic("Couldn't register /dev/ptmx driver\n");
3901 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3905 cdev_init(&vc0_cdev, &console_fops);
3906 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3907 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3908 panic("Couldn't register /dev/tty0 driver\n");
3909 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3915 module_init(tty_init);