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);
132 EXPORT_SYMBOL(tty_mutex);
134 #ifdef CONFIG_UNIX98_PTYS
135 extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
136 extern int pty_limit; /* Config limit on Unix98 ptys */
137 static DEFINE_IDR(allocated_ptys);
138 static DECLARE_MUTEX(allocated_ptys_lock);
139 static int ptmx_open(struct inode *, struct file *);
142 extern void disable_early_printk(void);
144 static void initialize_tty_struct(struct tty_struct *tty);
146 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149 static unsigned int tty_poll(struct file *, poll_table *);
150 static int tty_open(struct inode *, struct file *);
151 static int tty_release(struct inode *, struct file *);
152 int tty_ioctl(struct inode * inode, struct file * file,
153 unsigned int cmd, unsigned long arg);
154 static int tty_fasync(int fd, struct file * filp, int on);
155 static void release_mem(struct tty_struct *tty, int idx);
158 * alloc_tty_struct - allocate a tty object
160 * Return a new empty tty structure. The data fields have not
161 * been initialized in any way but has been zeroed
166 static struct tty_struct *alloc_tty_struct(void)
168 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
171 static void tty_buffer_free_all(struct tty_struct *);
174 * free_tty_struct - free a disused tty
175 * @tty: tty struct to free
177 * Free the write buffers, tty queue and tty memory itself.
179 * Locking: none. Must be called after tty is definitely unused
182 static inline void free_tty_struct(struct tty_struct *tty)
184 kfree(tty->write_buf);
185 tty_buffer_free_all(tty);
189 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
192 * tty_name - return tty naming
193 * @tty: tty structure
194 * @buf: buffer for output
196 * Convert a tty structure into a name. The name reflects the kernel
197 * naming policy and if udev is in use may not reflect user space
202 char *tty_name(struct tty_struct *tty, char *buf)
204 if (!tty) /* Hmm. NULL pointer. That's fun. */
205 strcpy(buf, "NULL tty");
207 strcpy(buf, tty->name);
211 EXPORT_SYMBOL(tty_name);
213 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
216 #ifdef TTY_PARANOIA_CHECK
219 "null TTY for (%d:%d) in %s\n",
220 imajor(inode), iminor(inode), routine);
223 if (tty->magic != TTY_MAGIC) {
225 "bad magic number for tty struct (%d:%d) in %s\n",
226 imajor(inode), iminor(inode), routine);
233 static int check_tty_count(struct tty_struct *tty, const char *routine)
235 #ifdef CHECK_TTY_COUNT
240 list_for_each(p, &tty->tty_files) {
244 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
245 tty->driver->subtype == PTY_TYPE_SLAVE &&
246 tty->link && tty->link->count)
248 if (tty->count != count) {
249 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
250 "!= #fd's(%d) in %s\n",
251 tty->name, tty->count, count, routine);
259 * Tty buffer allocation management
264 * tty_buffer_free_all - free buffers used by a tty
265 * @tty: tty to free from
267 * Remove all the buffers pending on a tty whether queued with data
268 * or in the free ring. Must be called when the tty is no longer in use
275 * tty_buffer_free_all - free buffers used by a tty
276 * @tty: tty to free from
278 * Remove all the buffers pending on a tty whether queued with data
279 * or in the free ring. Must be called when the tty is no longer in use
284 static void tty_buffer_free_all(struct tty_struct *tty)
286 struct tty_buffer *thead;
287 while((thead = tty->buf.head) != NULL) {
288 tty->buf.head = thead->next;
291 while((thead = tty->buf.free) != NULL) {
292 tty->buf.free = thead->next;
295 tty->buf.tail = NULL;
296 tty->buf.memory_used = 0;
300 * tty_buffer_init - prepare a tty buffer structure
301 * @tty: tty to initialise
303 * Set up the initial state of the buffer management for a tty device.
304 * Must be called before the other tty buffer functions are used.
309 static void tty_buffer_init(struct tty_struct *tty)
311 spin_lock_init(&tty->buf.lock);
312 tty->buf.head = NULL;
313 tty->buf.tail = NULL;
314 tty->buf.free = NULL;
315 tty->buf.memory_used = 0;
319 * tty_buffer_alloc - allocate a tty buffer
321 * @size: desired size (characters)
323 * Allocate a new tty buffer to hold the desired number of characters.
324 * Return NULL if out of memory or the allocation would exceed the
327 * Locking: Caller must hold tty->buf.lock
330 static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
332 struct tty_buffer *p;
334 if (tty->buf.memory_used + size > 65536)
336 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
344 p->char_buf_ptr = (char *)(p->data);
345 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
346 tty->buf.memory_used += size;
351 * tty_buffer_free - free a tty buffer
352 * @tty: tty owning the buffer
353 * @b: the buffer to free
355 * Free a tty buffer, or add it to the free list according to our
358 * Locking: Caller must hold tty->buf.lock
361 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
363 /* Dumb strategy for now - should keep some stats */
364 tty->buf.memory_used -= b->size;
365 WARN_ON(tty->buf.memory_used < 0);
370 b->next = tty->buf.free;
376 * tty_buffer_find - find a free tty buffer
377 * @tty: tty owning the buffer
378 * @size: characters wanted
380 * Locate an existing suitable tty buffer or if we are lacking one then
381 * allocate a new one. We round our buffers off in 256 character chunks
382 * to get better allocation behaviour.
384 * Locking: Caller must hold tty->buf.lock
387 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
389 struct tty_buffer **tbh = &tty->buf.free;
390 while((*tbh) != NULL) {
391 struct tty_buffer *t = *tbh;
392 if(t->size >= size) {
398 tty->buf.memory_used += t->size;
401 tbh = &((*tbh)->next);
403 /* Round the buffer size out */
404 size = (size + 0xFF) & ~ 0xFF;
405 return tty_buffer_alloc(tty, size);
406 /* Should possibly check if this fails for the largest buffer we
407 have queued and recycle that ? */
411 * tty_buffer_request_room - grow tty buffer if needed
412 * @tty: tty structure
413 * @size: size desired
415 * Make at least size bytes of linear space available for the tty
416 * buffer. If we fail return the size we managed to find.
418 * Locking: Takes tty->buf.lock
420 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
422 struct tty_buffer *b, *n;
426 spin_lock_irqsave(&tty->buf.lock, flags);
428 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
429 remove this conditional if its worth it. This would be invisible
431 if ((b = tty->buf.tail) != NULL)
432 left = b->size - b->used;
437 /* This is the slow path - looking for new buffers to use */
438 if ((n = tty_buffer_find(tty, size)) != NULL) {
449 spin_unlock_irqrestore(&tty->buf.lock, flags);
452 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
455 * tty_insert_flip_string - Add characters to the tty buffer
456 * @tty: tty structure
460 * Queue a series of bytes to the tty buffering. All the characters
461 * passed are marked as without error. Returns the number added.
463 * Locking: Called functions may take tty->buf.lock
466 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
471 int space = tty_buffer_request_room(tty, size - copied);
472 struct tty_buffer *tb = tty->buf.tail;
473 /* If there is no space then tb may be NULL */
474 if(unlikely(space == 0))
476 memcpy(tb->char_buf_ptr + tb->used, chars, space);
477 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
481 /* There is a small chance that we need to split the data over
482 several buffers. If this is the case we must loop */
483 } while (unlikely(size > copied));
486 EXPORT_SYMBOL(tty_insert_flip_string);
489 * tty_insert_flip_string_flags - Add characters to the tty buffer
490 * @tty: tty structure
495 * Queue a series of bytes to the tty buffering. For each character
496 * the flags array indicates the status of the character. Returns the
499 * Locking: Called functions may take tty->buf.lock
502 int tty_insert_flip_string_flags(struct tty_struct *tty,
503 const unsigned char *chars, const char *flags, size_t size)
507 int space = tty_buffer_request_room(tty, size - copied);
508 struct tty_buffer *tb = tty->buf.tail;
509 /* If there is no space then tb may be NULL */
510 if(unlikely(space == 0))
512 memcpy(tb->char_buf_ptr + tb->used, chars, space);
513 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
518 /* There is a small chance that we need to split the data over
519 several buffers. If this is the case we must loop */
520 } while (unlikely(size > copied));
523 EXPORT_SYMBOL(tty_insert_flip_string_flags);
526 * tty_schedule_flip - push characters to ldisc
527 * @tty: tty to push from
529 * Takes any pending buffers and transfers their ownership to the
530 * ldisc side of the queue. It then schedules those characters for
531 * processing by the line discipline.
533 * Locking: Takes tty->buf.lock
536 void tty_schedule_flip(struct tty_struct *tty)
539 spin_lock_irqsave(&tty->buf.lock, flags);
540 if (tty->buf.tail != NULL)
541 tty->buf.tail->commit = tty->buf.tail->used;
542 spin_unlock_irqrestore(&tty->buf.lock, flags);
543 schedule_delayed_work(&tty->buf.work, 1);
545 EXPORT_SYMBOL(tty_schedule_flip);
548 * tty_prepare_flip_string - make room for characters
550 * @chars: return pointer for character write area
551 * @size: desired size
553 * Prepare a block of space in the buffer for data. Returns the length
554 * available and buffer pointer to the space which is now allocated and
555 * accounted for as ready for normal characters. This is used for drivers
556 * that need their own block copy routines into the buffer. There is no
557 * guarantee the buffer is a DMA target!
559 * Locking: May call functions taking tty->buf.lock
562 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
564 int space = tty_buffer_request_room(tty, size);
566 struct tty_buffer *tb = tty->buf.tail;
567 *chars = tb->char_buf_ptr + tb->used;
568 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
574 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
577 * tty_prepare_flip_string_flags - make room for characters
579 * @chars: return pointer for character write area
580 * @flags: return pointer for status flag write area
581 * @size: desired size
583 * Prepare a block of space in the buffer for data. Returns the length
584 * available and buffer pointer to the space which is now allocated and
585 * accounted for as ready for characters. This is used for drivers
586 * that need their own block copy routines into the buffer. There is no
587 * guarantee the buffer is a DMA target!
589 * Locking: May call functions taking tty->buf.lock
592 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
594 int space = tty_buffer_request_room(tty, size);
596 struct tty_buffer *tb = tty->buf.tail;
597 *chars = tb->char_buf_ptr + tb->used;
598 *flags = tb->flag_buf_ptr + tb->used;
604 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
609 * tty_set_termios_ldisc - set ldisc field
610 * @tty: tty structure
611 * @num: line discipline number
613 * This is probably overkill for real world processors but
614 * they are not on hot paths so a little discipline won't do
617 * Locking: takes termios_sem
620 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
622 mutex_lock(&tty->termios_mutex);
623 tty->termios->c_line = num;
624 mutex_unlock(&tty->termios_mutex);
628 * This guards the refcounted line discipline lists. The lock
629 * must be taken with irqs off because there are hangup path
630 * callers who will do ldisc lookups and cannot sleep.
633 static DEFINE_SPINLOCK(tty_ldisc_lock);
634 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
635 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
638 * tty_register_ldisc - install a line discipline
639 * @disc: ldisc number
640 * @new_ldisc: pointer to the ldisc object
642 * Installs a new line discipline into the kernel. The discipline
643 * is set up as unreferenced and then made available to the kernel
644 * from this point onwards.
647 * takes tty_ldisc_lock to guard against ldisc races
650 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
655 if (disc < N_TTY || disc >= NR_LDISCS)
658 spin_lock_irqsave(&tty_ldisc_lock, flags);
659 tty_ldiscs[disc] = *new_ldisc;
660 tty_ldiscs[disc].num = disc;
661 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
662 tty_ldiscs[disc].refcount = 0;
663 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
667 EXPORT_SYMBOL(tty_register_ldisc);
670 * tty_unregister_ldisc - unload a line discipline
671 * @disc: ldisc number
672 * @new_ldisc: pointer to the ldisc object
674 * Remove a line discipline from the kernel providing it is not
678 * takes tty_ldisc_lock to guard against ldisc races
681 int tty_unregister_ldisc(int disc)
686 if (disc < N_TTY || disc >= NR_LDISCS)
689 spin_lock_irqsave(&tty_ldisc_lock, flags);
690 if (tty_ldiscs[disc].refcount)
693 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
694 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
698 EXPORT_SYMBOL(tty_unregister_ldisc);
701 * tty_ldisc_get - take a reference to an ldisc
702 * @disc: ldisc number
704 * Takes a reference to a line discipline. Deals with refcounts and
705 * module locking counts. Returns NULL if the discipline is not available.
706 * Returns a pointer to the discipline and bumps the ref count if it is
710 * takes tty_ldisc_lock to guard against ldisc races
713 struct tty_ldisc *tty_ldisc_get(int disc)
716 struct tty_ldisc *ld;
718 if (disc < N_TTY || disc >= NR_LDISCS)
721 spin_lock_irqsave(&tty_ldisc_lock, flags);
723 ld = &tty_ldiscs[disc];
724 /* Check the entry is defined */
725 if(ld->flags & LDISC_FLAG_DEFINED)
727 /* If the module is being unloaded we can't use it */
728 if (!try_module_get(ld->owner))
735 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
739 EXPORT_SYMBOL_GPL(tty_ldisc_get);
742 * tty_ldisc_put - drop ldisc reference
743 * @disc: ldisc number
745 * Drop a reference to a line discipline. Manage refcounts and
746 * module usage counts
749 * takes tty_ldisc_lock to guard against ldisc races
752 void tty_ldisc_put(int disc)
754 struct tty_ldisc *ld;
757 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
759 spin_lock_irqsave(&tty_ldisc_lock, flags);
760 ld = &tty_ldiscs[disc];
761 BUG_ON(ld->refcount == 0);
763 module_put(ld->owner);
764 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
767 EXPORT_SYMBOL_GPL(tty_ldisc_put);
770 * tty_ldisc_assign - set ldisc on a tty
771 * @tty: tty to assign
772 * @ld: line discipline
774 * Install an instance of a line discipline into a tty structure. The
775 * ldisc must have a reference count above zero to ensure it remains/
776 * The tty instance refcount starts at zero.
779 * Caller must hold references
782 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
785 tty->ldisc.refcount = 0;
789 * tty_ldisc_try - internal helper
792 * Make a single attempt to grab and bump the refcount on
793 * the tty ldisc. Return 0 on failure or 1 on success. This is
794 * used to implement both the waiting and non waiting versions
797 * Locking: takes tty_ldisc_lock
800 static int tty_ldisc_try(struct tty_struct *tty)
803 struct tty_ldisc *ld;
806 spin_lock_irqsave(&tty_ldisc_lock, flags);
808 if(test_bit(TTY_LDISC, &tty->flags))
813 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
818 * tty_ldisc_ref_wait - wait for the tty ldisc
821 * Dereference the line discipline for the terminal and take a
822 * reference to it. If the line discipline is in flux then
823 * wait patiently until it changes.
825 * Note: Must not be called from an IRQ/timer context. The caller
826 * must also be careful not to hold other locks that will deadlock
827 * against a discipline change, such as an existing ldisc reference
828 * (which we check for)
830 * Locking: call functions take tty_ldisc_lock
833 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
835 /* wait_event is a macro */
836 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
837 if(tty->ldisc.refcount == 0)
838 printk(KERN_ERR "tty_ldisc_ref_wait\n");
842 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
845 * tty_ldisc_ref - get the tty ldisc
848 * Dereference the line discipline for the terminal and take a
849 * reference to it. If the line discipline is in flux then
850 * return NULL. Can be called from IRQ and timer functions.
852 * Locking: called functions take tty_ldisc_lock
855 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
857 if(tty_ldisc_try(tty))
862 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
865 * tty_ldisc_deref - free a tty ldisc reference
866 * @ld: reference to free up
868 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
869 * be called in IRQ context.
871 * Locking: takes tty_ldisc_lock
874 void tty_ldisc_deref(struct tty_ldisc *ld)
880 spin_lock_irqsave(&tty_ldisc_lock, flags);
881 if(ld->refcount == 0)
882 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
885 if(ld->refcount == 0)
886 wake_up(&tty_ldisc_wait);
887 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
890 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
893 * tty_ldisc_enable - allow ldisc use
894 * @tty: terminal to activate ldisc on
896 * Set the TTY_LDISC flag when the line discipline can be called
897 * again. Do neccessary wakeups for existing sleepers.
899 * Note: nobody should set this bit except via this function. Clearing
900 * directly is allowed.
903 static void tty_ldisc_enable(struct tty_struct *tty)
905 set_bit(TTY_LDISC, &tty->flags);
906 wake_up(&tty_ldisc_wait);
910 * tty_set_ldisc - set line discipline
911 * @tty: the terminal to set
912 * @ldisc: the line discipline
914 * Set the discipline of a tty line. Must be called from a process
917 * Locking: takes tty_ldisc_lock.
918 * called functions take termios_sem
921 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
924 struct tty_ldisc o_ldisc;
928 struct tty_ldisc *ld;
929 struct tty_struct *o_tty;
931 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
936 ld = tty_ldisc_get(ldisc);
937 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
938 /* Cyrus Durgin <cider@speakeasy.org> */
940 request_module("tty-ldisc-%d", ldisc);
941 ld = tty_ldisc_get(ldisc);
947 * No more input please, we are switching. The new ldisc
948 * will update this value in the ldisc open function
951 tty->receive_room = 0;
954 * Problem: What do we do if this blocks ?
957 tty_wait_until_sent(tty, 0);
959 if (tty->ldisc.num == ldisc) {
960 tty_ldisc_put(ldisc);
964 o_ldisc = tty->ldisc;
968 * Make sure we don't change while someone holds a
969 * reference to the line discipline. The TTY_LDISC bit
970 * prevents anyone taking a reference once it is clear.
971 * We need the lock to avoid racing reference takers.
974 spin_lock_irqsave(&tty_ldisc_lock, flags);
975 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
976 if(tty->ldisc.refcount) {
977 /* Free the new ldisc we grabbed. Must drop the lock
979 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
980 tty_ldisc_put(ldisc);
982 * There are several reasons we may be busy, including
983 * random momentary I/O traffic. We must therefore
984 * retry. We could distinguish between blocking ops
985 * and retries if we made tty_ldisc_wait() smarter. That
986 * is up for discussion.
988 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
992 if(o_tty && o_tty->ldisc.refcount) {
993 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
994 tty_ldisc_put(ldisc);
995 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
1001 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
1003 if (!test_bit(TTY_LDISC, &tty->flags)) {
1004 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1005 tty_ldisc_put(ldisc);
1006 ld = tty_ldisc_ref_wait(tty);
1007 tty_ldisc_deref(ld);
1011 clear_bit(TTY_LDISC, &tty->flags);
1013 clear_bit(TTY_LDISC, &o_tty->flags);
1014 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1017 * From this point on we know nobody has an ldisc
1018 * usage reference, nor can they obtain one until
1019 * we say so later on.
1022 work = cancel_delayed_work(&tty->buf.work);
1024 * Wait for ->hangup_work and ->buf.work handlers to terminate
1027 flush_scheduled_work();
1028 /* Shutdown the current discipline. */
1029 if (tty->ldisc.close)
1030 (tty->ldisc.close)(tty);
1032 /* Now set up the new line discipline. */
1033 tty_ldisc_assign(tty, ld);
1034 tty_set_termios_ldisc(tty, ldisc);
1035 if (tty->ldisc.open)
1036 retval = (tty->ldisc.open)(tty);
1038 tty_ldisc_put(ldisc);
1039 /* There is an outstanding reference here so this is safe */
1040 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1041 tty_set_termios_ldisc(tty, tty->ldisc.num);
1042 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1043 tty_ldisc_put(o_ldisc.num);
1044 /* This driver is always present */
1045 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1046 tty_set_termios_ldisc(tty, N_TTY);
1047 if (tty->ldisc.open) {
1048 int r = tty->ldisc.open(tty);
1051 panic("Couldn't open N_TTY ldisc for "
1053 tty_name(tty, buf), r);
1057 /* At this point we hold a reference to the new ldisc and a
1058 a reference to the old ldisc. If we ended up flipping back
1059 to the existing ldisc we have two references to it */
1061 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1062 tty->driver->set_ldisc(tty);
1064 tty_ldisc_put(o_ldisc.num);
1067 * Allow ldisc referencing to occur as soon as the driver
1068 * ldisc callback completes.
1071 tty_ldisc_enable(tty);
1073 tty_ldisc_enable(o_tty);
1075 /* Restart it in case no characters kick it off. Safe if
1078 schedule_delayed_work(&tty->buf.work, 1);
1083 * get_tty_driver - find device of a tty
1084 * @dev_t: device identifier
1085 * @index: returns the index of the tty
1087 * This routine returns a tty driver structure, given a device number
1088 * and also passes back the index number.
1090 * Locking: caller must hold tty_mutex
1093 static struct tty_driver *get_tty_driver(dev_t device, int *index)
1095 struct tty_driver *p;
1097 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1098 dev_t base = MKDEV(p->major, p->minor_start);
1099 if (device < base || device >= base + p->num)
1101 *index = device - base;
1108 * tty_check_change - check for POSIX terminal changes
1109 * @tty: tty to check
1111 * If we try to write to, or set the state of, a terminal and we're
1112 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1113 * ignored, go ahead and perform the operation. (POSIX 7.2)
1118 int tty_check_change(struct tty_struct * tty)
1120 if (current->signal->tty != tty)
1122 if (tty->pgrp <= 0) {
1123 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1126 if (process_group(current) == tty->pgrp)
1128 if (is_ignored(SIGTTOU))
1130 if (is_orphaned_pgrp(process_group(current)))
1132 (void) kill_pg(process_group(current), SIGTTOU, 1);
1133 return -ERESTARTSYS;
1136 EXPORT_SYMBOL(tty_check_change);
1138 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1139 size_t count, loff_t *ppos)
1144 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1145 size_t count, loff_t *ppos)
1150 /* No kernel lock held - none needed ;) */
1151 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1153 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1156 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1157 unsigned int cmd, unsigned long arg)
1159 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1162 static const struct file_operations tty_fops = {
1163 .llseek = no_llseek,
1169 .release = tty_release,
1170 .fasync = tty_fasync,
1173 #ifdef CONFIG_UNIX98_PTYS
1174 static const struct file_operations ptmx_fops = {
1175 .llseek = no_llseek,
1181 .release = tty_release,
1182 .fasync = tty_fasync,
1186 static const struct file_operations console_fops = {
1187 .llseek = no_llseek,
1189 .write = redirected_tty_write,
1193 .release = tty_release,
1194 .fasync = tty_fasync,
1197 static const struct file_operations hung_up_tty_fops = {
1198 .llseek = no_llseek,
1199 .read = hung_up_tty_read,
1200 .write = hung_up_tty_write,
1201 .poll = hung_up_tty_poll,
1202 .ioctl = hung_up_tty_ioctl,
1203 .release = tty_release,
1206 static DEFINE_SPINLOCK(redirect_lock);
1207 static struct file *redirect;
1210 * tty_wakeup - request more data
1213 * Internal and external helper for wakeups of tty. This function
1214 * informs the line discipline if present that the driver is ready
1215 * to receive more output data.
1218 void tty_wakeup(struct tty_struct *tty)
1220 struct tty_ldisc *ld;
1222 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1223 ld = tty_ldisc_ref(tty);
1225 if(ld->write_wakeup)
1226 ld->write_wakeup(tty);
1227 tty_ldisc_deref(ld);
1230 wake_up_interruptible(&tty->write_wait);
1233 EXPORT_SYMBOL_GPL(tty_wakeup);
1236 * tty_ldisc_flush - flush line discipline queue
1239 * Flush the line discipline queue (if any) for this tty. If there
1240 * is no line discipline active this is a no-op.
1243 void tty_ldisc_flush(struct tty_struct *tty)
1245 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1247 if(ld->flush_buffer)
1248 ld->flush_buffer(tty);
1249 tty_ldisc_deref(ld);
1253 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1256 * do_tty_hangup - actual handler for hangup events
1259 * This can be called by the "eventd" kernel thread. That is process
1260 * synchronous but doesn't hold any locks, so we need to make sure we
1261 * have the appropriate locks for what we're doing.
1263 * The hangup event clears any pending redirections onto the hung up
1264 * device. It ensures future writes will error and it does the needed
1265 * line discipline hangup and signal delivery. The tty object itself
1270 * redirect lock for undoing redirection
1271 * file list lock for manipulating list of ttys
1272 * tty_ldisc_lock from called functions
1273 * termios_sem resetting termios data
1274 * tasklist_lock to walk task list for hangup event
1277 static void do_tty_hangup(struct work_struct *work)
1279 struct tty_struct *tty =
1280 container_of(work, struct tty_struct, hangup_work);
1281 struct file * cons_filp = NULL;
1282 struct file *filp, *f = NULL;
1283 struct task_struct *p;
1284 struct tty_ldisc *ld;
1285 int closecount = 0, n;
1290 /* inuse_filps is protected by the single kernel lock */
1293 spin_lock(&redirect_lock);
1294 if (redirect && redirect->private_data == tty) {
1298 spin_unlock(&redirect_lock);
1300 check_tty_count(tty, "do_tty_hangup");
1302 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1303 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1304 if (filp->f_op->write == redirected_tty_write)
1306 if (filp->f_op->write != tty_write)
1309 tty_fasync(-1, filp, 0); /* can't block */
1310 filp->f_op = &hung_up_tty_fops;
1314 /* FIXME! What are the locking issues here? This may me overdoing things..
1315 * this question is especially important now that we've removed the irqlock. */
1317 ld = tty_ldisc_ref(tty);
1318 if(ld != NULL) /* We may have no line discipline at this point */
1320 if (ld->flush_buffer)
1321 ld->flush_buffer(tty);
1322 if (tty->driver->flush_buffer)
1323 tty->driver->flush_buffer(tty);
1324 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1326 ld->write_wakeup(tty);
1331 /* FIXME: Once we trust the LDISC code better we can wait here for
1332 ldisc completion and fix the driver call race */
1334 wake_up_interruptible(&tty->write_wait);
1335 wake_up_interruptible(&tty->read_wait);
1338 * Shutdown the current line discipline, and reset it to
1341 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1343 mutex_lock(&tty->termios_mutex);
1344 *tty->termios = tty->driver->init_termios;
1345 mutex_unlock(&tty->termios_mutex);
1348 /* Defer ldisc switch */
1349 /* tty_deferred_ldisc_switch(N_TTY);
1351 This should get done automatically when the port closes and
1352 tty_release is called */
1354 read_lock(&tasklist_lock);
1355 if (tty->session > 0) {
1356 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1357 if (p->signal->tty == tty)
1358 p->signal->tty = NULL;
1359 if (!p->signal->leader)
1361 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1362 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1364 p->signal->tty_old_pgrp = tty->pgrp;
1365 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1367 read_unlock(&tasklist_lock);
1372 tty->ctrl_status = 0;
1374 * If one of the devices matches a console pointer, we
1375 * cannot just call hangup() because that will cause
1376 * tty->count and state->count to go out of sync.
1377 * So we just call close() the right number of times.
1380 if (tty->driver->close)
1381 for (n = 0; n < closecount; n++)
1382 tty->driver->close(tty, cons_filp);
1383 } else if (tty->driver->hangup)
1384 (tty->driver->hangup)(tty);
1386 /* We don't want to have driver/ldisc interactions beyond
1387 the ones we did here. The driver layer expects no
1388 calls after ->hangup() from the ldisc side. However we
1389 can't yet guarantee all that */
1391 set_bit(TTY_HUPPED, &tty->flags);
1393 tty_ldisc_enable(tty);
1394 tty_ldisc_deref(ld);
1402 * tty_hangup - trigger a hangup event
1403 * @tty: tty to hangup
1405 * A carrier loss (virtual or otherwise) has occurred on this like
1406 * schedule a hangup sequence to run after this event.
1409 void tty_hangup(struct tty_struct * tty)
1411 #ifdef TTY_DEBUG_HANGUP
1414 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1416 schedule_work(&tty->hangup_work);
1419 EXPORT_SYMBOL(tty_hangup);
1422 * tty_vhangup - process vhangup
1423 * @tty: tty to hangup
1425 * The user has asked via system call for the terminal to be hung up.
1426 * We do this synchronously so that when the syscall returns the process
1427 * is complete. That guarantee is neccessary for security reasons.
1430 void tty_vhangup(struct tty_struct * tty)
1432 #ifdef TTY_DEBUG_HANGUP
1435 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1437 do_tty_hangup(&tty->hangup_work);
1439 EXPORT_SYMBOL(tty_vhangup);
1442 * tty_hung_up_p - was tty hung up
1443 * @filp: file pointer of tty
1445 * Return true if the tty has been subject to a vhangup or a carrier
1449 int tty_hung_up_p(struct file * filp)
1451 return (filp->f_op == &hung_up_tty_fops);
1454 EXPORT_SYMBOL(tty_hung_up_p);
1457 * disassociate_ctty - disconnect controlling tty
1458 * @on_exit: true if exiting so need to "hang up" the session
1460 * This function is typically called only by the session leader, when
1461 * it wants to disassociate itself from its controlling tty.
1463 * It performs the following functions:
1464 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1465 * (2) Clears the tty from being controlling the session
1466 * (3) Clears the controlling tty for all processes in the
1469 * The argument on_exit is set to 1 if called when a process is
1470 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1472 * Locking: tty_mutex is taken to protect current->signal->tty
1473 * BKL is taken for hysterical raisins
1474 * Tasklist lock is taken (under tty_mutex) to walk process
1475 * lists for the session.
1478 void disassociate_ctty(int on_exit)
1480 struct tty_struct *tty;
1481 struct task_struct *p;
1486 mutex_lock(&tty_mutex);
1487 tty = current->signal->tty;
1489 tty_pgrp = tty->pgrp;
1490 mutex_unlock(&tty_mutex);
1491 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1494 if (current->signal->tty_old_pgrp) {
1495 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1496 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1498 mutex_unlock(&tty_mutex);
1503 kill_pg(tty_pgrp, SIGHUP, on_exit);
1505 kill_pg(tty_pgrp, SIGCONT, on_exit);
1508 /* Must lock changes to tty_old_pgrp */
1509 mutex_lock(&tty_mutex);
1510 current->signal->tty_old_pgrp = 0;
1514 /* Now clear signal->tty under the lock */
1515 read_lock(&tasklist_lock);
1516 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1517 p->signal->tty = NULL;
1518 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1519 read_unlock(&tasklist_lock);
1520 mutex_unlock(&tty_mutex);
1526 * stop_tty - propogate flow control
1529 * Perform flow control to the driver. For PTY/TTY pairs we
1530 * must also propogate the TIOCKPKT status. May be called
1531 * on an already stopped device and will not re-call the driver
1534 * This functionality is used by both the line disciplines for
1535 * halting incoming flow and by the driver. It may therefore be
1536 * called from any context, may be under the tty atomic_write_lock
1540 * Broken. Relies on BKL which is unsafe here.
1543 void stop_tty(struct tty_struct *tty)
1548 if (tty->link && tty->link->packet) {
1549 tty->ctrl_status &= ~TIOCPKT_START;
1550 tty->ctrl_status |= TIOCPKT_STOP;
1551 wake_up_interruptible(&tty->link->read_wait);
1553 if (tty->driver->stop)
1554 (tty->driver->stop)(tty);
1557 EXPORT_SYMBOL(stop_tty);
1560 * start_tty - propogate flow control
1561 * @tty: tty to start
1563 * Start a tty that has been stopped if at all possible. Perform
1564 * any neccessary wakeups and propogate the TIOCPKT status. If this
1565 * is the tty was previous stopped and is being started then the
1566 * driver start method is invoked and the line discipline woken.
1569 * Broken. Relies on BKL which is unsafe here.
1572 void start_tty(struct tty_struct *tty)
1574 if (!tty->stopped || tty->flow_stopped)
1577 if (tty->link && tty->link->packet) {
1578 tty->ctrl_status &= ~TIOCPKT_STOP;
1579 tty->ctrl_status |= TIOCPKT_START;
1580 wake_up_interruptible(&tty->link->read_wait);
1582 if (tty->driver->start)
1583 (tty->driver->start)(tty);
1585 /* If we have a running line discipline it may need kicking */
1587 wake_up_interruptible(&tty->write_wait);
1590 EXPORT_SYMBOL(start_tty);
1593 * tty_read - read method for tty device files
1594 * @file: pointer to tty file
1596 * @count: size of user buffer
1599 * Perform the read system call function on this terminal device. Checks
1600 * for hung up devices before calling the line discipline method.
1603 * Locks the line discipline internally while needed
1604 * For historical reasons the line discipline read method is
1605 * invoked under the BKL. This will go away in time so do not rely on it
1606 * in new code. Multiple read calls may be outstanding in parallel.
1609 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1613 struct tty_struct * tty;
1614 struct inode *inode;
1615 struct tty_ldisc *ld;
1617 tty = (struct tty_struct *)file->private_data;
1618 inode = file->f_dentry->d_inode;
1619 if (tty_paranoia_check(tty, inode, "tty_read"))
1621 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1624 /* We want to wait for the line discipline to sort out in this
1626 ld = tty_ldisc_ref_wait(tty);
1629 i = (ld->read)(tty,file,buf,count);
1632 tty_ldisc_deref(ld);
1635 inode->i_atime = current_fs_time(inode->i_sb);
1640 * Split writes up in sane blocksizes to avoid
1641 * denial-of-service type attacks
1643 static inline ssize_t do_tty_write(
1644 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1645 struct tty_struct *tty,
1647 const char __user *buf,
1650 ssize_t ret = 0, written = 0;
1653 /* FIXME: O_NDELAY ... */
1654 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1655 return -ERESTARTSYS;
1659 * We chunk up writes into a temporary buffer. This
1660 * simplifies low-level drivers immensely, since they
1661 * don't have locking issues and user mode accesses.
1663 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1666 * The default chunk-size is 2kB, because the NTTY
1667 * layer has problems with bigger chunks. It will
1668 * claim to be able to handle more characters than
1671 * FIXME: This can probably go away now except that 64K chunks
1672 * are too likely to fail unless switched to vmalloc...
1675 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1680 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1681 if (tty->write_cnt < chunk) {
1687 buf = kmalloc(chunk, GFP_KERNEL);
1689 mutex_unlock(&tty->atomic_write_lock);
1692 kfree(tty->write_buf);
1693 tty->write_cnt = chunk;
1694 tty->write_buf = buf;
1697 /* Do the write .. */
1699 size_t size = count;
1703 if (copy_from_user(tty->write_buf, buf, size))
1706 ret = write(tty, file, tty->write_buf, size);
1716 if (signal_pending(current))
1721 struct inode *inode = file->f_dentry->d_inode;
1722 inode->i_mtime = current_fs_time(inode->i_sb);
1725 mutex_unlock(&tty->atomic_write_lock);
1731 * tty_write - write method for tty device file
1732 * @file: tty file pointer
1733 * @buf: user data to write
1734 * @count: bytes to write
1737 * Write data to a tty device via the line discipline.
1740 * Locks the line discipline as required
1741 * Writes to the tty driver are serialized by the atomic_write_lock
1742 * and are then processed in chunks to the device. The line discipline
1743 * write method will not be involked in parallel for each device
1744 * The line discipline write method is called under the big
1745 * kernel lock for historical reasons. New code should not rely on this.
1748 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1751 struct tty_struct * tty;
1752 struct inode *inode = file->f_dentry->d_inode;
1754 struct tty_ldisc *ld;
1756 tty = (struct tty_struct *)file->private_data;
1757 if (tty_paranoia_check(tty, inode, "tty_write"))
1759 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1762 ld = tty_ldisc_ref_wait(tty);
1766 ret = do_tty_write(ld->write, tty, file, buf, count);
1767 tty_ldisc_deref(ld);
1771 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1774 struct file *p = NULL;
1776 spin_lock(&redirect_lock);
1781 spin_unlock(&redirect_lock);
1785 res = vfs_write(p, buf, count, &p->f_pos);
1790 return tty_write(file, buf, count, ppos);
1793 static char ptychar[] = "pqrstuvwxyzabcde";
1796 * pty_line_name - generate name for a pty
1797 * @driver: the tty driver in use
1798 * @index: the minor number
1799 * @p: output buffer of at least 6 bytes
1801 * Generate a name from a driver reference and write it to the output
1806 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1808 int i = index + driver->name_base;
1809 /* ->name is initialized to "ttyp", but "tty" is expected */
1810 sprintf(p, "%s%c%x",
1811 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1812 ptychar[i >> 4 & 0xf], i & 0xf);
1816 * pty_line_name - generate name for a tty
1817 * @driver: the tty driver in use
1818 * @index: the minor number
1819 * @p: output buffer of at least 7 bytes
1821 * Generate a name from a driver reference and write it to the output
1826 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1828 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1832 * init_dev - initialise a tty device
1833 * @driver: tty driver we are opening a device on
1834 * @idx: device index
1835 * @tty: returned tty structure
1837 * Prepare a tty device. This may not be a "new" clean device but
1838 * could also be an active device. The pty drivers require special
1839 * handling because of this.
1842 * The function is called under the tty_mutex, which
1843 * protects us from the tty struct or driver itself going away.
1845 * On exit the tty device has the line discipline attached and
1846 * a reference count of 1. If a pair was created for pty/tty use
1847 * and the other was a pty master then it too has a reference count of 1.
1849 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1850 * failed open. The new code protects the open with a mutex, so it's
1851 * really quite straightforward. The mutex locking can probably be
1852 * relaxed for the (most common) case of reopening a tty.
1855 static int init_dev(struct tty_driver *driver, int idx,
1856 struct tty_struct **ret_tty)
1858 struct tty_struct *tty, *o_tty;
1859 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1860 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1863 /* check whether we're reopening an existing tty */
1864 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1865 tty = devpts_get_tty(idx);
1866 if (tty && driver->subtype == PTY_TYPE_MASTER)
1869 tty = driver->ttys[idx];
1871 if (tty) goto fast_track;
1874 * First time open is complex, especially for PTY devices.
1875 * This code guarantees that either everything succeeds and the
1876 * TTY is ready for operation, or else the table slots are vacated
1877 * and the allocated memory released. (Except that the termios
1878 * and locked termios may be retained.)
1881 if (!try_module_get(driver->owner)) {
1890 tty = alloc_tty_struct();
1893 initialize_tty_struct(tty);
1894 tty->driver = driver;
1896 tty_line_name(driver, idx, tty->name);
1898 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1899 tp_loc = &tty->termios;
1900 ltp_loc = &tty->termios_locked;
1902 tp_loc = &driver->termios[idx];
1903 ltp_loc = &driver->termios_locked[idx];
1907 tp = (struct termios *) kmalloc(sizeof(struct termios),
1911 *tp = driver->init_termios;
1915 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1919 memset(ltp, 0, sizeof(struct termios));
1922 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1923 o_tty = alloc_tty_struct();
1926 initialize_tty_struct(o_tty);
1927 o_tty->driver = driver->other;
1929 tty_line_name(driver->other, idx, o_tty->name);
1931 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1932 o_tp_loc = &o_tty->termios;
1933 o_ltp_loc = &o_tty->termios_locked;
1935 o_tp_loc = &driver->other->termios[idx];
1936 o_ltp_loc = &driver->other->termios_locked[idx];
1940 o_tp = (struct termios *)
1941 kmalloc(sizeof(struct termios), GFP_KERNEL);
1944 *o_tp = driver->other->init_termios;
1948 o_ltp = (struct termios *)
1949 kmalloc(sizeof(struct termios), GFP_KERNEL);
1952 memset(o_ltp, 0, sizeof(struct termios));
1956 * Everything allocated ... set up the o_tty structure.
1958 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1959 driver->other->ttys[idx] = o_tty;
1965 o_tty->termios = *o_tp_loc;
1966 o_tty->termios_locked = *o_ltp_loc;
1967 driver->other->refcount++;
1968 if (driver->subtype == PTY_TYPE_MASTER)
1971 /* Establish the links in both directions */
1977 * All structures have been allocated, so now we install them.
1978 * Failures after this point use release_mem to clean up, so
1979 * there's no need to null out the local pointers.
1981 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1982 driver->ttys[idx] = tty;
1989 tty->termios = *tp_loc;
1990 tty->termios_locked = *ltp_loc;
1995 * Structures all installed ... call the ldisc open routines.
1996 * If we fail here just call release_mem to clean up. No need
1997 * to decrement the use counts, as release_mem doesn't care.
2000 if (tty->ldisc.open) {
2001 retval = (tty->ldisc.open)(tty);
2003 goto release_mem_out;
2005 if (o_tty && o_tty->ldisc.open) {
2006 retval = (o_tty->ldisc.open)(o_tty);
2008 if (tty->ldisc.close)
2009 (tty->ldisc.close)(tty);
2010 goto release_mem_out;
2012 tty_ldisc_enable(o_tty);
2014 tty_ldisc_enable(tty);
2018 * This fast open can be used if the tty is already open.
2019 * No memory is allocated, and the only failures are from
2020 * attempting to open a closing tty or attempting multiple
2021 * opens on a pty master.
2024 if (test_bit(TTY_CLOSING, &tty->flags)) {
2028 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2029 driver->subtype == PTY_TYPE_MASTER) {
2031 * special case for PTY masters: only one open permitted,
2032 * and the slave side open count is incremented as well.
2041 tty->driver = driver; /* N.B. why do this every time?? */
2044 if(!test_bit(TTY_LDISC, &tty->flags))
2045 printk(KERN_ERR "init_dev but no ldisc\n");
2049 /* All paths come through here to release the mutex */
2053 /* Release locally allocated memory ... nothing placed in slots */
2057 free_tty_struct(o_tty);
2060 free_tty_struct(tty);
2063 module_put(driver->owner);
2067 /* call the tty release_mem routine to clean out this slot */
2069 if (printk_ratelimit())
2070 printk(KERN_INFO "init_dev: ldisc open failed, "
2071 "clearing slot %d\n", idx);
2072 release_mem(tty, idx);
2077 * release_mem - release tty structure memory
2079 * Releases memory associated with a tty structure, and clears out the
2080 * driver table slots. This function is called when a device is no longer
2081 * in use. It also gets called when setup of a device fails.
2084 * tty_mutex - sometimes only
2085 * takes the file list lock internally when working on the list
2086 * of ttys that the driver keeps.
2087 * FIXME: should we require tty_mutex is held here ??
2090 static void release_mem(struct tty_struct *tty, int idx)
2092 struct tty_struct *o_tty;
2094 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2096 if ((o_tty = tty->link) != NULL) {
2098 o_tty->driver->ttys[idx] = NULL;
2099 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2100 tp = o_tty->termios;
2102 o_tty->driver->termios[idx] = NULL;
2105 tp = o_tty->termios_locked;
2107 o_tty->driver->termios_locked[idx] = NULL;
2111 o_tty->driver->refcount--;
2113 list_del_init(&o_tty->tty_files);
2115 free_tty_struct(o_tty);
2119 tty->driver->ttys[idx] = NULL;
2120 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2123 tty->driver->termios[idx] = NULL;
2126 tp = tty->termios_locked;
2128 tty->driver->termios_locked[idx] = NULL;
2133 tty->driver->refcount--;
2135 list_del_init(&tty->tty_files);
2137 module_put(tty->driver->owner);
2138 free_tty_struct(tty);
2142 * Even releasing the tty structures is a tricky business.. We have
2143 * to be very careful that the structures are all released at the
2144 * same time, as interrupts might otherwise get the wrong pointers.
2146 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2147 * lead to double frees or releasing memory still in use.
2149 static void release_dev(struct file * filp)
2151 struct tty_struct *tty, *o_tty;
2152 int pty_master, tty_closing, o_tty_closing, do_sleep;
2156 unsigned long flags;
2158 tty = (struct tty_struct *)filp->private_data;
2159 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2162 check_tty_count(tty, "release_dev");
2164 tty_fasync(-1, filp, 0);
2167 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2168 tty->driver->subtype == PTY_TYPE_MASTER);
2169 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2172 #ifdef TTY_PARANOIA_CHECK
2173 if (idx < 0 || idx >= tty->driver->num) {
2174 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2175 "free (%s)\n", tty->name);
2178 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2179 if (tty != tty->driver->ttys[idx]) {
2180 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2181 "for (%s)\n", idx, tty->name);
2184 if (tty->termios != tty->driver->termios[idx]) {
2185 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2190 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2191 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2192 "termios_locked for (%s)\n",
2199 #ifdef TTY_DEBUG_HANGUP
2200 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2201 tty_name(tty, buf), tty->count);
2204 #ifdef TTY_PARANOIA_CHECK
2205 if (tty->driver->other &&
2206 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2207 if (o_tty != tty->driver->other->ttys[idx]) {
2208 printk(KERN_DEBUG "release_dev: other->table[%d] "
2209 "not o_tty for (%s)\n",
2213 if (o_tty->termios != tty->driver->other->termios[idx]) {
2214 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2215 "not o_termios for (%s)\n",
2219 if (o_tty->termios_locked !=
2220 tty->driver->other->termios_locked[idx]) {
2221 printk(KERN_DEBUG "release_dev: other->termios_locked["
2222 "%d] not o_termios_locked for (%s)\n",
2226 if (o_tty->link != tty) {
2227 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2232 if (tty->driver->close)
2233 tty->driver->close(tty, filp);
2236 * Sanity check: if tty->count is going to zero, there shouldn't be
2237 * any waiters on tty->read_wait or tty->write_wait. We test the
2238 * wait queues and kick everyone out _before_ actually starting to
2239 * close. This ensures that we won't block while releasing the tty
2242 * The test for the o_tty closing is necessary, since the master and
2243 * slave sides may close in any order. If the slave side closes out
2244 * first, its count will be one, since the master side holds an open.
2245 * Thus this test wouldn't be triggered at the time the slave closes,
2248 * Note that it's possible for the tty to be opened again while we're
2249 * flushing out waiters. By recalculating the closing flags before
2250 * each iteration we avoid any problems.
2253 /* Guard against races with tty->count changes elsewhere and
2254 opens on /dev/tty */
2256 mutex_lock(&tty_mutex);
2257 tty_closing = tty->count <= 1;
2258 o_tty_closing = o_tty &&
2259 (o_tty->count <= (pty_master ? 1 : 0));
2263 if (waitqueue_active(&tty->read_wait)) {
2264 wake_up(&tty->read_wait);
2267 if (waitqueue_active(&tty->write_wait)) {
2268 wake_up(&tty->write_wait);
2272 if (o_tty_closing) {
2273 if (waitqueue_active(&o_tty->read_wait)) {
2274 wake_up(&o_tty->read_wait);
2277 if (waitqueue_active(&o_tty->write_wait)) {
2278 wake_up(&o_tty->write_wait);
2285 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2286 "active!\n", tty_name(tty, buf));
2287 mutex_unlock(&tty_mutex);
2292 * The closing flags are now consistent with the open counts on
2293 * both sides, and we've completed the last operation that could
2294 * block, so it's safe to proceed with closing.
2297 if (--o_tty->count < 0) {
2298 printk(KERN_WARNING "release_dev: bad pty slave count "
2300 o_tty->count, tty_name(o_tty, buf));
2304 if (--tty->count < 0) {
2305 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2306 tty->count, tty_name(tty, buf));
2311 * We've decremented tty->count, so we need to remove this file
2312 * descriptor off the tty->tty_files list; this serves two
2314 * - check_tty_count sees the correct number of file descriptors
2315 * associated with this tty.
2316 * - do_tty_hangup no longer sees this file descriptor as
2317 * something that needs to be handled for hangups.
2320 filp->private_data = NULL;
2323 * Perform some housekeeping before deciding whether to return.
2325 * Set the TTY_CLOSING flag if this was the last open. In the
2326 * case of a pty we may have to wait around for the other side
2327 * to close, and TTY_CLOSING makes sure we can't be reopened.
2330 set_bit(TTY_CLOSING, &tty->flags);
2332 set_bit(TTY_CLOSING, &o_tty->flags);
2335 * If _either_ side is closing, make sure there aren't any
2336 * processes that still think tty or o_tty is their controlling
2339 if (tty_closing || o_tty_closing) {
2340 struct task_struct *p;
2342 read_lock(&tasklist_lock);
2343 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2344 p->signal->tty = NULL;
2345 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2347 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
2348 p->signal->tty = NULL;
2349 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
2350 read_unlock(&tasklist_lock);
2353 mutex_unlock(&tty_mutex);
2355 /* check whether both sides are closing ... */
2356 if (!tty_closing || (o_tty && !o_tty_closing))
2359 #ifdef TTY_DEBUG_HANGUP
2360 printk(KERN_DEBUG "freeing tty structure...");
2363 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2364 * kill any delayed work. As this is the final close it does not
2365 * race with the set_ldisc code path.
2367 clear_bit(TTY_LDISC, &tty->flags);
2368 cancel_delayed_work(&tty->buf.work);
2371 * Wait for ->hangup_work and ->buf.work handlers to terminate
2374 flush_scheduled_work();
2377 * Wait for any short term users (we know they are just driver
2378 * side waiters as the file is closing so user count on the file
2381 spin_lock_irqsave(&tty_ldisc_lock, flags);
2382 while(tty->ldisc.refcount)
2384 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2385 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2386 spin_lock_irqsave(&tty_ldisc_lock, flags);
2388 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2390 * Shutdown the current line discipline, and reset it to N_TTY.
2391 * N.B. why reset ldisc when we're releasing the memory??
2393 * FIXME: this MUST get fixed for the new reflocking
2395 if (tty->ldisc.close)
2396 (tty->ldisc.close)(tty);
2397 tty_ldisc_put(tty->ldisc.num);
2400 * Switch the line discipline back
2402 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2403 tty_set_termios_ldisc(tty,N_TTY);
2405 /* FIXME: could o_tty be in setldisc here ? */
2406 clear_bit(TTY_LDISC, &o_tty->flags);
2407 if (o_tty->ldisc.close)
2408 (o_tty->ldisc.close)(o_tty);
2409 tty_ldisc_put(o_tty->ldisc.num);
2410 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2411 tty_set_termios_ldisc(o_tty,N_TTY);
2414 * The release_mem function takes care of the details of clearing
2415 * the slots and preserving the termios structure.
2417 release_mem(tty, idx);
2419 #ifdef CONFIG_UNIX98_PTYS
2420 /* Make this pty number available for reallocation */
2422 down(&allocated_ptys_lock);
2423 idr_remove(&allocated_ptys, idx);
2424 up(&allocated_ptys_lock);
2431 * tty_open - open a tty device
2432 * @inode: inode of device file
2433 * @filp: file pointer to tty
2435 * tty_open and tty_release keep up the tty count that contains the
2436 * number of opens done on a tty. We cannot use the inode-count, as
2437 * different inodes might point to the same tty.
2439 * Open-counting is needed for pty masters, as well as for keeping
2440 * track of serial lines: DTR is dropped when the last close happens.
2441 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2443 * The termios state of a pty is reset on first open so that
2444 * settings don't persist across reuse.
2446 * Locking: tty_mutex protects current->signal->tty, get_tty_driver and
2447 * init_dev work. tty->count should protect the rest.
2448 * task_lock is held to update task details for sessions
2451 static int tty_open(struct inode * inode, struct file * filp)
2453 struct tty_struct *tty;
2455 struct tty_driver *driver;
2457 dev_t device = inode->i_rdev;
2458 unsigned short saved_flags = filp->f_flags;
2460 nonseekable_open(inode, filp);
2463 noctty = filp->f_flags & O_NOCTTY;
2467 mutex_lock(&tty_mutex);
2469 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2470 if (!current->signal->tty) {
2471 mutex_unlock(&tty_mutex);
2474 driver = current->signal->tty->driver;
2475 index = current->signal->tty->index;
2476 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2481 if (device == MKDEV(TTY_MAJOR,0)) {
2482 extern struct tty_driver *console_driver;
2483 driver = console_driver;
2489 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2490 driver = console_device(&index);
2492 /* Don't let /dev/console block */
2493 filp->f_flags |= O_NONBLOCK;
2497 mutex_unlock(&tty_mutex);
2501 driver = get_tty_driver(device, &index);
2503 mutex_unlock(&tty_mutex);
2507 retval = init_dev(driver, index, &tty);
2508 mutex_unlock(&tty_mutex);
2512 filp->private_data = tty;
2513 file_move(filp, &tty->tty_files);
2514 check_tty_count(tty, "tty_open");
2515 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2516 tty->driver->subtype == PTY_TYPE_MASTER)
2518 #ifdef TTY_DEBUG_HANGUP
2519 printk(KERN_DEBUG "opening %s...", tty->name);
2522 if (tty->driver->open)
2523 retval = tty->driver->open(tty, filp);
2527 filp->f_flags = saved_flags;
2529 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2533 #ifdef TTY_DEBUG_HANGUP
2534 printk(KERN_DEBUG "error %d in opening %s...", retval,
2538 if (retval != -ERESTARTSYS)
2540 if (signal_pending(current))
2544 * Need to reset f_op in case a hangup happened.
2546 if (filp->f_op == &hung_up_tty_fops)
2547 filp->f_op = &tty_fops;
2551 current->signal->leader &&
2552 !current->signal->tty &&
2553 tty->session == 0) {
2555 current->signal->tty = tty;
2556 task_unlock(current);
2557 current->signal->tty_old_pgrp = 0;
2558 tty->session = current->signal->session;
2559 tty->pgrp = process_group(current);
2564 #ifdef CONFIG_UNIX98_PTYS
2566 * ptmx_open - open a unix 98 pty master
2567 * @inode: inode of device file
2568 * @filp: file pointer to tty
2570 * Allocate a unix98 pty master device from the ptmx driver.
2572 * Locking: tty_mutex protects theinit_dev work. tty->count should
2574 * allocated_ptys_lock handles the list of free pty numbers
2577 static int ptmx_open(struct inode * inode, struct file * filp)
2579 struct tty_struct *tty;
2584 nonseekable_open(inode, filp);
2586 /* find a device that is not in use. */
2587 down(&allocated_ptys_lock);
2588 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2589 up(&allocated_ptys_lock);
2592 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2594 up(&allocated_ptys_lock);
2595 if (idr_ret == -EAGAIN)
2599 if (index >= pty_limit) {
2600 idr_remove(&allocated_ptys, index);
2601 up(&allocated_ptys_lock);
2604 up(&allocated_ptys_lock);
2606 mutex_lock(&tty_mutex);
2607 retval = init_dev(ptm_driver, index, &tty);
2608 mutex_unlock(&tty_mutex);
2613 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2614 filp->private_data = tty;
2615 file_move(filp, &tty->tty_files);
2618 if (devpts_pty_new(tty->link))
2621 check_tty_count(tty, "tty_open");
2622 retval = ptm_driver->open(tty, filp);
2629 down(&allocated_ptys_lock);
2630 idr_remove(&allocated_ptys, index);
2631 up(&allocated_ptys_lock);
2637 * tty_release - vfs callback for close
2638 * @inode: inode of tty
2639 * @filp: file pointer for handle to tty
2641 * Called the last time each file handle is closed that references
2642 * this tty. There may however be several such references.
2645 * Takes bkl. See release_dev
2648 static int tty_release(struct inode * inode, struct file * filp)
2657 * tty_poll - check tty status
2658 * @filp: file being polled
2659 * @wait: poll wait structures to update
2661 * Call the line discipline polling method to obtain the poll
2662 * status of the device.
2664 * Locking: locks called line discipline but ldisc poll method
2665 * may be re-entered freely by other callers.
2668 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2670 struct tty_struct * tty;
2671 struct tty_ldisc *ld;
2674 tty = (struct tty_struct *)filp->private_data;
2675 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2678 ld = tty_ldisc_ref_wait(tty);
2680 ret = (ld->poll)(tty, filp, wait);
2681 tty_ldisc_deref(ld);
2685 static int tty_fasync(int fd, struct file * filp, int on)
2687 struct tty_struct * tty;
2690 tty = (struct tty_struct *)filp->private_data;
2691 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2694 retval = fasync_helper(fd, filp, on, &tty->fasync);
2699 if (!waitqueue_active(&tty->read_wait))
2700 tty->minimum_to_wake = 1;
2701 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2705 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2706 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2712 * tiocsti - fake input character
2713 * @tty: tty to fake input into
2714 * @p: pointer to character
2716 * Fake input to a tty device. Does the neccessary locking and
2719 * FIXME: does not honour flow control ??
2722 * Called functions take tty_ldisc_lock
2723 * current->signal->tty check is safe without locks
2725 * FIXME: may race normal receive processing
2728 static int tiocsti(struct tty_struct *tty, char __user *p)
2731 struct tty_ldisc *ld;
2733 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2735 if (get_user(ch, p))
2737 ld = tty_ldisc_ref_wait(tty);
2738 ld->receive_buf(tty, &ch, &mbz, 1);
2739 tty_ldisc_deref(ld);
2744 * tiocgwinsz - implement window query ioctl
2746 * @arg: user buffer for result
2748 * Copies the kernel idea of the window size into the user buffer.
2750 * Locking: tty->termios_sem is taken to ensure the winsize data
2754 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2758 mutex_lock(&tty->termios_mutex);
2759 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2760 mutex_unlock(&tty->termios_mutex);
2762 return err ? -EFAULT: 0;
2766 * tiocswinsz - implement window size set ioctl
2768 * @arg: user buffer for result
2770 * Copies the user idea of the window size to the kernel. Traditionally
2771 * this is just advisory information but for the Linux console it
2772 * actually has driver level meaning and triggers a VC resize.
2775 * Called function use the console_sem is used to ensure we do
2776 * not try and resize the console twice at once.
2777 * The tty->termios_sem is used to ensure we don't double
2778 * resize and get confused. Lock order - tty->termios.sem before
2782 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2783 struct winsize __user * arg)
2785 struct winsize tmp_ws;
2787 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2790 mutex_lock(&tty->termios_mutex);
2791 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2795 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2796 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2798 mutex_unlock(&tty->termios_mutex);
2804 kill_pg(tty->pgrp, SIGWINCH, 1);
2805 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2806 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2807 tty->winsize = tmp_ws;
2808 real_tty->winsize = tmp_ws;
2810 mutex_unlock(&tty->termios_mutex);
2815 * tioccons - allow admin to move logical console
2816 * @file: the file to become console
2818 * Allow the adminstrator to move the redirected console device
2820 * Locking: uses redirect_lock to guard the redirect information
2823 static int tioccons(struct file *file)
2825 if (!capable(CAP_SYS_ADMIN))
2827 if (file->f_op->write == redirected_tty_write) {
2829 spin_lock(&redirect_lock);
2832 spin_unlock(&redirect_lock);
2837 spin_lock(&redirect_lock);
2839 spin_unlock(&redirect_lock);
2844 spin_unlock(&redirect_lock);
2849 * fionbio - non blocking ioctl
2850 * @file: file to set blocking value
2851 * @p: user parameter
2853 * Historical tty interfaces had a blocking control ioctl before
2854 * the generic functionality existed. This piece of history is preserved
2855 * in the expected tty API of posix OS's.
2857 * Locking: none, the open fle handle ensures it won't go away.
2860 static int fionbio(struct file *file, int __user *p)
2864 if (get_user(nonblock, p))
2868 file->f_flags |= O_NONBLOCK;
2870 file->f_flags &= ~O_NONBLOCK;
2875 * tiocsctty - set controlling tty
2876 * @tty: tty structure
2877 * @arg: user argument
2879 * This ioctl is used to manage job control. It permits a session
2880 * leader to set this tty as the controlling tty for the session.
2883 * Takes tasklist lock internally to walk sessions
2884 * Takes task_lock() when updating signal->tty
2885 * Takes tty_mutex() to protect tty instance
2889 static int tiocsctty(struct tty_struct *tty, int arg)
2891 struct task_struct *p;
2893 if (current->signal->leader &&
2894 (current->signal->session == tty->session))
2897 * The process must be a session leader and
2898 * not have a controlling tty already.
2900 if (!current->signal->leader || current->signal->tty)
2902 if (tty->session > 0) {
2904 * This tty is already the controlling
2905 * tty for another session group!
2907 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2912 read_lock(&tasklist_lock);
2913 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2914 p->signal->tty = NULL;
2915 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2916 read_unlock(&tasklist_lock);
2920 mutex_lock(&tty_mutex);
2922 current->signal->tty = tty;
2923 task_unlock(current);
2924 mutex_unlock(&tty_mutex);
2925 current->signal->tty_old_pgrp = 0;
2926 tty->session = current->signal->session;
2927 tty->pgrp = process_group(current);
2932 * tiocgpgrp - get process group
2933 * @tty: tty passed by user
2934 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2937 * Obtain the process group of the tty. If there is no process group
2940 * Locking: none. Reference to ->signal->tty is safe.
2943 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2946 * (tty == real_tty) is a cheap way of
2947 * testing if the tty is NOT a master pty.
2949 if (tty == real_tty && current->signal->tty != real_tty)
2951 return put_user(real_tty->pgrp, p);
2955 * tiocspgrp - attempt to set process group
2956 * @tty: tty passed by user
2957 * @real_tty: tty side device matching tty passed by user
2960 * Set the process group of the tty to the session passed. Only
2961 * permitted where the tty session is our session.
2966 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2969 int retval = tty_check_change(real_tty);
2975 if (!current->signal->tty ||
2976 (current->signal->tty != real_tty) ||
2977 (real_tty->session != current->signal->session))
2979 if (get_user(pgrp, p))
2983 if (session_of_pgrp(pgrp) != current->signal->session)
2985 real_tty->pgrp = pgrp;
2990 * tiocgsid - get session id
2991 * @tty: tty passed by user
2992 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2993 * @p: pointer to returned session id
2995 * Obtain the session id of the tty. If there is no session
2998 * Locking: none. Reference to ->signal->tty is safe.
3001 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3004 * (tty == real_tty) is a cheap way of
3005 * testing if the tty is NOT a master pty.
3007 if (tty == real_tty && current->signal->tty != real_tty)
3009 if (real_tty->session <= 0)
3011 return put_user(real_tty->session, p);
3015 * tiocsetd - set line discipline
3017 * @p: pointer to user data
3019 * Set the line discipline according to user request.
3021 * Locking: see tty_set_ldisc, this function is just a helper
3024 static int tiocsetd(struct tty_struct *tty, int __user *p)
3028 if (get_user(ldisc, p))
3030 return tty_set_ldisc(tty, ldisc);
3034 * send_break - performed time break
3035 * @tty: device to break on
3036 * @duration: timeout in mS
3038 * Perform a timed break on hardware that lacks its own driver level
3039 * timed break functionality.
3042 * atomic_write_lock serializes
3046 static int send_break(struct tty_struct *tty, unsigned int duration)
3048 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3050 tty->driver->break_ctl(tty, -1);
3051 if (!signal_pending(current)) {
3052 msleep_interruptible(duration);
3054 tty->driver->break_ctl(tty, 0);
3055 mutex_unlock(&tty->atomic_write_lock);
3056 if (signal_pending(current))
3062 * tiocmget - get modem status
3064 * @file: user file pointer
3065 * @p: pointer to result
3067 * Obtain the modem status bits from the tty driver if the feature
3068 * is supported. Return -EINVAL if it is not available.
3070 * Locking: none (up to the driver)
3073 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3075 int retval = -EINVAL;
3077 if (tty->driver->tiocmget) {
3078 retval = tty->driver->tiocmget(tty, file);
3081 retval = put_user(retval, p);
3087 * tiocmset - set modem status
3089 * @file: user file pointer
3090 * @cmd: command - clear bits, set bits or set all
3091 * @p: pointer to desired bits
3093 * Set the modem status bits from the tty driver if the feature
3094 * is supported. Return -EINVAL if it is not available.
3096 * Locking: none (up to the driver)
3099 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3102 int retval = -EINVAL;
3104 if (tty->driver->tiocmset) {
3105 unsigned int set, clear, val;
3107 retval = get_user(val, p);
3125 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3126 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3128 retval = tty->driver->tiocmset(tty, file, set, clear);
3134 * Split this up, as gcc can choke on it otherwise..
3136 int tty_ioctl(struct inode * inode, struct file * file,
3137 unsigned int cmd, unsigned long arg)
3139 struct tty_struct *tty, *real_tty;
3140 void __user *p = (void __user *)arg;
3142 struct tty_ldisc *ld;
3144 tty = (struct tty_struct *)file->private_data;
3145 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3148 /* CHECKME: is this safe as one end closes ? */
3151 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3152 tty->driver->subtype == PTY_TYPE_MASTER)
3153 real_tty = tty->link;
3156 * Break handling by driver
3158 if (!tty->driver->break_ctl) {
3162 if (tty->driver->ioctl)
3163 return tty->driver->ioctl(tty, file, cmd, arg);
3166 /* These two ioctl's always return success; even if */
3167 /* the driver doesn't support them. */
3170 if (!tty->driver->ioctl)
3172 retval = tty->driver->ioctl(tty, file, cmd, arg);
3173 if (retval == -ENOIOCTLCMD)
3180 * Factor out some common prep work
3188 retval = tty_check_change(tty);
3191 if (cmd != TIOCCBRK) {
3192 tty_wait_until_sent(tty, 0);
3193 if (signal_pending(current))
3201 return tiocsti(tty, p);
3203 return tiocgwinsz(tty, p);
3205 return tiocswinsz(tty, real_tty, p);
3207 return real_tty!=tty ? -EINVAL : tioccons(file);
3209 return fionbio(file, p);
3211 set_bit(TTY_EXCLUSIVE, &tty->flags);
3214 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3217 /* FIXME: taks lock or tty_mutex ? */
3218 if (current->signal->tty != tty)
3220 if (current->signal->leader)
3221 disassociate_ctty(0);
3223 current->signal->tty = NULL;
3224 task_unlock(current);
3227 return tiocsctty(tty, arg);
3229 return tiocgpgrp(tty, real_tty, p);
3231 return tiocspgrp(tty, real_tty, p);
3233 return tiocgsid(tty, real_tty, p);
3235 /* FIXME: check this is ok */
3236 return put_user(tty->ldisc.num, (int __user *)p);
3238 return tiocsetd(tty, p);
3241 return tioclinux(tty, arg);
3246 case TIOCSBRK: /* Turn break on, unconditionally */
3247 tty->driver->break_ctl(tty, -1);
3250 case TIOCCBRK: /* Turn break off, unconditionally */
3251 tty->driver->break_ctl(tty, 0);
3253 case TCSBRK: /* SVID version: non-zero arg --> no break */
3254 /* non-zero arg means wait for all output data
3255 * to be sent (performed above) but don't send break.
3256 * This is used by the tcdrain() termios function.
3259 return send_break(tty, 250);
3261 case TCSBRKP: /* support for POSIX tcsendbreak() */
3262 return send_break(tty, arg ? arg*100 : 250);
3265 return tty_tiocmget(tty, file, p);
3270 return tty_tiocmset(tty, file, cmd, p);
3272 if (tty->driver->ioctl) {
3273 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3274 if (retval != -ENOIOCTLCMD)
3277 ld = tty_ldisc_ref_wait(tty);
3280 retval = ld->ioctl(tty, file, cmd, arg);
3281 if (retval == -ENOIOCTLCMD)
3284 tty_ldisc_deref(ld);
3290 * This implements the "Secure Attention Key" --- the idea is to
3291 * prevent trojan horses by killing all processes associated with this
3292 * tty when the user hits the "Secure Attention Key". Required for
3293 * super-paranoid applications --- see the Orange Book for more details.
3295 * This code could be nicer; ideally it should send a HUP, wait a few
3296 * seconds, then send a INT, and then a KILL signal. But you then
3297 * have to coordinate with the init process, since all processes associated
3298 * with the current tty must be dead before the new getty is allowed
3301 * Now, if it would be correct ;-/ The current code has a nasty hole -
3302 * it doesn't catch files in flight. We may send the descriptor to ourselves
3303 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3305 * Nasty bug: do_SAK is being called in interrupt context. This can
3306 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3308 static void __do_SAK(struct work_struct *work)
3310 struct tty_struct *tty =
3311 container_of(work, struct tty_struct, SAK_work);
3315 struct task_struct *g, *p;
3319 struct tty_ldisc *disc;
3320 struct fdtable *fdt;
3324 session = tty->session;
3326 /* We don't want an ldisc switch during this */
3327 disc = tty_ldisc_ref(tty);
3328 if (disc && disc->flush_buffer)
3329 disc->flush_buffer(tty);
3330 tty_ldisc_deref(disc);
3332 if (tty->driver->flush_buffer)
3333 tty->driver->flush_buffer(tty);
3335 read_lock(&tasklist_lock);
3336 /* Kill the entire session */
3337 do_each_task_pid(session, PIDTYPE_SID, p) {
3338 printk(KERN_NOTICE "SAK: killed process %d"
3339 " (%s): p->signal->session==tty->session\n",
3341 send_sig(SIGKILL, p, 1);
3342 } while_each_task_pid(session, PIDTYPE_SID, p);
3343 /* Now kill any processes that happen to have the
3346 do_each_thread(g, p) {
3347 if (p->signal->tty == tty) {
3348 printk(KERN_NOTICE "SAK: killed process %d"
3349 " (%s): p->signal->session==tty->session\n",
3351 send_sig(SIGKILL, p, 1);
3357 * We don't take a ref to the file, so we must
3358 * hold ->file_lock instead.
3360 spin_lock(&p->files->file_lock);
3361 fdt = files_fdtable(p->files);
3362 for (i=0; i < fdt->max_fds; i++) {
3363 filp = fcheck_files(p->files, i);
3366 if (filp->f_op->read == tty_read &&
3367 filp->private_data == tty) {
3368 printk(KERN_NOTICE "SAK: killed process %d"
3369 " (%s): fd#%d opened to the tty\n",
3370 p->pid, p->comm, i);
3371 force_sig(SIGKILL, p);
3375 spin_unlock(&p->files->file_lock);
3378 } while_each_thread(g, p);
3379 read_unlock(&tasklist_lock);
3384 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3385 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3386 * the values which we write to it will be identical to the values which it
3387 * already has. --akpm
3389 void do_SAK(struct tty_struct *tty)
3393 PREPARE_WORK(&tty->SAK_work, __do_SAK);
3394 schedule_work(&tty->SAK_work);
3397 EXPORT_SYMBOL(do_SAK);
3401 * @work: tty structure passed from work queue.
3403 * This routine is called out of the software interrupt to flush data
3404 * from the buffer chain to the line discipline.
3406 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3407 * while invoking the line discipline receive_buf method. The
3408 * receive_buf method is single threaded for each tty instance.
3411 static void flush_to_ldisc(struct work_struct *work)
3413 struct tty_struct *tty =
3414 container_of(work, struct tty_struct, buf.work.work);
3415 unsigned long flags;
3416 struct tty_ldisc *disc;
3417 struct tty_buffer *tbuf, *head;
3419 unsigned char *flag_buf;
3421 disc = tty_ldisc_ref(tty);
3422 if (disc == NULL) /* !TTY_LDISC */
3425 spin_lock_irqsave(&tty->buf.lock, flags);
3426 head = tty->buf.head;
3428 tty->buf.head = NULL;
3430 int count = head->commit - head->read;
3432 if (head->next == NULL)
3436 tty_buffer_free(tty, tbuf);
3439 if (!tty->receive_room) {
3440 schedule_delayed_work(&tty->buf.work, 1);
3443 if (count > tty->receive_room)
3444 count = tty->receive_room;
3445 char_buf = head->char_buf_ptr + head->read;
3446 flag_buf = head->flag_buf_ptr + head->read;
3447 head->read += count;
3448 spin_unlock_irqrestore(&tty->buf.lock, flags);
3449 disc->receive_buf(tty, char_buf, flag_buf, count);
3450 spin_lock_irqsave(&tty->buf.lock, flags);
3452 tty->buf.head = head;
3454 spin_unlock_irqrestore(&tty->buf.lock, flags);
3456 tty_ldisc_deref(disc);
3460 * Routine which returns the baud rate of the tty
3462 * Note that the baud_table needs to be kept in sync with the
3463 * include/asm/termbits.h file.
3465 static int baud_table[] = {
3466 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3467 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3469 76800, 153600, 307200, 614400, 921600
3471 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3472 2500000, 3000000, 3500000, 4000000
3476 static int n_baud_table = ARRAY_SIZE(baud_table);
3479 * tty_termios_baud_rate
3480 * @termios: termios structure
3482 * Convert termios baud rate data into a speed. This should be called
3483 * with the termios lock held if this termios is a terminal termios
3484 * structure. May change the termios data.
3489 int tty_termios_baud_rate(struct termios *termios)
3493 cbaud = termios->c_cflag & CBAUD;
3495 if (cbaud & CBAUDEX) {
3498 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3499 termios->c_cflag &= ~CBAUDEX;
3503 return baud_table[cbaud];
3506 EXPORT_SYMBOL(tty_termios_baud_rate);
3509 * tty_get_baud_rate - get tty bit rates
3510 * @tty: tty to query
3512 * Returns the baud rate as an integer for this terminal. The
3513 * termios lock must be held by the caller and the terminal bit
3514 * flags may be updated.
3519 int tty_get_baud_rate(struct tty_struct *tty)
3521 int baud = tty_termios_baud_rate(tty->termios);
3523 if (baud == 38400 && tty->alt_speed) {
3525 printk(KERN_WARNING "Use of setserial/setrocket to "
3526 "set SPD_* flags is deprecated\n");
3529 baud = tty->alt_speed;
3535 EXPORT_SYMBOL(tty_get_baud_rate);
3538 * tty_flip_buffer_push - terminal
3541 * Queue a push of the terminal flip buffers to the line discipline. This
3542 * function must not be called from IRQ context if tty->low_latency is set.
3544 * In the event of the queue being busy for flipping the work will be
3545 * held off and retried later.
3547 * Locking: tty buffer lock. Driver locks in low latency mode.
3550 void tty_flip_buffer_push(struct tty_struct *tty)
3552 unsigned long flags;
3553 spin_lock_irqsave(&tty->buf.lock, flags);
3554 if (tty->buf.tail != NULL)
3555 tty->buf.tail->commit = tty->buf.tail->used;
3556 spin_unlock_irqrestore(&tty->buf.lock, flags);
3558 if (tty->low_latency)
3559 flush_to_ldisc(&tty->buf.work.work);
3561 schedule_delayed_work(&tty->buf.work, 1);
3564 EXPORT_SYMBOL(tty_flip_buffer_push);
3568 * initialize_tty_struct
3569 * @tty: tty to initialize
3571 * This subroutine initializes a tty structure that has been newly
3574 * Locking: none - tty in question must not be exposed at this point
3577 static void initialize_tty_struct(struct tty_struct *tty)
3579 memset(tty, 0, sizeof(struct tty_struct));
3580 tty->magic = TTY_MAGIC;
3581 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3583 tty->overrun_time = jiffies;
3584 tty->buf.head = tty->buf.tail = NULL;
3585 tty_buffer_init(tty);
3586 INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
3587 init_MUTEX(&tty->buf.pty_sem);
3588 mutex_init(&tty->termios_mutex);
3589 init_waitqueue_head(&tty->write_wait);
3590 init_waitqueue_head(&tty->read_wait);
3591 INIT_WORK(&tty->hangup_work, do_tty_hangup);
3592 mutex_init(&tty->atomic_read_lock);
3593 mutex_init(&tty->atomic_write_lock);
3594 spin_lock_init(&tty->read_lock);
3595 INIT_LIST_HEAD(&tty->tty_files);
3596 INIT_WORK(&tty->SAK_work, NULL);
3600 * The default put_char routine if the driver did not define one.
3603 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3605 tty->driver->write(tty, &ch, 1);
3608 static struct class *tty_class;
3611 * tty_register_device - register a tty device
3612 * @driver: the tty driver that describes the tty device
3613 * @index: the index in the tty driver for this tty device
3614 * @device: a struct device that is associated with this tty device.
3615 * This field is optional, if there is no known struct device
3616 * for this tty device it can be set to NULL safely.
3618 * Returns a pointer to the struct device for this tty device
3619 * (or ERR_PTR(-EFOO) on error).
3621 * This call is required to be made to register an individual tty device
3622 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3623 * that bit is not set, this function should not be called by a tty
3629 struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3630 struct device *device)
3633 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3635 if (index >= driver->num) {
3636 printk(KERN_ERR "Attempt to register invalid tty line number "
3638 return ERR_PTR(-EINVAL);
3641 if (driver->type == TTY_DRIVER_TYPE_PTY)
3642 pty_line_name(driver, index, name);
3644 tty_line_name(driver, index, name);
3646 return device_create(tty_class, device, dev, name);
3650 * tty_unregister_device - unregister a tty device
3651 * @driver: the tty driver that describes the tty device
3652 * @index: the index in the tty driver for this tty device
3654 * If a tty device is registered with a call to tty_register_device() then
3655 * this function must be called when the tty device is gone.
3660 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3662 device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3665 EXPORT_SYMBOL(tty_register_device);
3666 EXPORT_SYMBOL(tty_unregister_device);
3668 struct tty_driver *alloc_tty_driver(int lines)
3670 struct tty_driver *driver;
3672 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3674 memset(driver, 0, sizeof(struct tty_driver));
3675 driver->magic = TTY_DRIVER_MAGIC;
3676 driver->num = lines;
3677 /* later we'll move allocation of tables here */
3682 void put_tty_driver(struct tty_driver *driver)
3687 void tty_set_operations(struct tty_driver *driver,
3688 const struct tty_operations *op)
3690 driver->open = op->open;
3691 driver->close = op->close;
3692 driver->write = op->write;
3693 driver->put_char = op->put_char;
3694 driver->flush_chars = op->flush_chars;
3695 driver->write_room = op->write_room;
3696 driver->chars_in_buffer = op->chars_in_buffer;
3697 driver->ioctl = op->ioctl;
3698 driver->set_termios = op->set_termios;
3699 driver->throttle = op->throttle;
3700 driver->unthrottle = op->unthrottle;
3701 driver->stop = op->stop;
3702 driver->start = op->start;
3703 driver->hangup = op->hangup;
3704 driver->break_ctl = op->break_ctl;
3705 driver->flush_buffer = op->flush_buffer;
3706 driver->set_ldisc = op->set_ldisc;
3707 driver->wait_until_sent = op->wait_until_sent;
3708 driver->send_xchar = op->send_xchar;
3709 driver->read_proc = op->read_proc;
3710 driver->write_proc = op->write_proc;
3711 driver->tiocmget = op->tiocmget;
3712 driver->tiocmset = op->tiocmset;
3716 EXPORT_SYMBOL(alloc_tty_driver);
3717 EXPORT_SYMBOL(put_tty_driver);
3718 EXPORT_SYMBOL(tty_set_operations);
3721 * Called by a tty driver to register itself.
3723 int tty_register_driver(struct tty_driver *driver)
3730 if (driver->flags & TTY_DRIVER_INSTALLED)
3733 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3734 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3737 memset(p, 0, driver->num * 3 * sizeof(void *));
3740 if (!driver->major) {
3741 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3742 (char*)driver->name);
3744 driver->major = MAJOR(dev);
3745 driver->minor_start = MINOR(dev);
3748 dev = MKDEV(driver->major, driver->minor_start);
3749 error = register_chrdev_region(dev, driver->num,
3750 (char*)driver->name);
3758 driver->ttys = (struct tty_struct **)p;
3759 driver->termios = (struct termios **)(p + driver->num);
3760 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3762 driver->ttys = NULL;
3763 driver->termios = NULL;
3764 driver->termios_locked = NULL;
3767 cdev_init(&driver->cdev, &tty_fops);
3768 driver->cdev.owner = driver->owner;
3769 error = cdev_add(&driver->cdev, dev, driver->num);
3771 unregister_chrdev_region(dev, driver->num);
3772 driver->ttys = NULL;
3773 driver->termios = driver->termios_locked = NULL;
3778 if (!driver->put_char)
3779 driver->put_char = tty_default_put_char;
3781 list_add(&driver->tty_drivers, &tty_drivers);
3783 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3784 for(i = 0; i < driver->num; i++)
3785 tty_register_device(driver, i, NULL);
3787 proc_tty_register_driver(driver);
3791 EXPORT_SYMBOL(tty_register_driver);
3794 * Called by a tty driver to unregister itself.
3796 int tty_unregister_driver(struct tty_driver *driver)
3802 if (driver->refcount)
3805 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3808 list_del(&driver->tty_drivers);
3811 * Free the termios and termios_locked structures because
3812 * we don't want to get memory leaks when modular tty
3813 * drivers are removed from the kernel.
3815 for (i = 0; i < driver->num; i++) {
3816 tp = driver->termios[i];
3818 driver->termios[i] = NULL;
3821 tp = driver->termios_locked[i];
3823 driver->termios_locked[i] = NULL;
3826 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3827 tty_unregister_device(driver, i);
3830 proc_tty_unregister_driver(driver);
3831 driver->ttys = NULL;
3832 driver->termios = driver->termios_locked = NULL;
3834 cdev_del(&driver->cdev);
3838 EXPORT_SYMBOL(tty_unregister_driver);
3842 * Initialize the console device. This is called *early*, so
3843 * we can't necessarily depend on lots of kernel help here.
3844 * Just do some early initializations, and do the complex setup
3847 void __init console_init(void)
3851 /* Setup the default TTY line discipline. */
3852 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3855 * set up the console device so that later boot sequences can
3856 * inform about problems etc..
3858 #ifdef CONFIG_EARLY_PRINTK
3859 disable_early_printk();
3861 call = __con_initcall_start;
3862 while (call < __con_initcall_end) {
3869 extern int vty_init(void);
3872 static int __init tty_class_init(void)
3874 tty_class = class_create(THIS_MODULE, "tty");
3875 if (IS_ERR(tty_class))
3876 return PTR_ERR(tty_class);
3880 postcore_initcall(tty_class_init);
3882 /* 3/2004 jmc: why do these devices exist? */
3884 static struct cdev tty_cdev, console_cdev;
3885 #ifdef CONFIG_UNIX98_PTYS
3886 static struct cdev ptmx_cdev;
3889 static struct cdev vc0_cdev;
3893 * Ok, now we can initialize the rest of the tty devices and can count
3894 * on memory allocations, interrupts etc..
3896 static int __init tty_init(void)
3898 cdev_init(&tty_cdev, &tty_fops);
3899 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3900 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3901 panic("Couldn't register /dev/tty driver\n");
3902 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
3904 cdev_init(&console_cdev, &console_fops);
3905 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3906 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3907 panic("Couldn't register /dev/console driver\n");
3908 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
3910 #ifdef CONFIG_UNIX98_PTYS
3911 cdev_init(&ptmx_cdev, &ptmx_fops);
3912 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3913 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3914 panic("Couldn't register /dev/ptmx driver\n");
3915 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
3919 cdev_init(&vc0_cdev, &console_fops);
3920 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3921 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3922 panic("Couldn't register /dev/tty0 driver\n");
3923 device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
3929 module_init(tty_init);