2 * linux/drivers/char/tty_io.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
8 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9 * or rs-channels. It also implements echoing, cooked mode etc.
11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
13 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14 * tty_struct and tty_queue structures. Previously there was an array
15 * of 256 tty_struct's which was statically allocated, and the
16 * tty_queue structures were allocated at boot time. Both are now
17 * dynamically allocated only when the tty is open.
19 * Also restructured routines so that there is more of a separation
20 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21 * the low-level tty routines (serial.c, pty.c, console.c). This
22 * makes for cleaner and more compact code. -TYT, 9/17/92
24 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25 * which can be dynamically activated and de-activated by the line
26 * discipline handling modules (like SLIP).
28 * NOTE: pay no attention to the line discipline code (yet); its
29 * interface is still subject to change in this version...
32 * Added functionality to the OPOST tty handling. No delays, but all
33 * other bits should be there.
34 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
36 * Rewrote canonical mode and added more termios flags.
37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
39 * Reorganized FASYNC support so mouse code can share it.
40 * -- ctm@ardi.com, 9Sep95
42 * New TIOCLINUX variants added.
43 * -- mj@k332.feld.cvut.cz, 19-Nov-95
45 * Restrict vt switching via ioctl()
46 * -- grif@cs.ucr.edu, 5-Dec-95
48 * Move console and virtual terminal code to more appropriate files,
49 * implement CONFIG_VT and generalize console device interface.
50 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
52 * Rewrote init_dev and release_dev to eliminate races.
53 * -- Bill Hawes <whawes@star.net>, June 97
55 * Added devfs support.
56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
58 * Added support for a Unix98-style ptmx device.
59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
61 * Reduced memory usage for older ARM systems
62 * -- Russell King <rmk@arm.linux.org.uk>
64 * Move do_SAK() into process context. Less stack use in devfs functions.
65 * alloc_tty_struct() always uses kmalloc() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
68 #include <linux/types.h>
69 #include <linux/major.h>
70 #include <linux/errno.h>
71 #include <linux/signal.h>
72 #include <linux/fcntl.h>
73 #include <linux/sched.h>
74 #include <linux/interrupt.h>
75 #include <linux/tty.h>
76 #include <linux/tty_driver.h>
77 #include <linux/tty_flip.h>
78 #include <linux/devpts_fs.h>
79 #include <linux/file.h>
80 #include <linux/console.h>
81 #include <linux/timer.h>
82 #include <linux/ctype.h>
85 #include <linux/string.h>
86 #include <linux/slab.h>
87 #include <linux/poll.h>
88 #include <linux/proc_fs.h>
89 #include <linux/init.h>
90 #include <linux/module.h>
91 #include <linux/smp_lock.h>
92 #include <linux/device.h>
93 #include <linux/idr.h>
94 #include <linux/wait.h>
95 #include <linux/bitops.h>
96 #include <linux/delay.h>
98 #include <asm/uaccess.h>
99 #include <asm/system.h>
101 #include <linux/kbd_kern.h>
102 #include <linux/vt_kern.h>
103 #include <linux/selection.h>
105 #include <linux/kmod.h>
106 #include <linux/vs_base.h>
107 #include <linux/vs_cvirt.h>
109 #undef TTY_DEBUG_HANGUP
111 #define TTY_PARANOIA_CHECK 1
112 #define CHECK_TTY_COUNT 1
114 struct termios tty_std_termios = { /* for the benefit of tty drivers */
115 .c_iflag = ICRNL | IXON,
116 .c_oflag = OPOST | ONLCR,
117 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
118 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
119 ECHOCTL | ECHOKE | IEXTEN,
123 EXPORT_SYMBOL(tty_std_termios);
125 /* This list gets poked at by procfs and various bits of boot up code. This
126 could do with some rationalisation such as pulling the tty proc function
129 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131 /* Mutex to protect creating and releasing a tty. This is shared with
132 vt.c for deeply disgusting hack reasons */
133 DEFINE_MUTEX(tty_mutex);
134 EXPORT_SYMBOL(tty_mutex);
136 #ifdef CONFIG_UNIX98_PTYS
137 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
138 extern int pty_limit; /* Config limit on Unix98 ptys */
139 static DEFINE_IDR(allocated_ptys);
140 static DECLARE_MUTEX(allocated_ptys_lock);
141 static int ptmx_open(struct inode *, struct file *);
144 extern void disable_early_printk(void);
146 static void initialize_tty_struct(struct tty_struct *tty);
148 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
149 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
150 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
151 static unsigned int tty_poll(struct file *, poll_table *);
152 static int tty_open(struct inode *, struct file *);
153 static int tty_release(struct inode *, struct file *);
154 int tty_ioctl(struct inode * inode, struct file * file,
155 unsigned int cmd, unsigned long arg);
156 static int tty_fasync(int fd, struct file * filp, int on);
157 static void release_mem(struct tty_struct *tty, int idx);
160 * alloc_tty_struct - allocate a tty object
162 * Return a new empty tty structure. The data fields have not
163 * been initialized in any way but has been zeroed
168 static struct tty_struct *alloc_tty_struct(void)
170 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
173 static void tty_buffer_free_all(struct tty_struct *);
176 * free_tty_struct - free a disused tty
177 * @tty: tty struct to free
179 * Free the write buffers, tty queue and tty memory itself.
181 * Locking: none. Must be called after tty is definitely unused
184 static inline void free_tty_struct(struct tty_struct *tty)
186 kfree(tty->write_buf);
187 tty_buffer_free_all(tty);
191 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
194 * tty_name - return tty naming
195 * @tty: tty structure
196 * @buf: buffer for output
198 * Convert a tty structure into a name. The name reflects the kernel
199 * naming policy and if udev is in use may not reflect user space
204 char *tty_name(struct tty_struct *tty, char *buf)
206 if (!tty) /* Hmm. NULL pointer. That's fun. */
207 strcpy(buf, "NULL tty");
209 strcpy(buf, tty->name);
213 EXPORT_SYMBOL(tty_name);
215 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
218 #ifdef TTY_PARANOIA_CHECK
221 "null TTY for (%d:%d) in %s\n",
222 imajor(inode), iminor(inode), routine);
225 if (tty->magic != TTY_MAGIC) {
227 "bad magic number for tty struct (%d:%d) in %s\n",
228 imajor(inode), iminor(inode), routine);
235 static int check_tty_count(struct tty_struct *tty, const char *routine)
237 #ifdef CHECK_TTY_COUNT
242 list_for_each(p, &tty->tty_files) {
246 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
247 tty->driver->subtype == PTY_TYPE_SLAVE &&
248 tty->link && tty->link->count)
250 if (tty->count != count) {
251 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
252 "!= #fd's(%d) in %s\n",
253 tty->name, tty->count, count, routine);
261 * Tty buffer allocation management
265 * tty_buffer_free_all - free buffers used by a tty
266 * @tty: tty to free from
268 * Remove all the buffers pending on a tty whether queued with data
269 * or in the free ring. Must be called when the tty is no longer in use
274 static void tty_buffer_free_all(struct tty_struct *tty)
276 struct tty_buffer *thead;
277 while((thead = tty->buf.head) != NULL) {
278 tty->buf.head = thead->next;
281 while((thead = tty->buf.free) != NULL) {
282 tty->buf.free = thead->next;
285 tty->buf.tail = NULL;
286 tty->buf.memory_used = 0;
290 * tty_buffer_init - prepare a tty buffer structure
291 * @tty: tty to initialise
293 * Set up the initial state of the buffer management for a tty device.
294 * Must be called before the other tty buffer functions are used.
299 static void tty_buffer_init(struct tty_struct *tty)
301 spin_lock_init(&tty->buf.lock);
302 tty->buf.head = NULL;
303 tty->buf.tail = NULL;
304 tty->buf.free = NULL;
305 tty->buf.memory_used = 0;
309 * tty_buffer_alloc - allocate a tty buffer
311 * @size: desired size (characters)
313 * Allocate a new tty buffer to hold the desired number of characters.
314 * Return NULL if out of memory or the allocation would exceed the
317 * Locking: Caller must hold tty->buf.lock
320 static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
322 struct tty_buffer *p;
324 if (tty->buf.memory_used + size > 65536)
326 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
334 p->char_buf_ptr = (char *)(p->data);
335 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
336 tty->buf.memory_used += size;
341 * tty_buffer_free - free a tty buffer
342 * @tty: tty owning the buffer
343 * @b: the buffer to free
345 * Free a tty buffer, or add it to the free list according to our
348 * Locking: Caller must hold tty->buf.lock
351 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
353 /* Dumb strategy for now - should keep some stats */
354 tty->buf.memory_used -= b->size;
355 WARN_ON(tty->buf.memory_used < 0);
360 b->next = tty->buf.free;
366 * tty_buffer_find - find a free tty buffer
367 * @tty: tty owning the buffer
368 * @size: characters wanted
370 * Locate an existing suitable tty buffer or if we are lacking one then
371 * allocate a new one. We round our buffers off in 256 character chunks
372 * to get better allocation behaviour.
374 * Locking: Caller must hold tty->buf.lock
377 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
379 struct tty_buffer **tbh = &tty->buf.free;
380 while((*tbh) != NULL) {
381 struct tty_buffer *t = *tbh;
382 if(t->size >= size) {
388 tty->buf.memory_used += t->size;
391 tbh = &((*tbh)->next);
393 /* Round the buffer size out */
394 size = (size + 0xFF) & ~ 0xFF;
395 return tty_buffer_alloc(tty, size);
396 /* Should possibly check if this fails for the largest buffer we
397 have queued and recycle that ? */
401 * tty_buffer_request_room - grow tty buffer if needed
402 * @tty: tty structure
403 * @size: size desired
405 * Make at least size bytes of linear space available for the tty
406 * buffer. If we fail return the size we managed to find.
408 * Locking: Takes tty->buf.lock
410 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
412 struct tty_buffer *b, *n;
416 spin_lock_irqsave(&tty->buf.lock, flags);
418 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
419 remove this conditional if its worth it. This would be invisible
421 if ((b = tty->buf.tail) != NULL)
422 left = b->size - b->used;
427 /* This is the slow path - looking for new buffers to use */
428 if ((n = tty_buffer_find(tty, size)) != NULL) {
439 spin_unlock_irqrestore(&tty->buf.lock, flags);
442 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
445 * tty_insert_flip_string - Add characters to the tty buffer
446 * @tty: tty structure
450 * Queue a series of bytes to the tty buffering. All the characters
451 * passed are marked as without error. Returns the number added.
453 * Locking: Called functions may take tty->buf.lock
456 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
461 int space = tty_buffer_request_room(tty, size - copied);
462 struct tty_buffer *tb = tty->buf.tail;
463 /* If there is no space then tb may be NULL */
464 if(unlikely(space == 0))
466 memcpy(tb->char_buf_ptr + tb->used, chars, space);
467 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
471 /* There is a small chance that we need to split the data over
472 several buffers. If this is the case we must loop */
473 } while (unlikely(size > copied));
476 EXPORT_SYMBOL(tty_insert_flip_string);
479 * tty_insert_flip_string_flags - Add characters to the tty buffer
480 * @tty: tty structure
485 * Queue a series of bytes to the tty buffering. For each character
486 * the flags array indicates the status of the character. Returns the
489 * Locking: Called functions may take tty->buf.lock
492 int tty_insert_flip_string_flags(struct tty_struct *tty,
493 const unsigned char *chars, const char *flags, size_t size)
497 int space = tty_buffer_request_room(tty, size - copied);
498 struct tty_buffer *tb = tty->buf.tail;
499 /* If there is no space then tb may be NULL */
500 if(unlikely(space == 0))
502 memcpy(tb->char_buf_ptr + tb->used, chars, space);
503 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
508 /* There is a small chance that we need to split the data over
509 several buffers. If this is the case we must loop */
510 } while (unlikely(size > copied));
513 EXPORT_SYMBOL(tty_insert_flip_string_flags);
516 * tty_schedule_flip - push characters to ldisc
517 * @tty: tty to push from
519 * Takes any pending buffers and transfers their ownership to the
520 * ldisc side of the queue. It then schedules those characters for
521 * processing by the line discipline.
523 * Locking: Takes tty->buf.lock
526 void tty_schedule_flip(struct tty_struct *tty)
529 spin_lock_irqsave(&tty->buf.lock, flags);
530 if (tty->buf.tail != NULL)
531 tty->buf.tail->commit = tty->buf.tail->used;
532 spin_unlock_irqrestore(&tty->buf.lock, flags);
533 schedule_delayed_work(&tty->buf.work, 1);
535 EXPORT_SYMBOL(tty_schedule_flip);
538 * tty_prepare_flip_string - make room for characters
540 * @chars: return pointer for character write area
541 * @size: desired size
543 * Prepare a block of space in the buffer for data. Returns the length
544 * available and buffer pointer to the space which is now allocated and
545 * accounted for as ready for normal characters. This is used for drivers
546 * that need their own block copy routines into the buffer. There is no
547 * guarantee the buffer is a DMA target!
549 * Locking: May call functions taking tty->buf.lock
552 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
554 int space = tty_buffer_request_room(tty, size);
556 struct tty_buffer *tb = tty->buf.tail;
557 *chars = tb->char_buf_ptr + tb->used;
558 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
564 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
567 * tty_prepare_flip_string_flags - make room for characters
569 * @chars: return pointer for character write area
570 * @flags: return pointer for status flag write area
571 * @size: desired size
573 * Prepare a block of space in the buffer for data. Returns the length
574 * available and buffer pointer to the space which is now allocated and
575 * accounted for as ready for characters. This is used for drivers
576 * that need their own block copy routines into the buffer. There is no
577 * guarantee the buffer is a DMA target!
579 * Locking: May call functions taking tty->buf.lock
582 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
584 int space = tty_buffer_request_room(tty, size);
586 struct tty_buffer *tb = tty->buf.tail;
587 *chars = tb->char_buf_ptr + tb->used;
588 *flags = tb->flag_buf_ptr + tb->used;
594 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
599 * tty_set_termios_ldisc - set ldisc field
600 * @tty: tty structure
601 * @num: line discipline number
603 * This is probably overkill for real world processors but
604 * they are not on hot paths so a little discipline won't do
607 * Locking: takes termios_mutex
610 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
612 mutex_lock(&tty->termios_mutex);
613 tty->termios->c_line = num;
614 mutex_unlock(&tty->termios_mutex);
618 * This guards the refcounted line discipline lists. The lock
619 * must be taken with irqs off because there are hangup path
620 * callers who will do ldisc lookups and cannot sleep.
623 static DEFINE_SPINLOCK(tty_ldisc_lock);
624 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
625 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
628 * tty_register_ldisc - install a line discipline
629 * @disc: ldisc number
630 * @new_ldisc: pointer to the ldisc object
632 * Installs a new line discipline into the kernel. The discipline
633 * is set up as unreferenced and then made available to the kernel
634 * from this point onwards.
637 * takes tty_ldisc_lock to guard against ldisc races
640 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
645 if (disc < N_TTY || disc >= NR_LDISCS)
648 spin_lock_irqsave(&tty_ldisc_lock, flags);
649 tty_ldiscs[disc] = *new_ldisc;
650 tty_ldiscs[disc].num = disc;
651 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
652 tty_ldiscs[disc].refcount = 0;
653 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
657 EXPORT_SYMBOL(tty_register_ldisc);
660 * tty_unregister_ldisc - unload a line discipline
661 * @disc: ldisc number
662 * @new_ldisc: pointer to the ldisc object
664 * Remove a line discipline from the kernel providing it is not
668 * takes tty_ldisc_lock to guard against ldisc races
671 int tty_unregister_ldisc(int disc)
676 if (disc < N_TTY || disc >= NR_LDISCS)
679 spin_lock_irqsave(&tty_ldisc_lock, flags);
680 if (tty_ldiscs[disc].refcount)
683 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
684 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
688 EXPORT_SYMBOL(tty_unregister_ldisc);
691 * tty_ldisc_get - take a reference to an ldisc
692 * @disc: ldisc number
694 * Takes a reference to a line discipline. Deals with refcounts and
695 * module locking counts. Returns NULL if the discipline is not available.
696 * Returns a pointer to the discipline and bumps the ref count if it is
700 * takes tty_ldisc_lock to guard against ldisc races
703 struct tty_ldisc *tty_ldisc_get(int disc)
706 struct tty_ldisc *ld;
708 if (disc < N_TTY || disc >= NR_LDISCS)
711 spin_lock_irqsave(&tty_ldisc_lock, flags);
713 ld = &tty_ldiscs[disc];
714 /* Check the entry is defined */
715 if(ld->flags & LDISC_FLAG_DEFINED)
717 /* If the module is being unloaded we can't use it */
718 if (!try_module_get(ld->owner))
725 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
729 EXPORT_SYMBOL_GPL(tty_ldisc_get);
732 * tty_ldisc_put - drop ldisc reference
733 * @disc: ldisc number
735 * Drop a reference to a line discipline. Manage refcounts and
736 * module usage counts
739 * takes tty_ldisc_lock to guard against ldisc races
742 void tty_ldisc_put(int disc)
744 struct tty_ldisc *ld;
747 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
749 spin_lock_irqsave(&tty_ldisc_lock, flags);
750 ld = &tty_ldiscs[disc];
751 BUG_ON(ld->refcount == 0);
753 module_put(ld->owner);
754 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
757 EXPORT_SYMBOL_GPL(tty_ldisc_put);
760 * tty_ldisc_assign - set ldisc on a tty
761 * @tty: tty to assign
762 * @ld: line discipline
764 * Install an instance of a line discipline into a tty structure. The
765 * ldisc must have a reference count above zero to ensure it remains/
766 * The tty instance refcount starts at zero.
769 * Caller must hold references
772 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
775 tty->ldisc.refcount = 0;
779 * tty_ldisc_try - internal helper
782 * Make a single attempt to grab and bump the refcount on
783 * the tty ldisc. Return 0 on failure or 1 on success. This is
784 * used to implement both the waiting and non waiting versions
787 * Locking: takes tty_ldisc_lock
790 static int tty_ldisc_try(struct tty_struct *tty)
793 struct tty_ldisc *ld;
796 spin_lock_irqsave(&tty_ldisc_lock, flags);
798 if(test_bit(TTY_LDISC, &tty->flags))
803 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
808 * tty_ldisc_ref_wait - wait for the tty ldisc
811 * Dereference the line discipline for the terminal and take a
812 * reference to it. If the line discipline is in flux then
813 * wait patiently until it changes.
815 * Note: Must not be called from an IRQ/timer context. The caller
816 * must also be careful not to hold other locks that will deadlock
817 * against a discipline change, such as an existing ldisc reference
818 * (which we check for)
820 * Locking: call functions take tty_ldisc_lock
823 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
825 /* wait_event is a macro */
826 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
827 if(tty->ldisc.refcount == 0)
828 printk(KERN_ERR "tty_ldisc_ref_wait\n");
832 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
835 * tty_ldisc_ref - get the tty ldisc
838 * Dereference the line discipline for the terminal and take a
839 * reference to it. If the line discipline is in flux then
840 * return NULL. Can be called from IRQ and timer functions.
842 * Locking: called functions take tty_ldisc_lock
845 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
847 if(tty_ldisc_try(tty))
852 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
855 * tty_ldisc_deref - free a tty ldisc reference
856 * @ld: reference to free up
858 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
859 * be called in IRQ context.
861 * Locking: takes tty_ldisc_lock
864 void tty_ldisc_deref(struct tty_ldisc *ld)
870 spin_lock_irqsave(&tty_ldisc_lock, flags);
871 if(ld->refcount == 0)
872 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
875 if(ld->refcount == 0)
876 wake_up(&tty_ldisc_wait);
877 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
880 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
883 * tty_ldisc_enable - allow ldisc use
884 * @tty: terminal to activate ldisc on
886 * Set the TTY_LDISC flag when the line discipline can be called
887 * again. Do neccessary wakeups for existing sleepers.
889 * Note: nobody should set this bit except via this function. Clearing
890 * directly is allowed.
893 static void tty_ldisc_enable(struct tty_struct *tty)
895 set_bit(TTY_LDISC, &tty->flags);
896 wake_up(&tty_ldisc_wait);
900 * tty_set_ldisc - set line discipline
901 * @tty: the terminal to set
902 * @ldisc: the line discipline
904 * Set the discipline of a tty line. Must be called from a process
907 * Locking: takes tty_ldisc_lock.
908 * called functions take termios_mutex
911 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
914 struct tty_ldisc o_ldisc;
918 struct tty_ldisc *ld;
919 struct tty_struct *o_tty;
921 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
926 ld = tty_ldisc_get(ldisc);
927 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
928 /* Cyrus Durgin <cider@speakeasy.org> */
930 request_module("tty-ldisc-%d", ldisc);
931 ld = tty_ldisc_get(ldisc);
937 * No more input please, we are switching. The new ldisc
938 * will update this value in the ldisc open function
941 tty->receive_room = 0;
944 * Problem: What do we do if this blocks ?
947 tty_wait_until_sent(tty, 0);
949 if (tty->ldisc.num == ldisc) {
950 tty_ldisc_put(ldisc);
954 o_ldisc = tty->ldisc;
958 * Make sure we don't change while someone holds a
959 * reference to the line discipline. The TTY_LDISC bit
960 * prevents anyone taking a reference once it is clear.
961 * We need the lock to avoid racing reference takers.
964 spin_lock_irqsave(&tty_ldisc_lock, flags);
965 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
966 if(tty->ldisc.refcount) {
967 /* Free the new ldisc we grabbed. Must drop the lock
969 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
970 tty_ldisc_put(ldisc);
972 * There are several reasons we may be busy, including
973 * random momentary I/O traffic. We must therefore
974 * retry. We could distinguish between blocking ops
975 * and retries if we made tty_ldisc_wait() smarter. That
976 * is up for discussion.
978 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
982 if(o_tty && o_tty->ldisc.refcount) {
983 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
984 tty_ldisc_put(ldisc);
985 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
991 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
993 if (!test_bit(TTY_LDISC, &tty->flags)) {
994 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
995 tty_ldisc_put(ldisc);
996 ld = tty_ldisc_ref_wait(tty);
1001 clear_bit(TTY_LDISC, &tty->flags);
1003 clear_bit(TTY_LDISC, &o_tty->flags);
1004 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1007 * From this point on we know nobody has an ldisc
1008 * usage reference, nor can they obtain one until
1009 * we say so later on.
1012 work = cancel_delayed_work(&tty->buf.work);
1014 * Wait for ->hangup_work and ->buf.work handlers to terminate
1017 flush_scheduled_work();
1018 /* Shutdown the current discipline. */
1019 if (tty->ldisc.close)
1020 (tty->ldisc.close)(tty);
1022 /* Now set up the new line discipline. */
1023 tty_ldisc_assign(tty, ld);
1024 tty_set_termios_ldisc(tty, ldisc);
1025 if (tty->ldisc.open)
1026 retval = (tty->ldisc.open)(tty);
1028 tty_ldisc_put(ldisc);
1029 /* There is an outstanding reference here so this is safe */
1030 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1031 tty_set_termios_ldisc(tty, tty->ldisc.num);
1032 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1033 tty_ldisc_put(o_ldisc.num);
1034 /* This driver is always present */
1035 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1036 tty_set_termios_ldisc(tty, N_TTY);
1037 if (tty->ldisc.open) {
1038 int r = tty->ldisc.open(tty);
1041 panic("Couldn't open N_TTY ldisc for "
1043 tty_name(tty, buf), r);
1047 /* At this point we hold a reference to the new ldisc and a
1048 a reference to the old ldisc. If we ended up flipping back
1049 to the existing ldisc we have two references to it */
1051 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1052 tty->driver->set_ldisc(tty);
1054 tty_ldisc_put(o_ldisc.num);
1057 * Allow ldisc referencing to occur as soon as the driver
1058 * ldisc callback completes.
1061 tty_ldisc_enable(tty);
1063 tty_ldisc_enable(o_tty);
1065 /* Restart it in case no characters kick it off. Safe if
1068 schedule_delayed_work(&tty->buf.work, 1);
1073 * get_tty_driver - find device of a tty
1074 * @dev_t: device identifier
1075 * @index: returns the index of the tty
1077 * This routine returns a tty driver structure, given a device number
1078 * and also passes back the index number.
1080 * Locking: caller must hold tty_mutex
1083 static struct tty_driver *get_tty_driver(dev_t device, int *index)
1085 struct tty_driver *p;
1087 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1088 dev_t base = MKDEV(p->major, p->minor_start);
1089 if (device < base || device >= base + p->num)
1091 *index = device - base;
1098 * tty_check_change - check for POSIX terminal changes
1099 * @tty: tty to check
1101 * If we try to write to, or set the state of, a terminal and we're
1102 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1103 * ignored, go ahead and perform the operation. (POSIX 7.2)
1108 int tty_check_change(struct tty_struct * tty)
1110 if (current->signal->tty != tty)
1112 if (tty->pgrp <= 0) {
1113 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1116 if (process_group(current) == tty->pgrp)
1118 if (is_ignored(SIGTTOU))
1120 if (is_orphaned_pgrp(process_group(current)))
1122 (void) kill_pg(process_group(current), SIGTTOU, 1);
1123 return -ERESTARTSYS;
1126 EXPORT_SYMBOL(tty_check_change);
1128 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1129 size_t count, loff_t *ppos)
1134 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1135 size_t count, loff_t *ppos)
1140 /* No kernel lock held - none needed ;) */
1141 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1143 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1146 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1147 unsigned int cmd, unsigned long arg)
1149 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1152 static const struct file_operations tty_fops = {
1153 .llseek = no_llseek,
1159 .release = tty_release,
1160 .fasync = tty_fasync,
1163 #ifdef CONFIG_UNIX98_PTYS
1164 static const struct file_operations ptmx_fops = {
1165 .llseek = no_llseek,
1171 .release = tty_release,
1172 .fasync = tty_fasync,
1176 static const struct file_operations console_fops = {
1177 .llseek = no_llseek,
1179 .write = redirected_tty_write,
1183 .release = tty_release,
1184 .fasync = tty_fasync,
1187 static const struct file_operations hung_up_tty_fops = {
1188 .llseek = no_llseek,
1189 .read = hung_up_tty_read,
1190 .write = hung_up_tty_write,
1191 .poll = hung_up_tty_poll,
1192 .ioctl = hung_up_tty_ioctl,
1193 .release = tty_release,
1196 static DEFINE_SPINLOCK(redirect_lock);
1197 static struct file *redirect;
1200 * tty_wakeup - request more data
1203 * Internal and external helper for wakeups of tty. This function
1204 * informs the line discipline if present that the driver is ready
1205 * to receive more output data.
1208 void tty_wakeup(struct tty_struct *tty)
1210 struct tty_ldisc *ld;
1212 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1213 ld = tty_ldisc_ref(tty);
1215 if(ld->write_wakeup)
1216 ld->write_wakeup(tty);
1217 tty_ldisc_deref(ld);
1220 wake_up_interruptible(&tty->write_wait);
1223 EXPORT_SYMBOL_GPL(tty_wakeup);
1226 * tty_ldisc_flush - flush line discipline queue
1229 * Flush the line discipline queue (if any) for this tty. If there
1230 * is no line discipline active this is a no-op.
1233 void tty_ldisc_flush(struct tty_struct *tty)
1235 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1237 if(ld->flush_buffer)
1238 ld->flush_buffer(tty);
1239 tty_ldisc_deref(ld);
1243 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1246 * do_tty_hangup - actual handler for hangup events
1249 * This can be called by the "eventd" kernel thread. That is process
1250 * synchronous but doesn't hold any locks, so we need to make sure we
1251 * have the appropriate locks for what we're doing.
1253 * The hangup event clears any pending redirections onto the hung up
1254 * device. It ensures future writes will error and it does the needed
1255 * line discipline hangup and signal delivery. The tty object itself
1260 * redirect lock for undoing redirection
1261 * file list lock for manipulating list of ttys
1262 * tty_ldisc_lock from called functions
1263 * termios_mutex resetting termios data
1264 * tasklist_lock to walk task list for hangup event
1265 * ->siglock to protect ->signal/->sighand
1267 static void do_tty_hangup(void *data)
1269 struct tty_struct *tty = (struct tty_struct *) data;
1270 struct file * cons_filp = NULL;
1271 struct file *filp, *f = NULL;
1272 struct task_struct *p;
1273 struct tty_ldisc *ld;
1274 int closecount = 0, n;
1279 /* inuse_filps is protected by the single kernel lock */
1282 spin_lock(&redirect_lock);
1283 if (redirect && redirect->private_data == tty) {
1287 spin_unlock(&redirect_lock);
1289 check_tty_count(tty, "do_tty_hangup");
1291 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1292 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1293 if (filp->f_op->write == redirected_tty_write)
1295 if (filp->f_op->write != tty_write)
1298 tty_fasync(-1, filp, 0); /* can't block */
1299 filp->f_op = &hung_up_tty_fops;
1303 /* FIXME! What are the locking issues here? This may me overdoing things..
1304 * this question is especially important now that we've removed the irqlock. */
1306 ld = tty_ldisc_ref(tty);
1307 if(ld != NULL) /* We may have no line discipline at this point */
1309 if (ld->flush_buffer)
1310 ld->flush_buffer(tty);
1311 if (tty->driver->flush_buffer)
1312 tty->driver->flush_buffer(tty);
1313 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1315 ld->write_wakeup(tty);
1320 /* FIXME: Once we trust the LDISC code better we can wait here for
1321 ldisc completion and fix the driver call race */
1323 wake_up_interruptible(&tty->write_wait);
1324 wake_up_interruptible(&tty->read_wait);
1327 * Shutdown the current line discipline, and reset it to
1330 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1332 mutex_lock(&tty->termios_mutex);
1333 *tty->termios = tty->driver->init_termios;
1334 mutex_unlock(&tty->termios_mutex);
1337 /* Defer ldisc switch */
1338 /* tty_deferred_ldisc_switch(N_TTY);
1340 This should get done automatically when the port closes and
1341 tty_release is called */
1343 read_lock(&tasklist_lock);
1344 if (tty->session > 0) {
1345 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1346 spin_lock_irq(&p->sighand->siglock);
1347 if (p->signal->tty == tty)
1348 p->signal->tty = NULL;
1349 if (!p->signal->leader) {
1350 spin_unlock_irq(&p->sighand->siglock);
1353 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1354 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1356 p->signal->tty_old_pgrp = tty->pgrp;
1357 spin_unlock_irq(&p->sighand->siglock);
1358 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1360 read_unlock(&tasklist_lock);
1365 tty->ctrl_status = 0;
1367 * If one of the devices matches a console pointer, we
1368 * cannot just call hangup() because that will cause
1369 * tty->count and state->count to go out of sync.
1370 * So we just call close() the right number of times.
1373 if (tty->driver->close)
1374 for (n = 0; n < closecount; n++)
1375 tty->driver->close(tty, cons_filp);
1376 } else if (tty->driver->hangup)
1377 (tty->driver->hangup)(tty);
1379 /* We don't want to have driver/ldisc interactions beyond
1380 the ones we did here. The driver layer expects no
1381 calls after ->hangup() from the ldisc side. However we
1382 can't yet guarantee all that */
1384 set_bit(TTY_HUPPED, &tty->flags);
1386 tty_ldisc_enable(tty);
1387 tty_ldisc_deref(ld);
1395 * tty_hangup - trigger a hangup event
1396 * @tty: tty to hangup
1398 * A carrier loss (virtual or otherwise) has occurred on this like
1399 * schedule a hangup sequence to run after this event.
1402 void tty_hangup(struct tty_struct * tty)
1404 #ifdef TTY_DEBUG_HANGUP
1407 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1409 schedule_work(&tty->hangup_work);
1412 EXPORT_SYMBOL(tty_hangup);
1415 * tty_vhangup - process vhangup
1416 * @tty: tty to hangup
1418 * The user has asked via system call for the terminal to be hung up.
1419 * We do this synchronously so that when the syscall returns the process
1420 * is complete. That guarantee is neccessary for security reasons.
1423 void tty_vhangup(struct tty_struct * tty)
1425 #ifdef TTY_DEBUG_HANGUP
1428 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1430 do_tty_hangup((void *) tty);
1432 EXPORT_SYMBOL(tty_vhangup);
1435 * tty_hung_up_p - was tty hung up
1436 * @filp: file pointer of tty
1438 * Return true if the tty has been subject to a vhangup or a carrier
1442 int tty_hung_up_p(struct file * filp)
1444 return (filp->f_op == &hung_up_tty_fops);
1447 EXPORT_SYMBOL(tty_hung_up_p);
1449 static void session_clear_tty(pid_t session)
1451 struct task_struct *p;
1452 do_each_task_pid(session, PIDTYPE_SID, p) {
1454 } while_each_task_pid(session, PIDTYPE_SID, p);
1458 * disassociate_ctty - disconnect controlling tty
1459 * @on_exit: true if exiting so need to "hang up" the session
1461 * This function is typically called only by the session leader, when
1462 * it wants to disassociate itself from its controlling tty.
1464 * It performs the following functions:
1465 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1466 * (2) Clears the tty from being controlling the session
1467 * (3) Clears the controlling tty for all processes in the
1470 * The argument on_exit is set to 1 if called when a process is
1471 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1474 * BKL is taken for hysterical raisins
1475 * tty_mutex is taken to protect tty
1476 * ->siglock is taken to protect ->signal/->sighand
1477 * tasklist_lock is taken to walk process list for sessions
1478 * ->siglock is taken to protect ->signal/->sighand
1481 void disassociate_ctty(int on_exit)
1483 struct tty_struct *tty;
1489 mutex_lock(&tty_mutex);
1490 tty = get_current_tty();
1492 tty_pgrp = tty->pgrp;
1493 mutex_unlock(&tty_mutex);
1494 /* XXX: here we race, there is nothing protecting tty */
1495 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1498 pid_t old_pgrp = current->signal->tty_old_pgrp;
1500 kill_pg(old_pgrp, SIGHUP, on_exit);
1501 kill_pg(old_pgrp, SIGCONT, on_exit);
1503 mutex_unlock(&tty_mutex);
1508 kill_pg(tty_pgrp, SIGHUP, on_exit);
1510 kill_pg(tty_pgrp, SIGCONT, on_exit);
1513 spin_lock_irq(¤t->sighand->siglock);
1514 current->signal->tty_old_pgrp = 0;
1515 session = current->signal->session;
1516 spin_unlock_irq(¤t->sighand->siglock);
1518 mutex_lock(&tty_mutex);
1519 /* It is possible that do_tty_hangup has free'd this tty */
1520 tty = get_current_tty();
1525 #ifdef TTY_DEBUG_HANGUP
1526 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
1530 mutex_unlock(&tty_mutex);
1532 /* Now clear signal->tty under the lock */
1533 read_lock(&tasklist_lock);
1534 session_clear_tty(session);
1535 read_unlock(&tasklist_lock);
1541 * stop_tty - propogate flow control
1544 * Perform flow control to the driver. For PTY/TTY pairs we
1545 * must also propogate the TIOCKPKT status. May be called
1546 * on an already stopped device and will not re-call the driver
1549 * This functionality is used by both the line disciplines for
1550 * halting incoming flow and by the driver. It may therefore be
1551 * called from any context, may be under the tty atomic_write_lock
1555 * Broken. Relies on BKL which is unsafe here.
1558 void stop_tty(struct tty_struct *tty)
1563 if (tty->link && tty->link->packet) {
1564 tty->ctrl_status &= ~TIOCPKT_START;
1565 tty->ctrl_status |= TIOCPKT_STOP;
1566 wake_up_interruptible(&tty->link->read_wait);
1568 if (tty->driver->stop)
1569 (tty->driver->stop)(tty);
1572 EXPORT_SYMBOL(stop_tty);
1575 * start_tty - propogate flow control
1576 * @tty: tty to start
1578 * Start a tty that has been stopped if at all possible. Perform
1579 * any neccessary wakeups and propogate the TIOCPKT status. If this
1580 * is the tty was previous stopped and is being started then the
1581 * driver start method is invoked and the line discipline woken.
1584 * Broken. Relies on BKL which is unsafe here.
1587 void start_tty(struct tty_struct *tty)
1589 if (!tty->stopped || tty->flow_stopped)
1592 if (tty->link && tty->link->packet) {
1593 tty->ctrl_status &= ~TIOCPKT_STOP;
1594 tty->ctrl_status |= TIOCPKT_START;
1595 wake_up_interruptible(&tty->link->read_wait);
1597 if (tty->driver->start)
1598 (tty->driver->start)(tty);
1600 /* If we have a running line discipline it may need kicking */
1602 wake_up_interruptible(&tty->write_wait);
1605 EXPORT_SYMBOL(start_tty);
1608 * tty_read - read method for tty device files
1609 * @file: pointer to tty file
1611 * @count: size of user buffer
1614 * Perform the read system call function on this terminal device. Checks
1615 * for hung up devices before calling the line discipline method.
1618 * Locks the line discipline internally while needed
1619 * For historical reasons the line discipline read method is
1620 * invoked under the BKL. This will go away in time so do not rely on it
1621 * in new code. Multiple read calls may be outstanding in parallel.
1624 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1628 struct tty_struct * tty;
1629 struct inode *inode;
1630 struct tty_ldisc *ld;
1632 tty = (struct tty_struct *)file->private_data;
1633 inode = file->f_dentry->d_inode;
1634 if (tty_paranoia_check(tty, inode, "tty_read"))
1636 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1639 /* We want to wait for the line discipline to sort out in this
1641 ld = tty_ldisc_ref_wait(tty);
1644 i = (ld->read)(tty,file,buf,count);
1647 tty_ldisc_deref(ld);
1650 inode->i_atime = current_fs_time(inode->i_sb);
1655 * Split writes up in sane blocksizes to avoid
1656 * denial-of-service type attacks
1658 static inline ssize_t do_tty_write(
1659 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1660 struct tty_struct *tty,
1662 const char __user *buf,
1665 ssize_t ret = 0, written = 0;
1668 /* FIXME: O_NDELAY ... */
1669 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1670 return -ERESTARTSYS;
1674 * We chunk up writes into a temporary buffer. This
1675 * simplifies low-level drivers immensely, since they
1676 * don't have locking issues and user mode accesses.
1678 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1681 * The default chunk-size is 2kB, because the NTTY
1682 * layer has problems with bigger chunks. It will
1683 * claim to be able to handle more characters than
1686 * FIXME: This can probably go away now except that 64K chunks
1687 * are too likely to fail unless switched to vmalloc...
1690 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1695 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1696 if (tty->write_cnt < chunk) {
1702 buf = kmalloc(chunk, GFP_KERNEL);
1704 mutex_unlock(&tty->atomic_write_lock);
1707 kfree(tty->write_buf);
1708 tty->write_cnt = chunk;
1709 tty->write_buf = buf;
1712 /* Do the write .. */
1714 size_t size = count;
1718 if (copy_from_user(tty->write_buf, buf, size))
1721 ret = write(tty, file, tty->write_buf, size);
1731 if (signal_pending(current))
1736 struct inode *inode = file->f_dentry->d_inode;
1737 inode->i_mtime = current_fs_time(inode->i_sb);
1740 mutex_unlock(&tty->atomic_write_lock);
1746 * tty_write - write method for tty device file
1747 * @file: tty file pointer
1748 * @buf: user data to write
1749 * @count: bytes to write
1752 * Write data to a tty device via the line discipline.
1755 * Locks the line discipline as required
1756 * Writes to the tty driver are serialized by the atomic_write_lock
1757 * and are then processed in chunks to the device. The line discipline
1758 * write method will not be involked in parallel for each device
1759 * The line discipline write method is called under the big
1760 * kernel lock for historical reasons. New code should not rely on this.
1763 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1766 struct tty_struct * tty;
1767 struct inode *inode = file->f_dentry->d_inode;
1769 struct tty_ldisc *ld;
1771 tty = (struct tty_struct *)file->private_data;
1772 if (tty_paranoia_check(tty, inode, "tty_write"))
1774 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1777 ld = tty_ldisc_ref_wait(tty);
1781 ret = do_tty_write(ld->write, tty, file, buf, count);
1782 tty_ldisc_deref(ld);
1786 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1789 struct file *p = NULL;
1791 spin_lock(&redirect_lock);
1796 spin_unlock(&redirect_lock);
1800 res = vfs_write(p, buf, count, &p->f_pos);
1805 return tty_write(file, buf, count, ppos);
1808 static char ptychar[] = "pqrstuvwxyzabcde";
1811 * pty_line_name - generate name for a pty
1812 * @driver: the tty driver in use
1813 * @index: the minor number
1814 * @p: output buffer of at least 6 bytes
1816 * Generate a name from a driver reference and write it to the output
1821 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1823 int i = index + driver->name_base;
1824 /* ->name is initialized to "ttyp", but "tty" is expected */
1825 sprintf(p, "%s%c%x",
1826 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1827 ptychar[i >> 4 & 0xf], i & 0xf);
1831 * pty_line_name - generate name for a tty
1832 * @driver: the tty driver in use
1833 * @index: the minor number
1834 * @p: output buffer of at least 7 bytes
1836 * Generate a name from a driver reference and write it to the output
1841 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1843 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1847 * init_dev - initialise a tty device
1848 * @driver: tty driver we are opening a device on
1849 * @idx: device index
1850 * @tty: returned tty structure
1852 * Prepare a tty device. This may not be a "new" clean device but
1853 * could also be an active device. The pty drivers require special
1854 * handling because of this.
1857 * The function is called under the tty_mutex, which
1858 * protects us from the tty struct or driver itself going away.
1860 * On exit the tty device has the line discipline attached and
1861 * a reference count of 1. If a pair was created for pty/tty use
1862 * and the other was a pty master then it too has a reference count of 1.
1864 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1865 * failed open. The new code protects the open with a mutex, so it's
1866 * really quite straightforward. The mutex locking can probably be
1867 * relaxed for the (most common) case of reopening a tty.
1870 static int init_dev(struct tty_driver *driver, int idx,
1871 struct tty_struct **ret_tty)
1873 struct tty_struct *tty, *o_tty;
1874 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1875 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1878 /* check whether we're reopening an existing tty */
1879 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1880 tty = devpts_get_tty(idx);
1881 if (tty && driver->subtype == PTY_TYPE_MASTER)
1884 tty = driver->ttys[idx];
1886 if (tty) goto fast_track;
1889 * First time open is complex, especially for PTY devices.
1890 * This code guarantees that either everything succeeds and the
1891 * TTY is ready for operation, or else the table slots are vacated
1892 * and the allocated memory released. (Except that the termios
1893 * and locked termios may be retained.)
1896 if (!try_module_get(driver->owner)) {
1905 tty = alloc_tty_struct();
1908 initialize_tty_struct(tty);
1909 tty->driver = driver;
1911 tty_line_name(driver, idx, tty->name);
1913 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1914 tp_loc = &tty->termios;
1915 ltp_loc = &tty->termios_locked;
1917 tp_loc = &driver->termios[idx];
1918 ltp_loc = &driver->termios_locked[idx];
1922 tp = (struct termios *) kmalloc(sizeof(struct termios),
1926 *tp = driver->init_termios;
1930 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1934 memset(ltp, 0, sizeof(struct termios));
1937 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1938 o_tty = alloc_tty_struct();
1941 initialize_tty_struct(o_tty);
1942 o_tty->driver = driver->other;
1944 tty_line_name(driver->other, idx, o_tty->name);
1946 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1947 o_tp_loc = &o_tty->termios;
1948 o_ltp_loc = &o_tty->termios_locked;
1950 o_tp_loc = &driver->other->termios[idx];
1951 o_ltp_loc = &driver->other->termios_locked[idx];
1955 o_tp = (struct termios *)
1956 kmalloc(sizeof(struct termios), GFP_KERNEL);
1959 *o_tp = driver->other->init_termios;
1963 o_ltp = (struct termios *)
1964 kmalloc(sizeof(struct termios), GFP_KERNEL);
1967 memset(o_ltp, 0, sizeof(struct termios));
1971 * Everything allocated ... set up the o_tty structure.
1973 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1974 driver->other->ttys[idx] = o_tty;
1980 o_tty->termios = *o_tp_loc;
1981 o_tty->termios_locked = *o_ltp_loc;
1982 driver->other->refcount++;
1983 if (driver->subtype == PTY_TYPE_MASTER)
1986 /* Establish the links in both directions */
1992 * All structures have been allocated, so now we install them.
1993 * Failures after this point use release_mem to clean up, so
1994 * there's no need to null out the local pointers.
1996 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1997 driver->ttys[idx] = tty;
2004 tty->termios = *tp_loc;
2005 tty->termios_locked = *ltp_loc;
2010 * Structures all installed ... call the ldisc open routines.
2011 * If we fail here just call release_mem to clean up. No need
2012 * to decrement the use counts, as release_mem doesn't care.
2015 if (tty->ldisc.open) {
2016 retval = (tty->ldisc.open)(tty);
2018 goto release_mem_out;
2020 if (o_tty && o_tty->ldisc.open) {
2021 retval = (o_tty->ldisc.open)(o_tty);
2023 if (tty->ldisc.close)
2024 (tty->ldisc.close)(tty);
2025 goto release_mem_out;
2027 tty_ldisc_enable(o_tty);
2029 tty_ldisc_enable(tty);
2033 * This fast open can be used if the tty is already open.
2034 * No memory is allocated, and the only failures are from
2035 * attempting to open a closing tty or attempting multiple
2036 * opens on a pty master.
2039 if (test_bit(TTY_CLOSING, &tty->flags)) {
2043 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2044 driver->subtype == PTY_TYPE_MASTER) {
2046 * special case for PTY masters: only one open permitted,
2047 * and the slave side open count is incremented as well.
2056 tty->driver = driver; /* N.B. why do this every time?? */
2059 if(!test_bit(TTY_LDISC, &tty->flags))
2060 printk(KERN_ERR "init_dev but no ldisc\n");
2064 /* All paths come through here to release the mutex */
2068 /* Release locally allocated memory ... nothing placed in slots */
2072 free_tty_struct(o_tty);
2075 free_tty_struct(tty);
2078 module_put(driver->owner);
2082 /* call the tty release_mem routine to clean out this slot */
2084 printk(KERN_INFO "init_dev: ldisc open failed, "
2085 "clearing slot %d\n", idx);
2086 release_mem(tty, idx);
2091 * release_mem - release tty structure memory
2093 * Releases memory associated with a tty structure, and clears out the
2094 * driver table slots. This function is called when a device is no longer
2095 * in use. It also gets called when setup of a device fails.
2098 * tty_mutex - sometimes only
2099 * takes the file list lock internally when working on the list
2100 * of ttys that the driver keeps.
2101 * FIXME: should we require tty_mutex is held here ??
2104 static void release_mem(struct tty_struct *tty, int idx)
2106 struct tty_struct *o_tty;
2108 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2110 if ((o_tty = tty->link) != NULL) {
2112 o_tty->driver->ttys[idx] = NULL;
2113 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2114 tp = o_tty->termios;
2116 o_tty->driver->termios[idx] = NULL;
2119 tp = o_tty->termios_locked;
2121 o_tty->driver->termios_locked[idx] = NULL;
2125 o_tty->driver->refcount--;
2127 list_del_init(&o_tty->tty_files);
2129 free_tty_struct(o_tty);
2133 tty->driver->ttys[idx] = NULL;
2134 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2137 tty->driver->termios[idx] = NULL;
2140 tp = tty->termios_locked;
2142 tty->driver->termios_locked[idx] = NULL;
2147 tty->driver->refcount--;
2149 list_del_init(&tty->tty_files);
2151 module_put(tty->driver->owner);
2152 free_tty_struct(tty);
2156 * Even releasing the tty structures is a tricky business.. We have
2157 * to be very careful that the structures are all released at the
2158 * same time, as interrupts might otherwise get the wrong pointers.
2160 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2161 * lead to double frees or releasing memory still in use.
2163 static void release_dev(struct file * filp)
2165 struct tty_struct *tty, *o_tty;
2166 int pty_master, tty_closing, o_tty_closing, do_sleep;
2170 unsigned long flags;
2172 tty = (struct tty_struct *)filp->private_data;
2173 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2176 check_tty_count(tty, "release_dev");
2178 tty_fasync(-1, filp, 0);
2181 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2182 tty->driver->subtype == PTY_TYPE_MASTER);
2183 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2186 #ifdef TTY_PARANOIA_CHECK
2187 if (idx < 0 || idx >= tty->driver->num) {
2188 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2189 "free (%s)\n", tty->name);
2192 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2193 if (tty != tty->driver->ttys[idx]) {
2194 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2195 "for (%s)\n", idx, tty->name);
2198 if (tty->termios != tty->driver->termios[idx]) {
2199 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2204 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2205 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2206 "termios_locked for (%s)\n",
2213 #ifdef TTY_DEBUG_HANGUP
2214 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2215 tty_name(tty, buf), tty->count);
2218 #ifdef TTY_PARANOIA_CHECK
2219 if (tty->driver->other &&
2220 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2221 if (o_tty != tty->driver->other->ttys[idx]) {
2222 printk(KERN_DEBUG "release_dev: other->table[%d] "
2223 "not o_tty for (%s)\n",
2227 if (o_tty->termios != tty->driver->other->termios[idx]) {
2228 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2229 "not o_termios for (%s)\n",
2233 if (o_tty->termios_locked !=
2234 tty->driver->other->termios_locked[idx]) {
2235 printk(KERN_DEBUG "release_dev: other->termios_locked["
2236 "%d] not o_termios_locked for (%s)\n",
2240 if (o_tty->link != tty) {
2241 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2246 if (tty->driver->close)
2247 tty->driver->close(tty, filp);
2250 * Sanity check: if tty->count is going to zero, there shouldn't be
2251 * any waiters on tty->read_wait or tty->write_wait. We test the
2252 * wait queues and kick everyone out _before_ actually starting to
2253 * close. This ensures that we won't block while releasing the tty
2256 * The test for the o_tty closing is necessary, since the master and
2257 * slave sides may close in any order. If the slave side closes out
2258 * first, its count will be one, since the master side holds an open.
2259 * Thus this test wouldn't be triggered at the time the slave closes,
2262 * Note that it's possible for the tty to be opened again while we're
2263 * flushing out waiters. By recalculating the closing flags before
2264 * each iteration we avoid any problems.
2267 /* Guard against races with tty->count changes elsewhere and
2268 opens on /dev/tty */
2270 mutex_lock(&tty_mutex);
2271 tty_closing = tty->count <= 1;
2272 o_tty_closing = o_tty &&
2273 (o_tty->count <= (pty_master ? 1 : 0));
2277 if (waitqueue_active(&tty->read_wait)) {
2278 wake_up(&tty->read_wait);
2281 if (waitqueue_active(&tty->write_wait)) {
2282 wake_up(&tty->write_wait);
2286 if (o_tty_closing) {
2287 if (waitqueue_active(&o_tty->read_wait)) {
2288 wake_up(&o_tty->read_wait);
2291 if (waitqueue_active(&o_tty->write_wait)) {
2292 wake_up(&o_tty->write_wait);
2299 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2300 "active!\n", tty_name(tty, buf));
2301 mutex_unlock(&tty_mutex);
2306 * The closing flags are now consistent with the open counts on
2307 * both sides, and we've completed the last operation that could
2308 * block, so it's safe to proceed with closing.
2311 if (--o_tty->count < 0) {
2312 printk(KERN_WARNING "release_dev: bad pty slave count "
2314 o_tty->count, tty_name(o_tty, buf));
2318 if (--tty->count < 0) {
2319 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2320 tty->count, tty_name(tty, buf));
2325 * We've decremented tty->count, so we need to remove this file
2326 * descriptor off the tty->tty_files list; this serves two
2328 * - check_tty_count sees the correct number of file descriptors
2329 * associated with this tty.
2330 * - do_tty_hangup no longer sees this file descriptor as
2331 * something that needs to be handled for hangups.
2334 filp->private_data = NULL;
2337 * Perform some housekeeping before deciding whether to return.
2339 * Set the TTY_CLOSING flag if this was the last open. In the
2340 * case of a pty we may have to wait around for the other side
2341 * to close, and TTY_CLOSING makes sure we can't be reopened.
2344 set_bit(TTY_CLOSING, &tty->flags);
2346 set_bit(TTY_CLOSING, &o_tty->flags);
2349 * If _either_ side is closing, make sure there aren't any
2350 * processes that still think tty or o_tty is their controlling
2353 if (tty_closing || o_tty_closing) {
2354 read_lock(&tasklist_lock);
2355 session_clear_tty(tty->session);
2357 session_clear_tty(o_tty->session);
2358 read_unlock(&tasklist_lock);
2361 mutex_unlock(&tty_mutex);
2363 /* check whether both sides are closing ... */
2364 if (!tty_closing || (o_tty && !o_tty_closing))
2367 #ifdef TTY_DEBUG_HANGUP
2368 printk(KERN_DEBUG "freeing tty structure...");
2371 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2372 * kill any delayed work. As this is the final close it does not
2373 * race with the set_ldisc code path.
2375 clear_bit(TTY_LDISC, &tty->flags);
2376 cancel_delayed_work(&tty->buf.work);
2379 * Wait for ->hangup_work and ->buf.work handlers to terminate
2382 flush_scheduled_work();
2385 * Wait for any short term users (we know they are just driver
2386 * side waiters as the file is closing so user count on the file
2389 spin_lock_irqsave(&tty_ldisc_lock, flags);
2390 while(tty->ldisc.refcount)
2392 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2393 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2394 spin_lock_irqsave(&tty_ldisc_lock, flags);
2396 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2398 * Shutdown the current line discipline, and reset it to N_TTY.
2399 * N.B. why reset ldisc when we're releasing the memory??
2401 * FIXME: this MUST get fixed for the new reflocking
2403 if (tty->ldisc.close)
2404 (tty->ldisc.close)(tty);
2405 tty_ldisc_put(tty->ldisc.num);
2408 * Switch the line discipline back
2410 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2411 tty_set_termios_ldisc(tty,N_TTY);
2413 /* FIXME: could o_tty be in setldisc here ? */
2414 clear_bit(TTY_LDISC, &o_tty->flags);
2415 if (o_tty->ldisc.close)
2416 (o_tty->ldisc.close)(o_tty);
2417 tty_ldisc_put(o_tty->ldisc.num);
2418 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2419 tty_set_termios_ldisc(o_tty,N_TTY);
2422 * The release_mem function takes care of the details of clearing
2423 * the slots and preserving the termios structure.
2425 release_mem(tty, idx);
2427 #ifdef CONFIG_UNIX98_PTYS
2428 /* Make this pty number available for reallocation */
2430 down(&allocated_ptys_lock);
2431 idr_remove(&allocated_ptys, idx);
2432 up(&allocated_ptys_lock);
2439 * tty_open - open a tty device
2440 * @inode: inode of device file
2441 * @filp: file pointer to tty
2443 * tty_open and tty_release keep up the tty count that contains the
2444 * number of opens done on a tty. We cannot use the inode-count, as
2445 * different inodes might point to the same tty.
2447 * Open-counting is needed for pty masters, as well as for keeping
2448 * track of serial lines: DTR is dropped when the last close happens.
2449 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2451 * The termios state of a pty is reset on first open so that
2452 * settings don't persist across reuse.
2454 * Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2455 * tty->count should protect the rest.
2456 * ->siglock protects ->signal/->sighand
2459 static int tty_open(struct inode * inode, struct file * filp)
2461 struct tty_struct *tty;
2463 struct tty_driver *driver;
2465 dev_t device = inode->i_rdev;
2466 unsigned short saved_flags = filp->f_flags;
2468 nonseekable_open(inode, filp);
2471 noctty = filp->f_flags & O_NOCTTY;
2475 mutex_lock(&tty_mutex);
2477 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2478 tty = get_current_tty();
2480 mutex_unlock(&tty_mutex);
2483 driver = tty->driver;
2485 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2490 if (device == MKDEV(TTY_MAJOR,0)) {
2491 extern struct tty_driver *console_driver;
2492 driver = console_driver;
2498 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2499 driver = console_device(&index);
2501 /* Don't let /dev/console block */
2502 filp->f_flags |= O_NONBLOCK;
2506 mutex_unlock(&tty_mutex);
2510 driver = get_tty_driver(device, &index);
2512 mutex_unlock(&tty_mutex);
2516 retval = init_dev(driver, index, &tty);
2517 mutex_unlock(&tty_mutex);
2521 filp->private_data = tty;
2522 file_move(filp, &tty->tty_files);
2523 check_tty_count(tty, "tty_open");
2524 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2525 tty->driver->subtype == PTY_TYPE_MASTER)
2527 #ifdef TTY_DEBUG_HANGUP
2528 printk(KERN_DEBUG "opening %s...", tty->name);
2531 if (tty->driver->open)
2532 retval = tty->driver->open(tty, filp);
2536 filp->f_flags = saved_flags;
2538 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2542 #ifdef TTY_DEBUG_HANGUP
2543 printk(KERN_DEBUG "error %d in opening %s...", retval,
2547 if (retval != -ERESTARTSYS)
2549 if (signal_pending(current))
2553 * Need to reset f_op in case a hangup happened.
2555 if (filp->f_op == &hung_up_tty_fops)
2556 filp->f_op = &tty_fops;
2560 mutex_lock(&tty_mutex);
2561 spin_lock_irq(¤t->sighand->siglock);
2563 current->signal->leader &&
2564 !current->signal->tty &&
2566 __proc_set_tty(current, tty);
2567 spin_unlock_irq(¤t->sighand->siglock);
2568 mutex_unlock(&tty_mutex);
2572 #ifdef CONFIG_UNIX98_PTYS
2574 * ptmx_open - open a unix 98 pty master
2575 * @inode: inode of device file
2576 * @filp: file pointer to tty
2578 * Allocate a unix98 pty master device from the ptmx driver.
2580 * Locking: tty_mutex protects theinit_dev work. tty->count should
2582 * allocated_ptys_lock handles the list of free pty numbers
2585 static int ptmx_open(struct inode * inode, struct file * filp)
2587 struct tty_struct *tty;
2592 nonseekable_open(inode, filp);
2594 /* find a device that is not in use. */
2595 down(&allocated_ptys_lock);
2596 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2597 up(&allocated_ptys_lock);
2600 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2602 up(&allocated_ptys_lock);
2603 if (idr_ret == -EAGAIN)
2607 if (index >= pty_limit) {
2608 idr_remove(&allocated_ptys, index);
2609 up(&allocated_ptys_lock);
2612 up(&allocated_ptys_lock);
2614 mutex_lock(&tty_mutex);
2615 retval = init_dev(ptm_driver, index, &tty);
2616 mutex_unlock(&tty_mutex);
2621 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2622 filp->private_data = tty;
2623 file_move(filp, &tty->tty_files);
2626 if (devpts_pty_new(tty->link))
2629 check_tty_count(tty, "tty_open");
2630 retval = ptm_driver->open(tty, filp);
2637 down(&allocated_ptys_lock);
2638 idr_remove(&allocated_ptys, index);
2639 up(&allocated_ptys_lock);
2645 * tty_release - vfs callback for close
2646 * @inode: inode of tty
2647 * @filp: file pointer for handle to tty
2649 * Called the last time each file handle is closed that references
2650 * this tty. There may however be several such references.
2653 * Takes bkl. See release_dev
2656 static int tty_release(struct inode * inode, struct file * filp)
2665 * tty_poll - check tty status
2666 * @filp: file being polled
2667 * @wait: poll wait structures to update
2669 * Call the line discipline polling method to obtain the poll
2670 * status of the device.
2672 * Locking: locks called line discipline but ldisc poll method
2673 * may be re-entered freely by other callers.
2676 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2678 struct tty_struct * tty;
2679 struct tty_ldisc *ld;
2682 tty = (struct tty_struct *)filp->private_data;
2683 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2686 ld = tty_ldisc_ref_wait(tty);
2688 ret = (ld->poll)(tty, filp, wait);
2689 tty_ldisc_deref(ld);
2693 static int tty_fasync(int fd, struct file * filp, int on)
2695 struct tty_struct * tty;
2698 tty = (struct tty_struct *)filp->private_data;
2699 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2702 retval = fasync_helper(fd, filp, on, &tty->fasync);
2707 if (!waitqueue_active(&tty->read_wait))
2708 tty->minimum_to_wake = 1;
2709 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2713 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2714 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2720 * tiocsti - fake input character
2721 * @tty: tty to fake input into
2722 * @p: pointer to character
2724 * Fake input to a tty device. Does the neccessary locking and
2727 * FIXME: does not honour flow control ??
2730 * Called functions take tty_ldisc_lock
2731 * current->signal->tty check is safe without locks
2733 * FIXME: may race normal receive processing
2736 static int tiocsti(struct tty_struct *tty, char __user *p)
2739 struct tty_ldisc *ld;
2741 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2743 if (get_user(ch, p))
2745 ld = tty_ldisc_ref_wait(tty);
2746 ld->receive_buf(tty, &ch, &mbz, 1);
2747 tty_ldisc_deref(ld);
2752 * tiocgwinsz - implement window query ioctl
2754 * @arg: user buffer for result
2756 * Copies the kernel idea of the window size into the user buffer.
2758 * Locking: tty->termios_mutex is taken to ensure the winsize data
2762 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2766 mutex_lock(&tty->termios_mutex);
2767 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2768 mutex_unlock(&tty->termios_mutex);
2770 return err ? -EFAULT: 0;
2774 * tiocswinsz - implement window size set ioctl
2776 * @arg: user buffer for result
2778 * Copies the user idea of the window size to the kernel. Traditionally
2779 * this is just advisory information but for the Linux console it
2780 * actually has driver level meaning and triggers a VC resize.
2783 * Called function use the console_sem is used to ensure we do
2784 * not try and resize the console twice at once.
2785 * The tty->termios_mutex is used to ensure we don't double
2786 * resize and get confused. Lock order - tty->termios_mutex before
2790 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2791 struct winsize __user * arg)
2793 struct winsize tmp_ws;
2795 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2798 mutex_lock(&tty->termios_mutex);
2799 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2803 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2804 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2806 mutex_unlock(&tty->termios_mutex);
2812 kill_pg(tty->pgrp, SIGWINCH, 1);
2813 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2814 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2815 tty->winsize = tmp_ws;
2816 real_tty->winsize = tmp_ws;
2818 mutex_unlock(&tty->termios_mutex);
2823 * tioccons - allow admin to move logical console
2824 * @file: the file to become console
2826 * Allow the adminstrator to move the redirected console device
2828 * Locking: uses redirect_lock to guard the redirect information
2831 static int tioccons(struct file *file)
2833 if (!capable(CAP_SYS_ADMIN))
2835 if (file->f_op->write == redirected_tty_write) {
2837 spin_lock(&redirect_lock);
2840 spin_unlock(&redirect_lock);
2845 spin_lock(&redirect_lock);
2847 spin_unlock(&redirect_lock);
2852 spin_unlock(&redirect_lock);
2857 * fionbio - non blocking ioctl
2858 * @file: file to set blocking value
2859 * @p: user parameter
2861 * Historical tty interfaces had a blocking control ioctl before
2862 * the generic functionality existed. This piece of history is preserved
2863 * in the expected tty API of posix OS's.
2865 * Locking: none, the open fle handle ensures it won't go away.
2868 static int fionbio(struct file *file, int __user *p)
2872 if (get_user(nonblock, p))
2876 file->f_flags |= O_NONBLOCK;
2878 file->f_flags &= ~O_NONBLOCK;
2883 * tiocsctty - set controlling tty
2884 * @tty: tty structure
2885 * @arg: user argument
2887 * This ioctl is used to manage job control. It permits a session
2888 * leader to set this tty as the controlling tty for the session.
2891 * Takes tty_mutex() to protect tty instance
2892 * Takes tasklist_lock internally to walk sessions
2893 * Takes ->siglock() when updating signal->tty
2896 static int tiocsctty(struct tty_struct *tty, int arg)
2899 if (current->signal->leader &&
2900 (current->signal->session == tty->session))
2903 mutex_lock(&tty_mutex);
2905 * The process must be a session leader and
2906 * not have a controlling tty already.
2908 if (!current->signal->leader || current->signal->tty) {
2913 if (tty->session > 0) {
2915 * This tty is already the controlling
2916 * tty for another session group!
2918 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2922 read_lock(&tasklist_lock);
2923 session_clear_tty(tty->session);
2924 read_unlock(&tasklist_lock);
2930 proc_set_tty(current, tty);
2932 mutex_unlock(&tty_mutex);
2937 * tiocgpgrp - get process group
2938 * @tty: tty passed by user
2939 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2942 * Obtain the process group of the tty. If there is no process group
2945 * Locking: none. Reference to current->signal->tty is safe.
2948 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2952 * (tty == real_tty) is a cheap way of
2953 * testing if the tty is NOT a master pty.
2955 if (tty == real_tty && current->signal->tty != real_tty)
2958 pgrp = vx_map_pid(real_tty->pgrp);
2959 return put_user(pgrp, p);
2963 * tiocspgrp - attempt to set process group
2964 * @tty: tty passed by user
2965 * @real_tty: tty side device matching tty passed by user
2968 * Set the process group of the tty to the session passed. Only
2969 * permitted where the tty session is our session.
2974 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2977 int retval = tty_check_change(real_tty);
2983 if (!current->signal->tty ||
2984 (current->signal->tty != real_tty) ||
2985 (real_tty->session != current->signal->session))
2987 if (get_user(pgrp, p))
2990 pgrp = vx_rmap_pid(pgrp);
2993 if (session_of_pgrp(pgrp) != current->signal->session)
2995 real_tty->pgrp = pgrp;
3000 * tiocgsid - get session id
3001 * @tty: tty passed by user
3002 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3003 * @p: pointer to returned session id
3005 * Obtain the session id of the tty. If there is no session
3008 * Locking: none. Reference to current->signal->tty is safe.
3011 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3014 * (tty == real_tty) is a cheap way of
3015 * testing if the tty is NOT a master pty.
3017 if (tty == real_tty && current->signal->tty != real_tty)
3019 if (real_tty->session <= 0)
3021 return put_user(real_tty->session, p);
3025 * tiocsetd - set line discipline
3027 * @p: pointer to user data
3029 * Set the line discipline according to user request.
3031 * Locking: see tty_set_ldisc, this function is just a helper
3034 static int tiocsetd(struct tty_struct *tty, int __user *p)
3038 if (get_user(ldisc, p))
3040 return tty_set_ldisc(tty, ldisc);
3044 * send_break - performed time break
3045 * @tty: device to break on
3046 * @duration: timeout in mS
3048 * Perform a timed break on hardware that lacks its own driver level
3049 * timed break functionality.
3052 * atomic_write_lock serializes
3056 static int send_break(struct tty_struct *tty, unsigned int duration)
3058 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3060 tty->driver->break_ctl(tty, -1);
3061 if (!signal_pending(current)) {
3062 msleep_interruptible(duration);
3064 tty->driver->break_ctl(tty, 0);
3065 mutex_unlock(&tty->atomic_write_lock);
3066 if (signal_pending(current))
3072 * tiocmget - get modem status
3074 * @file: user file pointer
3075 * @p: pointer to result
3077 * Obtain the modem status bits from the tty driver if the feature
3078 * is supported. Return -EINVAL if it is not available.
3080 * Locking: none (up to the driver)
3083 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3085 int retval = -EINVAL;
3087 if (tty->driver->tiocmget) {
3088 retval = tty->driver->tiocmget(tty, file);
3091 retval = put_user(retval, p);
3097 * tiocmset - set modem status
3099 * @file: user file pointer
3100 * @cmd: command - clear bits, set bits or set all
3101 * @p: pointer to desired bits
3103 * Set the modem status bits from the tty driver if the feature
3104 * is supported. Return -EINVAL if it is not available.
3106 * Locking: none (up to the driver)
3109 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3112 int retval = -EINVAL;
3114 if (tty->driver->tiocmset) {
3115 unsigned int set, clear, val;
3117 retval = get_user(val, p);
3135 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3136 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3138 retval = tty->driver->tiocmset(tty, file, set, clear);
3144 * Split this up, as gcc can choke on it otherwise..
3146 int tty_ioctl(struct inode * inode, struct file * file,
3147 unsigned int cmd, unsigned long arg)
3149 struct tty_struct *tty, *real_tty;
3150 void __user *p = (void __user *)arg;
3152 struct tty_ldisc *ld;
3154 tty = (struct tty_struct *)file->private_data;
3155 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3158 /* CHECKME: is this safe as one end closes ? */
3161 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3162 tty->driver->subtype == PTY_TYPE_MASTER)
3163 real_tty = tty->link;
3166 * Break handling by driver
3168 if (!tty->driver->break_ctl) {
3172 if (tty->driver->ioctl)
3173 return tty->driver->ioctl(tty, file, cmd, arg);
3176 /* These two ioctl's always return success; even if */
3177 /* the driver doesn't support them. */
3180 if (!tty->driver->ioctl)
3182 retval = tty->driver->ioctl(tty, file, cmd, arg);
3183 if (retval == -ENOIOCTLCMD)
3190 * Factor out some common prep work
3198 retval = tty_check_change(tty);
3201 if (cmd != TIOCCBRK) {
3202 tty_wait_until_sent(tty, 0);
3203 if (signal_pending(current))
3211 return tiocsti(tty, p);
3213 return tiocgwinsz(tty, p);
3215 return tiocswinsz(tty, real_tty, p);
3217 return real_tty!=tty ? -EINVAL : tioccons(file);
3219 return fionbio(file, p);
3221 set_bit(TTY_EXCLUSIVE, &tty->flags);
3224 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3227 if (current->signal->tty != tty)
3229 if (current->signal->leader)
3230 disassociate_ctty(0);
3231 proc_clear_tty(current);
3234 return tiocsctty(tty, arg);
3236 return tiocgpgrp(tty, real_tty, p);
3238 return tiocspgrp(tty, real_tty, p);
3240 return tiocgsid(tty, real_tty, p);
3242 /* FIXME: check this is ok */
3243 return put_user(tty->ldisc.num, (int __user *)p);
3245 return tiocsetd(tty, p);
3248 return tioclinux(tty, arg);
3253 case TIOCSBRK: /* Turn break on, unconditionally */
3254 tty->driver->break_ctl(tty, -1);
3257 case TIOCCBRK: /* Turn break off, unconditionally */
3258 tty->driver->break_ctl(tty, 0);
3260 case TCSBRK: /* SVID version: non-zero arg --> no break */
3261 /* non-zero arg means wait for all output data
3262 * to be sent (performed above) but don't send break.
3263 * This is used by the tcdrain() termios function.
3266 return send_break(tty, 250);
3268 case TCSBRKP: /* support for POSIX tcsendbreak() */
3269 return send_break(tty, arg ? arg*100 : 250);
3272 return tty_tiocmget(tty, file, p);
3277 return tty_tiocmset(tty, file, cmd, p);
3279 if (tty->driver->ioctl) {
3280 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3281 if (retval != -ENOIOCTLCMD)
3284 ld = tty_ldisc_ref_wait(tty);
3287 retval = ld->ioctl(tty, file, cmd, arg);
3288 if (retval == -ENOIOCTLCMD)
3291 tty_ldisc_deref(ld);
3297 * This implements the "Secure Attention Key" --- the idea is to
3298 * prevent trojan horses by killing all processes associated with this
3299 * tty when the user hits the "Secure Attention Key". Required for
3300 * super-paranoid applications --- see the Orange Book for more details.
3302 * This code could be nicer; ideally it should send a HUP, wait a few
3303 * seconds, then send a INT, and then a KILL signal. But you then
3304 * have to coordinate with the init process, since all processes associated
3305 * with the current tty must be dead before the new getty is allowed
3308 * Now, if it would be correct ;-/ The current code has a nasty hole -
3309 * it doesn't catch files in flight. We may send the descriptor to ourselves
3310 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3312 * Nasty bug: do_SAK is being called in interrupt context. This can
3313 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3315 static void __do_SAK(void *arg)
3320 struct tty_struct *tty = arg;
3321 struct task_struct *g, *p;
3325 struct tty_ldisc *disc;
3326 struct fdtable *fdt;
3330 session = tty->session;
3332 /* We don't want an ldisc switch during this */
3333 disc = tty_ldisc_ref(tty);
3334 if (disc && disc->flush_buffer)
3335 disc->flush_buffer(tty);
3336 tty_ldisc_deref(disc);
3338 if (tty->driver->flush_buffer)
3339 tty->driver->flush_buffer(tty);
3341 read_lock(&tasklist_lock);
3342 /* Kill the entire session */
3343 do_each_task_pid(session, PIDTYPE_SID, p) {
3344 printk(KERN_NOTICE "SAK: killed process %d"
3345 " (%s): p->signal->session==tty->session\n",
3347 send_sig(SIGKILL, p, 1);
3348 } while_each_task_pid(session, PIDTYPE_SID, p);
3349 /* Now kill any processes that happen to have the
3352 do_each_thread(g, p) {
3353 if (p->signal->tty == tty) {
3354 printk(KERN_NOTICE "SAK: killed process %d"
3355 " (%s): p->signal->session==tty->session\n",
3357 send_sig(SIGKILL, p, 1);
3363 * We don't take a ref to the file, so we must
3364 * hold ->file_lock instead.
3366 spin_lock(&p->files->file_lock);
3367 fdt = files_fdtable(p->files);
3368 for (i=0; i < fdt->max_fds; i++) {
3369 filp = fcheck_files(p->files, i);
3372 if (filp->f_op->read == tty_read &&
3373 filp->private_data == tty) {
3374 printk(KERN_NOTICE "SAK: killed process %d"
3375 " (%s): fd#%d opened to the tty\n",
3376 p->pid, p->comm, i);
3377 force_sig(SIGKILL, p);
3381 spin_unlock(&p->files->file_lock);
3384 } while_each_thread(g, p);
3385 read_unlock(&tasklist_lock);
3390 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3391 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3392 * the values which we write to it will be identical to the values which it
3393 * already has. --akpm
3395 void do_SAK(struct tty_struct *tty)
3399 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
3400 schedule_work(&tty->SAK_work);
3403 EXPORT_SYMBOL(do_SAK);
3407 * @private_: tty structure passed from work queue.
3409 * This routine is called out of the software interrupt to flush data
3410 * from the buffer chain to the line discipline.
3412 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3413 * while invoking the line discipline receive_buf method. The
3414 * receive_buf method is single threaded for each tty instance.
3417 static void flush_to_ldisc(void *private_)
3419 struct tty_struct *tty = (struct tty_struct *) private_;
3420 unsigned long flags;
3421 struct tty_ldisc *disc;
3422 struct tty_buffer *tbuf, *head;
3424 unsigned char *flag_buf;
3426 disc = tty_ldisc_ref(tty);
3427 if (disc == NULL) /* !TTY_LDISC */
3430 spin_lock_irqsave(&tty->buf.lock, flags);
3431 head = tty->buf.head;
3433 tty->buf.head = NULL;
3435 int count = head->commit - head->read;
3437 if (head->next == NULL)
3441 tty_buffer_free(tty, tbuf);
3444 if (!tty->receive_room) {
3445 schedule_delayed_work(&tty->buf.work, 1);
3448 if (count > tty->receive_room)
3449 count = tty->receive_room;
3450 char_buf = head->char_buf_ptr + head->read;
3451 flag_buf = head->flag_buf_ptr + head->read;
3452 head->read += count;
3453 spin_unlock_irqrestore(&tty->buf.lock, flags);
3454 disc->receive_buf(tty, char_buf, flag_buf, count);
3455 spin_lock_irqsave(&tty->buf.lock, flags);
3457 tty->buf.head = head;
3459 spin_unlock_irqrestore(&tty->buf.lock, flags);
3461 tty_ldisc_deref(disc);
3465 * Routine which returns the baud rate of the tty
3467 * Note that the baud_table needs to be kept in sync with the
3468 * include/asm/termbits.h file.
3470 static int baud_table[] = {
3471 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3472 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3474 76800, 153600, 307200, 614400, 921600
3476 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3477 2500000, 3000000, 3500000, 4000000
3481 static int n_baud_table = ARRAY_SIZE(baud_table);
3484 * tty_termios_baud_rate
3485 * @termios: termios structure
3487 * Convert termios baud rate data into a speed. This should be called
3488 * with the termios lock held if this termios is a terminal termios
3489 * structure. May change the termios data.
3494 int tty_termios_baud_rate(struct termios *termios)
3498 cbaud = termios->c_cflag & CBAUD;
3500 if (cbaud & CBAUDEX) {
3503 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3504 termios->c_cflag &= ~CBAUDEX;
3508 return baud_table[cbaud];
3511 EXPORT_SYMBOL(tty_termios_baud_rate);
3514 * tty_get_baud_rate - get tty bit rates
3515 * @tty: tty to query
3517 * Returns the baud rate as an integer for this terminal. The
3518 * termios lock must be held by the caller and the terminal bit
3519 * flags may be updated.
3524 int tty_get_baud_rate(struct tty_struct *tty)
3526 int baud = tty_termios_baud_rate(tty->termios);
3528 if (baud == 38400 && tty->alt_speed) {
3530 printk(KERN_WARNING "Use of setserial/setrocket to "
3531 "set SPD_* flags is deprecated\n");
3534 baud = tty->alt_speed;
3540 EXPORT_SYMBOL(tty_get_baud_rate);
3543 * tty_flip_buffer_push - terminal
3546 * Queue a push of the terminal flip buffers to the line discipline. This
3547 * function must not be called from IRQ context if tty->low_latency is set.
3549 * In the event of the queue being busy for flipping the work will be
3550 * held off and retried later.
3552 * Locking: tty buffer lock. Driver locks in low latency mode.
3555 void tty_flip_buffer_push(struct tty_struct *tty)
3557 unsigned long flags;
3558 spin_lock_irqsave(&tty->buf.lock, flags);
3559 if (tty->buf.tail != NULL)
3560 tty->buf.tail->commit = tty->buf.tail->used;
3561 spin_unlock_irqrestore(&tty->buf.lock, flags);
3563 if (tty->low_latency)
3564 flush_to_ldisc((void *) tty);
3566 schedule_delayed_work(&tty->buf.work, 1);
3569 EXPORT_SYMBOL(tty_flip_buffer_push);
3573 * initialize_tty_struct
3574 * @tty: tty to initialize
3576 * This subroutine initializes a tty structure that has been newly
3579 * Locking: none - tty in question must not be exposed at this point
3582 static void initialize_tty_struct(struct tty_struct *tty)
3584 memset(tty, 0, sizeof(struct tty_struct));
3585 tty->magic = TTY_MAGIC;
3586 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3588 tty->overrun_time = jiffies;
3589 tty->buf.head = tty->buf.tail = NULL;
3590 tty_buffer_init(tty);
3591 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
3592 init_MUTEX(&tty->buf.pty_sem);
3593 mutex_init(&tty->termios_mutex);
3594 init_waitqueue_head(&tty->write_wait);
3595 init_waitqueue_head(&tty->read_wait);
3596 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
3597 mutex_init(&tty->atomic_read_lock);
3598 mutex_init(&tty->atomic_write_lock);
3599 spin_lock_init(&tty->read_lock);
3600 INIT_LIST_HEAD(&tty->tty_files);
3601 INIT_WORK(&tty->SAK_work, NULL, NULL);
3605 * The default put_char routine if the driver did not define one.
3608 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3610 tty->driver->write(tty, &ch, 1);
3613 static struct class *tty_class;
3616 * tty_register_device - register a tty device
3617 * @driver: the tty driver that describes the tty device
3618 * @index: the index in the tty driver for this tty device
3619 * @device: a struct device that is associated with this tty device.
3620 * This field is optional, if there is no known struct device
3621 * for this tty device it can be set to NULL safely.
3623 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
3625 * This call is required to be made to register an individual tty device
3626 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3627 * that bit is not set, this function should not be called by a tty
3633 struct class_device *tty_register_device(struct tty_driver *driver,
3634 unsigned index, struct device *device)
3637 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3639 if (index >= driver->num) {
3640 printk(KERN_ERR "Attempt to register invalid tty line number "
3642 return ERR_PTR(-EINVAL);
3645 if (driver->type == TTY_DRIVER_TYPE_PTY)
3646 pty_line_name(driver, index, name);
3648 tty_line_name(driver, index, name);
3650 return class_device_create(tty_class, NULL, dev, device, "%s", name);
3654 * tty_unregister_device - unregister a tty device
3655 * @driver: the tty driver that describes the tty device
3656 * @index: the index in the tty driver for this tty device
3658 * If a tty device is registered with a call to tty_register_device() then
3659 * this function must be called when the tty device is gone.
3664 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3666 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3669 EXPORT_SYMBOL(tty_register_device);
3670 EXPORT_SYMBOL(tty_unregister_device);
3672 struct tty_driver *alloc_tty_driver(int lines)
3674 struct tty_driver *driver;
3676 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3678 memset(driver, 0, sizeof(struct tty_driver));
3679 driver->magic = TTY_DRIVER_MAGIC;
3680 driver->num = lines;
3681 /* later we'll move allocation of tables here */
3686 void put_tty_driver(struct tty_driver *driver)
3691 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3693 driver->open = op->open;
3694 driver->close = op->close;
3695 driver->write = op->write;
3696 driver->put_char = op->put_char;
3697 driver->flush_chars = op->flush_chars;
3698 driver->write_room = op->write_room;
3699 driver->chars_in_buffer = op->chars_in_buffer;
3700 driver->ioctl = op->ioctl;
3701 driver->set_termios = op->set_termios;
3702 driver->throttle = op->throttle;
3703 driver->unthrottle = op->unthrottle;
3704 driver->stop = op->stop;
3705 driver->start = op->start;
3706 driver->hangup = op->hangup;
3707 driver->break_ctl = op->break_ctl;
3708 driver->flush_buffer = op->flush_buffer;
3709 driver->set_ldisc = op->set_ldisc;
3710 driver->wait_until_sent = op->wait_until_sent;
3711 driver->send_xchar = op->send_xchar;
3712 driver->read_proc = op->read_proc;
3713 driver->write_proc = op->write_proc;
3714 driver->tiocmget = op->tiocmget;
3715 driver->tiocmset = op->tiocmset;
3719 EXPORT_SYMBOL(alloc_tty_driver);
3720 EXPORT_SYMBOL(put_tty_driver);
3721 EXPORT_SYMBOL(tty_set_operations);
3724 * Called by a tty driver to register itself.
3726 int tty_register_driver(struct tty_driver *driver)
3733 if (driver->flags & TTY_DRIVER_INSTALLED)
3736 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3737 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3740 memset(p, 0, driver->num * 3 * sizeof(void *));
3743 if (!driver->major) {
3744 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3745 (char*)driver->name);
3747 driver->major = MAJOR(dev);
3748 driver->minor_start = MINOR(dev);
3751 dev = MKDEV(driver->major, driver->minor_start);
3752 error = register_chrdev_region(dev, driver->num,
3753 (char*)driver->name);
3761 driver->ttys = (struct tty_struct **)p;
3762 driver->termios = (struct termios **)(p + driver->num);
3763 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3765 driver->ttys = NULL;
3766 driver->termios = NULL;
3767 driver->termios_locked = NULL;
3770 cdev_init(&driver->cdev, &tty_fops);
3771 driver->cdev.owner = driver->owner;
3772 error = cdev_add(&driver->cdev, dev, driver->num);
3774 unregister_chrdev_region(dev, driver->num);
3775 driver->ttys = NULL;
3776 driver->termios = driver->termios_locked = NULL;
3781 if (!driver->put_char)
3782 driver->put_char = tty_default_put_char;
3784 list_add(&driver->tty_drivers, &tty_drivers);
3786 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3787 for(i = 0; i < driver->num; i++)
3788 tty_register_device(driver, i, NULL);
3790 proc_tty_register_driver(driver);
3794 EXPORT_SYMBOL(tty_register_driver);
3797 * Called by a tty driver to unregister itself.
3799 int tty_unregister_driver(struct tty_driver *driver)
3805 if (driver->refcount)
3808 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3811 list_del(&driver->tty_drivers);
3814 * Free the termios and termios_locked structures because
3815 * we don't want to get memory leaks when modular tty
3816 * drivers are removed from the kernel.
3818 for (i = 0; i < driver->num; i++) {
3819 tp = driver->termios[i];
3821 driver->termios[i] = NULL;
3824 tp = driver->termios_locked[i];
3826 driver->termios_locked[i] = NULL;
3829 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3830 tty_unregister_device(driver, i);
3833 proc_tty_unregister_driver(driver);
3834 driver->ttys = NULL;
3835 driver->termios = driver->termios_locked = NULL;
3837 cdev_del(&driver->cdev);
3841 EXPORT_SYMBOL(tty_unregister_driver);
3845 * Initialize the console device. This is called *early*, so
3846 * we can't necessarily depend on lots of kernel help here.
3847 * Just do some early initializations, and do the complex setup
3850 void __init console_init(void)
3854 /* Setup the default TTY line discipline. */
3855 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3858 * set up the console device so that later boot sequences can
3859 * inform about problems etc..
3861 #ifdef CONFIG_EARLY_PRINTK
3862 disable_early_printk();
3864 call = __con_initcall_start;
3865 while (call < __con_initcall_end) {
3872 extern int vty_init(void);
3875 static int __init tty_class_init(void)
3877 tty_class = class_create(THIS_MODULE, "tty");
3878 if (IS_ERR(tty_class))
3879 return PTR_ERR(tty_class);
3883 postcore_initcall(tty_class_init);
3885 /* 3/2004 jmc: why do these devices exist? */
3887 static struct cdev tty_cdev, console_cdev;
3888 #ifdef CONFIG_UNIX98_PTYS
3889 static struct cdev ptmx_cdev;
3892 static struct cdev vc0_cdev;
3896 * Ok, now we can initialize the rest of the tty devices and can count
3897 * on memory allocations, interrupts etc..
3899 static int __init tty_init(void)
3901 cdev_init(&tty_cdev, &tty_fops);
3902 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3903 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3904 panic("Couldn't register /dev/tty driver\n");
3905 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3907 cdev_init(&console_cdev, &console_fops);
3908 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3909 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3910 panic("Couldn't register /dev/console driver\n");
3911 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3913 #ifdef CONFIG_UNIX98_PTYS
3914 cdev_init(&ptmx_cdev, &ptmx_fops);
3915 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3916 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3917 panic("Couldn't register /dev/ptmx driver\n");
3918 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3922 cdev_init(&vc0_cdev, &console_fops);
3923 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3924 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3925 panic("Couldn't register /dev/tty0 driver\n");
3926 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3933 module_init(tty_init);