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(void *data)
1279 struct tty_struct *tty = (struct tty_struct *) data;
1280 struct file * cons_filp = NULL;
1281 struct file *filp, *f = NULL;
1282 struct task_struct *p;
1283 struct tty_ldisc *ld;
1284 int closecount = 0, n;
1289 /* inuse_filps is protected by the single kernel lock */
1292 spin_lock(&redirect_lock);
1293 if (redirect && redirect->private_data == tty) {
1297 spin_unlock(&redirect_lock);
1299 check_tty_count(tty, "do_tty_hangup");
1301 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1302 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1303 if (filp->f_op->write == redirected_tty_write)
1305 if (filp->f_op->write != tty_write)
1308 tty_fasync(-1, filp, 0); /* can't block */
1309 filp->f_op = &hung_up_tty_fops;
1313 /* FIXME! What are the locking issues here? This may me overdoing things..
1314 * this question is especially important now that we've removed the irqlock. */
1316 ld = tty_ldisc_ref(tty);
1317 if(ld != NULL) /* We may have no line discipline at this point */
1319 if (ld->flush_buffer)
1320 ld->flush_buffer(tty);
1321 if (tty->driver->flush_buffer)
1322 tty->driver->flush_buffer(tty);
1323 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1325 ld->write_wakeup(tty);
1330 /* FIXME: Once we trust the LDISC code better we can wait here for
1331 ldisc completion and fix the driver call race */
1333 wake_up_interruptible(&tty->write_wait);
1334 wake_up_interruptible(&tty->read_wait);
1337 * Shutdown the current line discipline, and reset it to
1340 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1342 mutex_lock(&tty->termios_mutex);
1343 *tty->termios = tty->driver->init_termios;
1344 mutex_unlock(&tty->termios_mutex);
1347 /* Defer ldisc switch */
1348 /* tty_deferred_ldisc_switch(N_TTY);
1350 This should get done automatically when the port closes and
1351 tty_release is called */
1353 read_lock(&tasklist_lock);
1354 if (tty->session > 0) {
1355 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1356 if (p->signal->tty == tty)
1357 p->signal->tty = NULL;
1358 if (!p->signal->leader)
1360 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1361 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1363 p->signal->tty_old_pgrp = tty->pgrp;
1364 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1366 read_unlock(&tasklist_lock);
1371 tty->ctrl_status = 0;
1373 * If one of the devices matches a console pointer, we
1374 * cannot just call hangup() because that will cause
1375 * tty->count and state->count to go out of sync.
1376 * So we just call close() the right number of times.
1379 if (tty->driver->close)
1380 for (n = 0; n < closecount; n++)
1381 tty->driver->close(tty, cons_filp);
1382 } else if (tty->driver->hangup)
1383 (tty->driver->hangup)(tty);
1385 /* We don't want to have driver/ldisc interactions beyond
1386 the ones we did here. The driver layer expects no
1387 calls after ->hangup() from the ldisc side. However we
1388 can't yet guarantee all that */
1390 set_bit(TTY_HUPPED, &tty->flags);
1392 tty_ldisc_enable(tty);
1393 tty_ldisc_deref(ld);
1401 * tty_hangup - trigger a hangup event
1402 * @tty: tty to hangup
1404 * A carrier loss (virtual or otherwise) has occurred on this like
1405 * schedule a hangup sequence to run after this event.
1408 void tty_hangup(struct tty_struct * tty)
1410 #ifdef TTY_DEBUG_HANGUP
1413 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1415 schedule_work(&tty->hangup_work);
1418 EXPORT_SYMBOL(tty_hangup);
1421 * tty_vhangup - process vhangup
1422 * @tty: tty to hangup
1424 * The user has asked via system call for the terminal to be hung up.
1425 * We do this synchronously so that when the syscall returns the process
1426 * is complete. That guarantee is neccessary for security reasons.
1429 void tty_vhangup(struct tty_struct * tty)
1431 #ifdef TTY_DEBUG_HANGUP
1434 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1436 do_tty_hangup((void *) tty);
1438 EXPORT_SYMBOL(tty_vhangup);
1441 * tty_hung_up_p - was tty hung up
1442 * @filp: file pointer of tty
1444 * Return true if the tty has been subject to a vhangup or a carrier
1448 int tty_hung_up_p(struct file * filp)
1450 return (filp->f_op == &hung_up_tty_fops);
1453 EXPORT_SYMBOL(tty_hung_up_p);
1456 * disassociate_ctty - disconnect controlling tty
1457 * @on_exit: true if exiting so need to "hang up" the session
1459 * This function is typically called only by the session leader, when
1460 * it wants to disassociate itself from its controlling tty.
1462 * It performs the following functions:
1463 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1464 * (2) Clears the tty from being controlling the session
1465 * (3) Clears the controlling tty for all processes in the
1468 * The argument on_exit is set to 1 if called when a process is
1469 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1471 * Locking: tty_mutex is taken to protect current->signal->tty
1472 * BKL is taken for hysterical raisins
1473 * Tasklist lock is taken (under tty_mutex) to walk process
1474 * lists for the session.
1477 void disassociate_ctty(int on_exit)
1479 struct tty_struct *tty;
1480 struct task_struct *p;
1485 mutex_lock(&tty_mutex);
1486 tty = current->signal->tty;
1488 tty_pgrp = tty->pgrp;
1489 mutex_unlock(&tty_mutex);
1490 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1493 if (current->signal->tty_old_pgrp) {
1494 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1495 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1497 mutex_unlock(&tty_mutex);
1502 kill_pg(tty_pgrp, SIGHUP, on_exit);
1504 kill_pg(tty_pgrp, SIGCONT, on_exit);
1507 /* Must lock changes to tty_old_pgrp */
1508 mutex_lock(&tty_mutex);
1509 current->signal->tty_old_pgrp = 0;
1513 /* Now clear signal->tty under the lock */
1514 read_lock(&tasklist_lock);
1515 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1516 p->signal->tty = NULL;
1517 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1518 read_unlock(&tasklist_lock);
1519 mutex_unlock(&tty_mutex);
1525 * stop_tty - propogate flow control
1528 * Perform flow control to the driver. For PTY/TTY pairs we
1529 * must also propogate the TIOCKPKT status. May be called
1530 * on an already stopped device and will not re-call the driver
1533 * This functionality is used by both the line disciplines for
1534 * halting incoming flow and by the driver. It may therefore be
1535 * called from any context, may be under the tty atomic_write_lock
1539 * Broken. Relies on BKL which is unsafe here.
1542 void stop_tty(struct tty_struct *tty)
1547 if (tty->link && tty->link->packet) {
1548 tty->ctrl_status &= ~TIOCPKT_START;
1549 tty->ctrl_status |= TIOCPKT_STOP;
1550 wake_up_interruptible(&tty->link->read_wait);
1552 if (tty->driver->stop)
1553 (tty->driver->stop)(tty);
1556 EXPORT_SYMBOL(stop_tty);
1559 * start_tty - propogate flow control
1560 * @tty: tty to start
1562 * Start a tty that has been stopped if at all possible. Perform
1563 * any neccessary wakeups and propogate the TIOCPKT status. If this
1564 * is the tty was previous stopped and is being started then the
1565 * driver start method is invoked and the line discipline woken.
1568 * Broken. Relies on BKL which is unsafe here.
1571 void start_tty(struct tty_struct *tty)
1573 if (!tty->stopped || tty->flow_stopped)
1576 if (tty->link && tty->link->packet) {
1577 tty->ctrl_status &= ~TIOCPKT_STOP;
1578 tty->ctrl_status |= TIOCPKT_START;
1579 wake_up_interruptible(&tty->link->read_wait);
1581 if (tty->driver->start)
1582 (tty->driver->start)(tty);
1584 /* If we have a running line discipline it may need kicking */
1586 wake_up_interruptible(&tty->write_wait);
1589 EXPORT_SYMBOL(start_tty);
1592 * tty_read - read method for tty device files
1593 * @file: pointer to tty file
1595 * @count: size of user buffer
1598 * Perform the read system call function on this terminal device. Checks
1599 * for hung up devices before calling the line discipline method.
1602 * Locks the line discipline internally while needed
1603 * For historical reasons the line discipline read method is
1604 * invoked under the BKL. This will go away in time so do not rely on it
1605 * in new code. Multiple read calls may be outstanding in parallel.
1608 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1612 struct tty_struct * tty;
1613 struct inode *inode;
1614 struct tty_ldisc *ld;
1616 tty = (struct tty_struct *)file->private_data;
1617 inode = file->f_dentry->d_inode;
1618 if (tty_paranoia_check(tty, inode, "tty_read"))
1620 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1623 /* We want to wait for the line discipline to sort out in this
1625 ld = tty_ldisc_ref_wait(tty);
1628 i = (ld->read)(tty,file,buf,count);
1631 tty_ldisc_deref(ld);
1634 inode->i_atime = current_fs_time(inode->i_sb);
1639 * Split writes up in sane blocksizes to avoid
1640 * denial-of-service type attacks
1642 static inline ssize_t do_tty_write(
1643 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1644 struct tty_struct *tty,
1646 const char __user *buf,
1649 ssize_t ret = 0, written = 0;
1652 /* FIXME: O_NDELAY ... */
1653 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1654 return -ERESTARTSYS;
1658 * We chunk up writes into a temporary buffer. This
1659 * simplifies low-level drivers immensely, since they
1660 * don't have locking issues and user mode accesses.
1662 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1665 * The default chunk-size is 2kB, because the NTTY
1666 * layer has problems with bigger chunks. It will
1667 * claim to be able to handle more characters than
1670 * FIXME: This can probably go away now except that 64K chunks
1671 * are too likely to fail unless switched to vmalloc...
1674 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1679 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1680 if (tty->write_cnt < chunk) {
1686 buf = kmalloc(chunk, GFP_KERNEL);
1688 mutex_unlock(&tty->atomic_write_lock);
1691 kfree(tty->write_buf);
1692 tty->write_cnt = chunk;
1693 tty->write_buf = buf;
1696 /* Do the write .. */
1698 size_t size = count;
1702 if (copy_from_user(tty->write_buf, buf, size))
1705 ret = write(tty, file, tty->write_buf, size);
1715 if (signal_pending(current))
1720 struct inode *inode = file->f_dentry->d_inode;
1721 inode->i_mtime = current_fs_time(inode->i_sb);
1724 mutex_unlock(&tty->atomic_write_lock);
1730 * tty_write - write method for tty device file
1731 * @file: tty file pointer
1732 * @buf: user data to write
1733 * @count: bytes to write
1736 * Write data to a tty device via the line discipline.
1739 * Locks the line discipline as required
1740 * Writes to the tty driver are serialized by the atomic_write_lock
1741 * and are then processed in chunks to the device. The line discipline
1742 * write method will not be involked in parallel for each device
1743 * The line discipline write method is called under the big
1744 * kernel lock for historical reasons. New code should not rely on this.
1747 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1750 struct tty_struct * tty;
1751 struct inode *inode = file->f_dentry->d_inode;
1753 struct tty_ldisc *ld;
1755 tty = (struct tty_struct *)file->private_data;
1756 if (tty_paranoia_check(tty, inode, "tty_write"))
1758 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1761 ld = tty_ldisc_ref_wait(tty);
1765 ret = do_tty_write(ld->write, tty, file, buf, count);
1766 tty_ldisc_deref(ld);
1770 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1773 struct file *p = NULL;
1775 spin_lock(&redirect_lock);
1780 spin_unlock(&redirect_lock);
1784 res = vfs_write(p, buf, count, &p->f_pos);
1789 return tty_write(file, buf, count, ppos);
1792 static char ptychar[] = "pqrstuvwxyzabcde";
1795 * pty_line_name - generate name for a pty
1796 * @driver: the tty driver in use
1797 * @index: the minor number
1798 * @p: output buffer of at least 6 bytes
1800 * Generate a name from a driver reference and write it to the output
1805 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1807 int i = index + driver->name_base;
1808 /* ->name is initialized to "ttyp", but "tty" is expected */
1809 sprintf(p, "%s%c%x",
1810 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1811 ptychar[i >> 4 & 0xf], i & 0xf);
1815 * pty_line_name - generate name for a tty
1816 * @driver: the tty driver in use
1817 * @index: the minor number
1818 * @p: output buffer of at least 7 bytes
1820 * Generate a name from a driver reference and write it to the output
1825 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1827 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1831 * init_dev - initialise a tty device
1832 * @driver: tty driver we are opening a device on
1833 * @idx: device index
1834 * @tty: returned tty structure
1836 * Prepare a tty device. This may not be a "new" clean device but
1837 * could also be an active device. The pty drivers require special
1838 * handling because of this.
1841 * The function is called under the tty_mutex, which
1842 * protects us from the tty struct or driver itself going away.
1844 * On exit the tty device has the line discipline attached and
1845 * a reference count of 1. If a pair was created for pty/tty use
1846 * and the other was a pty master then it too has a reference count of 1.
1848 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1849 * failed open. The new code protects the open with a mutex, so it's
1850 * really quite straightforward. The mutex locking can probably be
1851 * relaxed for the (most common) case of reopening a tty.
1854 static int init_dev(struct tty_driver *driver, int idx,
1855 struct tty_struct **ret_tty)
1857 struct tty_struct *tty, *o_tty;
1858 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1859 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1862 /* check whether we're reopening an existing tty */
1863 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1864 tty = devpts_get_tty(idx);
1865 if (tty && driver->subtype == PTY_TYPE_MASTER)
1868 tty = driver->ttys[idx];
1870 if (tty) goto fast_track;
1873 * First time open is complex, especially for PTY devices.
1874 * This code guarantees that either everything succeeds and the
1875 * TTY is ready for operation, or else the table slots are vacated
1876 * and the allocated memory released. (Except that the termios
1877 * and locked termios may be retained.)
1880 if (!try_module_get(driver->owner)) {
1889 tty = alloc_tty_struct();
1892 initialize_tty_struct(tty);
1893 tty->driver = driver;
1895 tty_line_name(driver, idx, tty->name);
1897 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1898 tp_loc = &tty->termios;
1899 ltp_loc = &tty->termios_locked;
1901 tp_loc = &driver->termios[idx];
1902 ltp_loc = &driver->termios_locked[idx];
1906 tp = (struct termios *) kmalloc(sizeof(struct termios),
1910 *tp = driver->init_termios;
1914 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1918 memset(ltp, 0, sizeof(struct termios));
1921 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1922 o_tty = alloc_tty_struct();
1925 initialize_tty_struct(o_tty);
1926 o_tty->driver = driver->other;
1928 tty_line_name(driver->other, idx, o_tty->name);
1930 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1931 o_tp_loc = &o_tty->termios;
1932 o_ltp_loc = &o_tty->termios_locked;
1934 o_tp_loc = &driver->other->termios[idx];
1935 o_ltp_loc = &driver->other->termios_locked[idx];
1939 o_tp = (struct termios *)
1940 kmalloc(sizeof(struct termios), GFP_KERNEL);
1943 *o_tp = driver->other->init_termios;
1947 o_ltp = (struct termios *)
1948 kmalloc(sizeof(struct termios), GFP_KERNEL);
1951 memset(o_ltp, 0, sizeof(struct termios));
1955 * Everything allocated ... set up the o_tty structure.
1957 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1958 driver->other->ttys[idx] = o_tty;
1964 o_tty->termios = *o_tp_loc;
1965 o_tty->termios_locked = *o_ltp_loc;
1966 driver->other->refcount++;
1967 if (driver->subtype == PTY_TYPE_MASTER)
1970 /* Establish the links in both directions */
1976 * All structures have been allocated, so now we install them.
1977 * Failures after this point use release_mem to clean up, so
1978 * there's no need to null out the local pointers.
1980 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1981 driver->ttys[idx] = tty;
1988 tty->termios = *tp_loc;
1989 tty->termios_locked = *ltp_loc;
1994 * Structures all installed ... call the ldisc open routines.
1995 * If we fail here just call release_mem to clean up. No need
1996 * to decrement the use counts, as release_mem doesn't care.
1999 if (tty->ldisc.open) {
2000 retval = (tty->ldisc.open)(tty);
2002 goto release_mem_out;
2004 if (o_tty && o_tty->ldisc.open) {
2005 retval = (o_tty->ldisc.open)(o_tty);
2007 if (tty->ldisc.close)
2008 (tty->ldisc.close)(tty);
2009 goto release_mem_out;
2011 tty_ldisc_enable(o_tty);
2013 tty_ldisc_enable(tty);
2017 * This fast open can be used if the tty is already open.
2018 * No memory is allocated, and the only failures are from
2019 * attempting to open a closing tty or attempting multiple
2020 * opens on a pty master.
2023 if (test_bit(TTY_CLOSING, &tty->flags)) {
2027 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2028 driver->subtype == PTY_TYPE_MASTER) {
2030 * special case for PTY masters: only one open permitted,
2031 * and the slave side open count is incremented as well.
2040 tty->driver = driver; /* N.B. why do this every time?? */
2043 if(!test_bit(TTY_LDISC, &tty->flags))
2044 printk(KERN_ERR "init_dev but no ldisc\n");
2048 /* All paths come through here to release the mutex */
2052 /* Release locally allocated memory ... nothing placed in slots */
2056 free_tty_struct(o_tty);
2059 free_tty_struct(tty);
2062 module_put(driver->owner);
2066 /* call the tty release_mem routine to clean out this slot */
2068 printk(KERN_INFO "init_dev: ldisc open failed, "
2069 "clearing slot %d\n", idx);
2070 release_mem(tty, idx);
2075 * release_mem - release tty structure memory
2077 * Releases memory associated with a tty structure, and clears out the
2078 * driver table slots. This function is called when a device is no longer
2079 * in use. It also gets called when setup of a device fails.
2082 * tty_mutex - sometimes only
2083 * takes the file list lock internally when working on the list
2084 * of ttys that the driver keeps.
2085 * FIXME: should we require tty_mutex is held here ??
2088 static void release_mem(struct tty_struct *tty, int idx)
2090 struct tty_struct *o_tty;
2092 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2094 if ((o_tty = tty->link) != NULL) {
2096 o_tty->driver->ttys[idx] = NULL;
2097 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2098 tp = o_tty->termios;
2100 o_tty->driver->termios[idx] = NULL;
2103 tp = o_tty->termios_locked;
2105 o_tty->driver->termios_locked[idx] = NULL;
2109 o_tty->driver->refcount--;
2111 list_del_init(&o_tty->tty_files);
2113 free_tty_struct(o_tty);
2117 tty->driver->ttys[idx] = NULL;
2118 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2121 tty->driver->termios[idx] = NULL;
2124 tp = tty->termios_locked;
2126 tty->driver->termios_locked[idx] = NULL;
2131 tty->driver->refcount--;
2133 list_del_init(&tty->tty_files);
2135 module_put(tty->driver->owner);
2136 free_tty_struct(tty);
2140 * Even releasing the tty structures is a tricky business.. We have
2141 * to be very careful that the structures are all released at the
2142 * same time, as interrupts might otherwise get the wrong pointers.
2144 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2145 * lead to double frees or releasing memory still in use.
2147 static void release_dev(struct file * filp)
2149 struct tty_struct *tty, *o_tty;
2150 int pty_master, tty_closing, o_tty_closing, do_sleep;
2154 unsigned long flags;
2156 tty = (struct tty_struct *)filp->private_data;
2157 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2160 check_tty_count(tty, "release_dev");
2162 tty_fasync(-1, filp, 0);
2165 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2166 tty->driver->subtype == PTY_TYPE_MASTER);
2167 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2170 #ifdef TTY_PARANOIA_CHECK
2171 if (idx < 0 || idx >= tty->driver->num) {
2172 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2173 "free (%s)\n", tty->name);
2176 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2177 if (tty != tty->driver->ttys[idx]) {
2178 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2179 "for (%s)\n", idx, tty->name);
2182 if (tty->termios != tty->driver->termios[idx]) {
2183 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2188 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2189 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2190 "termios_locked for (%s)\n",
2197 #ifdef TTY_DEBUG_HANGUP
2198 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2199 tty_name(tty, buf), tty->count);
2202 #ifdef TTY_PARANOIA_CHECK
2203 if (tty->driver->other &&
2204 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2205 if (o_tty != tty->driver->other->ttys[idx]) {
2206 printk(KERN_DEBUG "release_dev: other->table[%d] "
2207 "not o_tty for (%s)\n",
2211 if (o_tty->termios != tty->driver->other->termios[idx]) {
2212 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2213 "not o_termios for (%s)\n",
2217 if (o_tty->termios_locked !=
2218 tty->driver->other->termios_locked[idx]) {
2219 printk(KERN_DEBUG "release_dev: other->termios_locked["
2220 "%d] not o_termios_locked for (%s)\n",
2224 if (o_tty->link != tty) {
2225 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2230 if (tty->driver->close)
2231 tty->driver->close(tty, filp);
2234 * Sanity check: if tty->count is going to zero, there shouldn't be
2235 * any waiters on tty->read_wait or tty->write_wait. We test the
2236 * wait queues and kick everyone out _before_ actually starting to
2237 * close. This ensures that we won't block while releasing the tty
2240 * The test for the o_tty closing is necessary, since the master and
2241 * slave sides may close in any order. If the slave side closes out
2242 * first, its count will be one, since the master side holds an open.
2243 * Thus this test wouldn't be triggered at the time the slave closes,
2246 * Note that it's possible for the tty to be opened again while we're
2247 * flushing out waiters. By recalculating the closing flags before
2248 * each iteration we avoid any problems.
2251 /* Guard against races with tty->count changes elsewhere and
2252 opens on /dev/tty */
2254 mutex_lock(&tty_mutex);
2255 tty_closing = tty->count <= 1;
2256 o_tty_closing = o_tty &&
2257 (o_tty->count <= (pty_master ? 1 : 0));
2261 if (waitqueue_active(&tty->read_wait)) {
2262 wake_up(&tty->read_wait);
2265 if (waitqueue_active(&tty->write_wait)) {
2266 wake_up(&tty->write_wait);
2270 if (o_tty_closing) {
2271 if (waitqueue_active(&o_tty->read_wait)) {
2272 wake_up(&o_tty->read_wait);
2275 if (waitqueue_active(&o_tty->write_wait)) {
2276 wake_up(&o_tty->write_wait);
2283 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2284 "active!\n", tty_name(tty, buf));
2285 mutex_unlock(&tty_mutex);
2290 * The closing flags are now consistent with the open counts on
2291 * both sides, and we've completed the last operation that could
2292 * block, so it's safe to proceed with closing.
2295 if (--o_tty->count < 0) {
2296 printk(KERN_WARNING "release_dev: bad pty slave count "
2298 o_tty->count, tty_name(o_tty, buf));
2302 if (--tty->count < 0) {
2303 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2304 tty->count, tty_name(tty, buf));
2309 * We've decremented tty->count, so we need to remove this file
2310 * descriptor off the tty->tty_files list; this serves two
2312 * - check_tty_count sees the correct number of file descriptors
2313 * associated with this tty.
2314 * - do_tty_hangup no longer sees this file descriptor as
2315 * something that needs to be handled for hangups.
2318 filp->private_data = NULL;
2321 * Perform some housekeeping before deciding whether to return.
2323 * Set the TTY_CLOSING flag if this was the last open. In the
2324 * case of a pty we may have to wait around for the other side
2325 * to close, and TTY_CLOSING makes sure we can't be reopened.
2328 set_bit(TTY_CLOSING, &tty->flags);
2330 set_bit(TTY_CLOSING, &o_tty->flags);
2333 * If _either_ side is closing, make sure there aren't any
2334 * processes that still think tty or o_tty is their controlling
2337 if (tty_closing || o_tty_closing) {
2338 struct task_struct *p;
2340 read_lock(&tasklist_lock);
2341 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2342 p->signal->tty = NULL;
2343 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2345 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
2346 p->signal->tty = NULL;
2347 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
2348 read_unlock(&tasklist_lock);
2351 mutex_unlock(&tty_mutex);
2353 /* check whether both sides are closing ... */
2354 if (!tty_closing || (o_tty && !o_tty_closing))
2357 #ifdef TTY_DEBUG_HANGUP
2358 printk(KERN_DEBUG "freeing tty structure...");
2361 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2362 * kill any delayed work. As this is the final close it does not
2363 * race with the set_ldisc code path.
2365 clear_bit(TTY_LDISC, &tty->flags);
2366 cancel_delayed_work(&tty->buf.work);
2369 * Wait for ->hangup_work and ->buf.work handlers to terminate
2372 flush_scheduled_work();
2375 * Wait for any short term users (we know they are just driver
2376 * side waiters as the file is closing so user count on the file
2379 spin_lock_irqsave(&tty_ldisc_lock, flags);
2380 while(tty->ldisc.refcount)
2382 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2383 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2384 spin_lock_irqsave(&tty_ldisc_lock, flags);
2386 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2388 * Shutdown the current line discipline, and reset it to N_TTY.
2389 * N.B. why reset ldisc when we're releasing the memory??
2391 * FIXME: this MUST get fixed for the new reflocking
2393 if (tty->ldisc.close)
2394 (tty->ldisc.close)(tty);
2395 tty_ldisc_put(tty->ldisc.num);
2398 * Switch the line discipline back
2400 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2401 tty_set_termios_ldisc(tty,N_TTY);
2403 /* FIXME: could o_tty be in setldisc here ? */
2404 clear_bit(TTY_LDISC, &o_tty->flags);
2405 if (o_tty->ldisc.close)
2406 (o_tty->ldisc.close)(o_tty);
2407 tty_ldisc_put(o_tty->ldisc.num);
2408 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2409 tty_set_termios_ldisc(o_tty,N_TTY);
2412 * The release_mem function takes care of the details of clearing
2413 * the slots and preserving the termios structure.
2415 release_mem(tty, idx);
2417 #ifdef CONFIG_UNIX98_PTYS
2418 /* Make this pty number available for reallocation */
2420 down(&allocated_ptys_lock);
2421 idr_remove(&allocated_ptys, idx);
2422 up(&allocated_ptys_lock);
2429 * tty_open - open a tty device
2430 * @inode: inode of device file
2431 * @filp: file pointer to tty
2433 * tty_open and tty_release keep up the tty count that contains the
2434 * number of opens done on a tty. We cannot use the inode-count, as
2435 * different inodes might point to the same tty.
2437 * Open-counting is needed for pty masters, as well as for keeping
2438 * track of serial lines: DTR is dropped when the last close happens.
2439 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2441 * The termios state of a pty is reset on first open so that
2442 * settings don't persist across reuse.
2444 * Locking: tty_mutex protects current->signal->tty, get_tty_driver and
2445 * init_dev work. tty->count should protect the rest.
2446 * task_lock is held to update task details for sessions
2449 static int tty_open(struct inode * inode, struct file * filp)
2451 struct tty_struct *tty;
2453 struct tty_driver *driver;
2455 dev_t device = inode->i_rdev;
2456 unsigned short saved_flags = filp->f_flags;
2458 nonseekable_open(inode, filp);
2461 noctty = filp->f_flags & O_NOCTTY;
2465 mutex_lock(&tty_mutex);
2467 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2468 if (!current->signal->tty) {
2469 mutex_unlock(&tty_mutex);
2472 driver = current->signal->tty->driver;
2473 index = current->signal->tty->index;
2474 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2479 if (device == MKDEV(TTY_MAJOR,0)) {
2480 extern struct tty_driver *console_driver;
2481 driver = console_driver;
2487 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2488 driver = console_device(&index);
2490 /* Don't let /dev/console block */
2491 filp->f_flags |= O_NONBLOCK;
2495 mutex_unlock(&tty_mutex);
2499 driver = get_tty_driver(device, &index);
2501 mutex_unlock(&tty_mutex);
2505 retval = init_dev(driver, index, &tty);
2506 mutex_unlock(&tty_mutex);
2510 filp->private_data = tty;
2511 file_move(filp, &tty->tty_files);
2512 check_tty_count(tty, "tty_open");
2513 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2514 tty->driver->subtype == PTY_TYPE_MASTER)
2516 #ifdef TTY_DEBUG_HANGUP
2517 printk(KERN_DEBUG "opening %s...", tty->name);
2520 if (tty->driver->open)
2521 retval = tty->driver->open(tty, filp);
2525 filp->f_flags = saved_flags;
2527 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2531 #ifdef TTY_DEBUG_HANGUP
2532 printk(KERN_DEBUG "error %d in opening %s...", retval,
2536 if (retval != -ERESTARTSYS)
2538 if (signal_pending(current))
2542 * Need to reset f_op in case a hangup happened.
2544 if (filp->f_op == &hung_up_tty_fops)
2545 filp->f_op = &tty_fops;
2549 current->signal->leader &&
2550 !current->signal->tty &&
2551 tty->session == 0) {
2553 current->signal->tty = tty;
2554 task_unlock(current);
2555 current->signal->tty_old_pgrp = 0;
2556 tty->session = current->signal->session;
2557 tty->pgrp = process_group(current);
2562 #ifdef CONFIG_UNIX98_PTYS
2564 * ptmx_open - open a unix 98 pty master
2565 * @inode: inode of device file
2566 * @filp: file pointer to tty
2568 * Allocate a unix98 pty master device from the ptmx driver.
2570 * Locking: tty_mutex protects theinit_dev work. tty->count should
2572 * allocated_ptys_lock handles the list of free pty numbers
2575 static int ptmx_open(struct inode * inode, struct file * filp)
2577 struct tty_struct *tty;
2582 nonseekable_open(inode, filp);
2584 /* find a device that is not in use. */
2585 down(&allocated_ptys_lock);
2586 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2587 up(&allocated_ptys_lock);
2590 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2592 up(&allocated_ptys_lock);
2593 if (idr_ret == -EAGAIN)
2597 if (index >= pty_limit) {
2598 idr_remove(&allocated_ptys, index);
2599 up(&allocated_ptys_lock);
2602 up(&allocated_ptys_lock);
2604 mutex_lock(&tty_mutex);
2605 retval = init_dev(ptm_driver, index, &tty);
2606 mutex_unlock(&tty_mutex);
2611 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2612 filp->private_data = tty;
2613 file_move(filp, &tty->tty_files);
2616 if (devpts_pty_new(tty->link))
2619 check_tty_count(tty, "tty_open");
2620 retval = ptm_driver->open(tty, filp);
2627 down(&allocated_ptys_lock);
2628 idr_remove(&allocated_ptys, index);
2629 up(&allocated_ptys_lock);
2635 * tty_release - vfs callback for close
2636 * @inode: inode of tty
2637 * @filp: file pointer for handle to tty
2639 * Called the last time each file handle is closed that references
2640 * this tty. There may however be several such references.
2643 * Takes bkl. See release_dev
2646 static int tty_release(struct inode * inode, struct file * filp)
2655 * tty_poll - check tty status
2656 * @filp: file being polled
2657 * @wait: poll wait structures to update
2659 * Call the line discipline polling method to obtain the poll
2660 * status of the device.
2662 * Locking: locks called line discipline but ldisc poll method
2663 * may be re-entered freely by other callers.
2666 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2668 struct tty_struct * tty;
2669 struct tty_ldisc *ld;
2672 tty = (struct tty_struct *)filp->private_data;
2673 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2676 ld = tty_ldisc_ref_wait(tty);
2678 ret = (ld->poll)(tty, filp, wait);
2679 tty_ldisc_deref(ld);
2683 static int tty_fasync(int fd, struct file * filp, int on)
2685 struct tty_struct * tty;
2688 tty = (struct tty_struct *)filp->private_data;
2689 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2692 retval = fasync_helper(fd, filp, on, &tty->fasync);
2697 if (!waitqueue_active(&tty->read_wait))
2698 tty->minimum_to_wake = 1;
2699 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2703 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2704 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2710 * tiocsti - fake input character
2711 * @tty: tty to fake input into
2712 * @p: pointer to character
2714 * Fake input to a tty device. Does the neccessary locking and
2717 * FIXME: does not honour flow control ??
2720 * Called functions take tty_ldisc_lock
2721 * current->signal->tty check is safe without locks
2723 * FIXME: may race normal receive processing
2726 static int tiocsti(struct tty_struct *tty, char __user *p)
2729 struct tty_ldisc *ld;
2731 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2733 if (get_user(ch, p))
2735 ld = tty_ldisc_ref_wait(tty);
2736 ld->receive_buf(tty, &ch, &mbz, 1);
2737 tty_ldisc_deref(ld);
2742 * tiocgwinsz - implement window query ioctl
2744 * @arg: user buffer for result
2746 * Copies the kernel idea of the window size into the user buffer.
2748 * Locking: tty->termios_sem is taken to ensure the winsize data
2752 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2756 mutex_lock(&tty->termios_mutex);
2757 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2758 mutex_unlock(&tty->termios_mutex);
2760 return err ? -EFAULT: 0;
2764 * tiocswinsz - implement window size set ioctl
2766 * @arg: user buffer for result
2768 * Copies the user idea of the window size to the kernel. Traditionally
2769 * this is just advisory information but for the Linux console it
2770 * actually has driver level meaning and triggers a VC resize.
2773 * Called function use the console_sem is used to ensure we do
2774 * not try and resize the console twice at once.
2775 * The tty->termios_sem is used to ensure we don't double
2776 * resize and get confused. Lock order - tty->termios.sem before
2780 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2781 struct winsize __user * arg)
2783 struct winsize tmp_ws;
2785 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2788 mutex_lock(&tty->termios_mutex);
2789 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2793 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2794 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2796 mutex_unlock(&tty->termios_mutex);
2802 kill_pg(tty->pgrp, SIGWINCH, 1);
2803 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2804 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2805 tty->winsize = tmp_ws;
2806 real_tty->winsize = tmp_ws;
2808 mutex_unlock(&tty->termios_mutex);
2813 * tioccons - allow admin to move logical console
2814 * @file: the file to become console
2816 * Allow the adminstrator to move the redirected console device
2818 * Locking: uses redirect_lock to guard the redirect information
2821 static int tioccons(struct file *file)
2823 if (!capable(CAP_SYS_ADMIN))
2825 if (file->f_op->write == redirected_tty_write) {
2827 spin_lock(&redirect_lock);
2830 spin_unlock(&redirect_lock);
2835 spin_lock(&redirect_lock);
2837 spin_unlock(&redirect_lock);
2842 spin_unlock(&redirect_lock);
2847 * fionbio - non blocking ioctl
2848 * @file: file to set blocking value
2849 * @p: user parameter
2851 * Historical tty interfaces had a blocking control ioctl before
2852 * the generic functionality existed. This piece of history is preserved
2853 * in the expected tty API of posix OS's.
2855 * Locking: none, the open fle handle ensures it won't go away.
2858 static int fionbio(struct file *file, int __user *p)
2862 if (get_user(nonblock, p))
2866 file->f_flags |= O_NONBLOCK;
2868 file->f_flags &= ~O_NONBLOCK;
2873 * tiocsctty - set controlling tty
2874 * @tty: tty structure
2875 * @arg: user argument
2877 * This ioctl is used to manage job control. It permits a session
2878 * leader to set this tty as the controlling tty for the session.
2881 * Takes tasklist lock internally to walk sessions
2882 * Takes task_lock() when updating signal->tty
2883 * Takes tty_mutex() to protect tty instance
2887 static int tiocsctty(struct tty_struct *tty, int arg)
2889 struct task_struct *p;
2891 if (current->signal->leader &&
2892 (current->signal->session == tty->session))
2895 * The process must be a session leader and
2896 * not have a controlling tty already.
2898 if (!current->signal->leader || current->signal->tty)
2900 if (tty->session > 0) {
2902 * This tty is already the controlling
2903 * tty for another session group!
2905 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2910 read_lock(&tasklist_lock);
2911 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2912 p->signal->tty = NULL;
2913 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2914 read_unlock(&tasklist_lock);
2918 mutex_lock(&tty_mutex);
2920 current->signal->tty = tty;
2921 task_unlock(current);
2922 mutex_unlock(&tty_mutex);
2923 current->signal->tty_old_pgrp = 0;
2924 tty->session = current->signal->session;
2925 tty->pgrp = process_group(current);
2930 * tiocgpgrp - get process group
2931 * @tty: tty passed by user
2932 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2935 * Obtain the process group of the tty. If there is no process group
2938 * Locking: none. Reference to ->signal->tty is safe.
2941 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2944 * (tty == real_tty) is a cheap way of
2945 * testing if the tty is NOT a master pty.
2947 if (tty == real_tty && current->signal->tty != real_tty)
2949 return put_user(real_tty->pgrp, p);
2953 * tiocspgrp - attempt to set process group
2954 * @tty: tty passed by user
2955 * @real_tty: tty side device matching tty passed by user
2958 * Set the process group of the tty to the session passed. Only
2959 * permitted where the tty session is our session.
2964 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2967 int retval = tty_check_change(real_tty);
2973 if (!current->signal->tty ||
2974 (current->signal->tty != real_tty) ||
2975 (real_tty->session != current->signal->session))
2977 if (get_user(pgrp, p))
2981 if (session_of_pgrp(pgrp) != current->signal->session)
2983 real_tty->pgrp = pgrp;
2988 * tiocgsid - get session id
2989 * @tty: tty passed by user
2990 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2991 * @p: pointer to returned session id
2993 * Obtain the session id of the tty. If there is no session
2996 * Locking: none. Reference to ->signal->tty is safe.
2999 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3002 * (tty == real_tty) is a cheap way of
3003 * testing if the tty is NOT a master pty.
3005 if (tty == real_tty && current->signal->tty != real_tty)
3007 if (real_tty->session <= 0)
3009 return put_user(real_tty->session, p);
3013 * tiocsetd - set line discipline
3015 * @p: pointer to user data
3017 * Set the line discipline according to user request.
3019 * Locking: see tty_set_ldisc, this function is just a helper
3022 static int tiocsetd(struct tty_struct *tty, int __user *p)
3026 if (get_user(ldisc, p))
3028 return tty_set_ldisc(tty, ldisc);
3032 * send_break - performed time break
3033 * @tty: device to break on
3034 * @duration: timeout in mS
3036 * Perform a timed break on hardware that lacks its own driver level
3037 * timed break functionality.
3040 * atomic_write_lock serializes
3044 static int send_break(struct tty_struct *tty, unsigned int duration)
3046 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3048 tty->driver->break_ctl(tty, -1);
3049 if (!signal_pending(current)) {
3050 msleep_interruptible(duration);
3052 tty->driver->break_ctl(tty, 0);
3053 mutex_unlock(&tty->atomic_write_lock);
3054 if (signal_pending(current))
3060 * tiocmget - get modem status
3062 * @file: user file pointer
3063 * @p: pointer to result
3065 * Obtain the modem status bits from the tty driver if the feature
3066 * is supported. Return -EINVAL if it is not available.
3068 * Locking: none (up to the driver)
3071 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3073 int retval = -EINVAL;
3075 if (tty->driver->tiocmget) {
3076 retval = tty->driver->tiocmget(tty, file);
3079 retval = put_user(retval, p);
3085 * tiocmset - set modem status
3087 * @file: user file pointer
3088 * @cmd: command - clear bits, set bits or set all
3089 * @p: pointer to desired bits
3091 * Set the modem status bits from the tty driver if the feature
3092 * is supported. Return -EINVAL if it is not available.
3094 * Locking: none (up to the driver)
3097 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3100 int retval = -EINVAL;
3102 if (tty->driver->tiocmset) {
3103 unsigned int set, clear, val;
3105 retval = get_user(val, p);
3123 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3124 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3126 retval = tty->driver->tiocmset(tty, file, set, clear);
3132 * Split this up, as gcc can choke on it otherwise..
3134 int tty_ioctl(struct inode * inode, struct file * file,
3135 unsigned int cmd, unsigned long arg)
3137 struct tty_struct *tty, *real_tty;
3138 void __user *p = (void __user *)arg;
3140 struct tty_ldisc *ld;
3142 tty = (struct tty_struct *)file->private_data;
3143 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3146 /* CHECKME: is this safe as one end closes ? */
3149 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3150 tty->driver->subtype == PTY_TYPE_MASTER)
3151 real_tty = tty->link;
3154 * Break handling by driver
3156 if (!tty->driver->break_ctl) {
3160 if (tty->driver->ioctl)
3161 return tty->driver->ioctl(tty, file, cmd, arg);
3164 /* These two ioctl's always return success; even if */
3165 /* the driver doesn't support them. */
3168 if (!tty->driver->ioctl)
3170 retval = tty->driver->ioctl(tty, file, cmd, arg);
3171 if (retval == -ENOIOCTLCMD)
3178 * Factor out some common prep work
3186 retval = tty_check_change(tty);
3189 if (cmd != TIOCCBRK) {
3190 tty_wait_until_sent(tty, 0);
3191 if (signal_pending(current))
3199 return tiocsti(tty, p);
3201 return tiocgwinsz(tty, p);
3203 return tiocswinsz(tty, real_tty, p);
3205 return real_tty!=tty ? -EINVAL : tioccons(file);
3207 return fionbio(file, p);
3209 set_bit(TTY_EXCLUSIVE, &tty->flags);
3212 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3215 /* FIXME: taks lock or tty_mutex ? */
3216 if (current->signal->tty != tty)
3218 if (current->signal->leader)
3219 disassociate_ctty(0);
3221 current->signal->tty = NULL;
3222 task_unlock(current);
3225 return tiocsctty(tty, arg);
3227 return tiocgpgrp(tty, real_tty, p);
3229 return tiocspgrp(tty, real_tty, p);
3231 return tiocgsid(tty, real_tty, p);
3233 /* FIXME: check this is ok */
3234 return put_user(tty->ldisc.num, (int __user *)p);
3236 return tiocsetd(tty, p);
3239 return tioclinux(tty, arg);
3244 case TIOCSBRK: /* Turn break on, unconditionally */
3245 tty->driver->break_ctl(tty, -1);
3248 case TIOCCBRK: /* Turn break off, unconditionally */
3249 tty->driver->break_ctl(tty, 0);
3251 case TCSBRK: /* SVID version: non-zero arg --> no break */
3252 /* non-zero arg means wait for all output data
3253 * to be sent (performed above) but don't send break.
3254 * This is used by the tcdrain() termios function.
3257 return send_break(tty, 250);
3259 case TCSBRKP: /* support for POSIX tcsendbreak() */
3260 return send_break(tty, arg ? arg*100 : 250);
3263 return tty_tiocmget(tty, file, p);
3268 return tty_tiocmset(tty, file, cmd, p);
3270 if (tty->driver->ioctl) {
3271 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3272 if (retval != -ENOIOCTLCMD)
3275 ld = tty_ldisc_ref_wait(tty);
3278 retval = ld->ioctl(tty, file, cmd, arg);
3279 if (retval == -ENOIOCTLCMD)
3282 tty_ldisc_deref(ld);
3288 * This implements the "Secure Attention Key" --- the idea is to
3289 * prevent trojan horses by killing all processes associated with this
3290 * tty when the user hits the "Secure Attention Key". Required for
3291 * super-paranoid applications --- see the Orange Book for more details.
3293 * This code could be nicer; ideally it should send a HUP, wait a few
3294 * seconds, then send a INT, and then a KILL signal. But you then
3295 * have to coordinate with the init process, since all processes associated
3296 * with the current tty must be dead before the new getty is allowed
3299 * Now, if it would be correct ;-/ The current code has a nasty hole -
3300 * it doesn't catch files in flight. We may send the descriptor to ourselves
3301 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3303 * Nasty bug: do_SAK is being called in interrupt context. This can
3304 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3306 static void __do_SAK(void *arg)
3311 struct tty_struct *tty = arg;
3312 struct task_struct *g, *p;
3316 struct tty_ldisc *disc;
3317 struct fdtable *fdt;
3321 session = tty->session;
3323 /* We don't want an ldisc switch during this */
3324 disc = tty_ldisc_ref(tty);
3325 if (disc && disc->flush_buffer)
3326 disc->flush_buffer(tty);
3327 tty_ldisc_deref(disc);
3329 if (tty->driver->flush_buffer)
3330 tty->driver->flush_buffer(tty);
3332 read_lock(&tasklist_lock);
3333 /* Kill the entire session */
3334 do_each_task_pid(session, PIDTYPE_SID, p) {
3335 printk(KERN_NOTICE "SAK: killed process %d"
3336 " (%s): p->signal->session==tty->session\n",
3338 send_sig(SIGKILL, p, 1);
3339 } while_each_task_pid(session, PIDTYPE_SID, p);
3340 /* Now kill any processes that happen to have the
3343 do_each_thread(g, p) {
3344 if (p->signal->tty == tty) {
3345 printk(KERN_NOTICE "SAK: killed process %d"
3346 " (%s): p->signal->session==tty->session\n",
3348 send_sig(SIGKILL, p, 1);
3354 * We don't take a ref to the file, so we must
3355 * hold ->file_lock instead.
3357 spin_lock(&p->files->file_lock);
3358 fdt = files_fdtable(p->files);
3359 for (i=0; i < fdt->max_fds; i++) {
3360 filp = fcheck_files(p->files, i);
3363 if (filp->f_op->read == tty_read &&
3364 filp->private_data == tty) {
3365 printk(KERN_NOTICE "SAK: killed process %d"
3366 " (%s): fd#%d opened to the tty\n",
3367 p->pid, p->comm, i);
3368 force_sig(SIGKILL, p);
3372 spin_unlock(&p->files->file_lock);
3375 } while_each_thread(g, p);
3376 read_unlock(&tasklist_lock);
3381 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3382 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3383 * the values which we write to it will be identical to the values which it
3384 * already has. --akpm
3386 void do_SAK(struct tty_struct *tty)
3390 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
3391 schedule_work(&tty->SAK_work);
3394 EXPORT_SYMBOL(do_SAK);
3398 * @private_: tty structure passed from work queue.
3400 * This routine is called out of the software interrupt to flush data
3401 * from the buffer chain to the line discipline.
3403 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3404 * while invoking the line discipline receive_buf method. The
3405 * receive_buf method is single threaded for each tty instance.
3408 static void flush_to_ldisc(void *private_)
3410 struct tty_struct *tty = (struct tty_struct *) private_;
3411 unsigned long flags;
3412 struct tty_ldisc *disc;
3413 struct tty_buffer *tbuf, *head;
3415 unsigned char *flag_buf;
3417 disc = tty_ldisc_ref(tty);
3418 if (disc == NULL) /* !TTY_LDISC */
3421 spin_lock_irqsave(&tty->buf.lock, flags);
3422 head = tty->buf.head;
3424 tty->buf.head = NULL;
3426 int count = head->commit - head->read;
3428 if (head->next == NULL)
3432 tty_buffer_free(tty, tbuf);
3435 if (!tty->receive_room) {
3436 schedule_delayed_work(&tty->buf.work, 1);
3439 if (count > tty->receive_room)
3440 count = tty->receive_room;
3441 char_buf = head->char_buf_ptr + head->read;
3442 flag_buf = head->flag_buf_ptr + head->read;
3443 head->read += count;
3444 spin_unlock_irqrestore(&tty->buf.lock, flags);
3445 disc->receive_buf(tty, char_buf, flag_buf, count);
3446 spin_lock_irqsave(&tty->buf.lock, flags);
3448 tty->buf.head = head;
3450 spin_unlock_irqrestore(&tty->buf.lock, flags);
3452 tty_ldisc_deref(disc);
3456 * Routine which returns the baud rate of the tty
3458 * Note that the baud_table needs to be kept in sync with the
3459 * include/asm/termbits.h file.
3461 static int baud_table[] = {
3462 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3463 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3465 76800, 153600, 307200, 614400, 921600
3467 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3468 2500000, 3000000, 3500000, 4000000
3472 static int n_baud_table = ARRAY_SIZE(baud_table);
3475 * tty_termios_baud_rate
3476 * @termios: termios structure
3478 * Convert termios baud rate data into a speed. This should be called
3479 * with the termios lock held if this termios is a terminal termios
3480 * structure. May change the termios data.
3485 int tty_termios_baud_rate(struct termios *termios)
3489 cbaud = termios->c_cflag & CBAUD;
3491 if (cbaud & CBAUDEX) {
3494 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3495 termios->c_cflag &= ~CBAUDEX;
3499 return baud_table[cbaud];
3502 EXPORT_SYMBOL(tty_termios_baud_rate);
3505 * tty_get_baud_rate - get tty bit rates
3506 * @tty: tty to query
3508 * Returns the baud rate as an integer for this terminal. The
3509 * termios lock must be held by the caller and the terminal bit
3510 * flags may be updated.
3515 int tty_get_baud_rate(struct tty_struct *tty)
3517 int baud = tty_termios_baud_rate(tty->termios);
3519 if (baud == 38400 && tty->alt_speed) {
3521 printk(KERN_WARNING "Use of setserial/setrocket to "
3522 "set SPD_* flags is deprecated\n");
3525 baud = tty->alt_speed;
3531 EXPORT_SYMBOL(tty_get_baud_rate);
3534 * tty_flip_buffer_push - terminal
3537 * Queue a push of the terminal flip buffers to the line discipline. This
3538 * function must not be called from IRQ context if tty->low_latency is set.
3540 * In the event of the queue being busy for flipping the work will be
3541 * held off and retried later.
3543 * Locking: tty buffer lock. Driver locks in low latency mode.
3546 void tty_flip_buffer_push(struct tty_struct *tty)
3548 unsigned long flags;
3549 spin_lock_irqsave(&tty->buf.lock, flags);
3550 if (tty->buf.tail != NULL)
3551 tty->buf.tail->commit = tty->buf.tail->used;
3552 spin_unlock_irqrestore(&tty->buf.lock, flags);
3554 if (tty->low_latency)
3555 flush_to_ldisc((void *) tty);
3557 schedule_delayed_work(&tty->buf.work, 1);
3560 EXPORT_SYMBOL(tty_flip_buffer_push);
3564 * initialize_tty_struct
3565 * @tty: tty to initialize
3567 * This subroutine initializes a tty structure that has been newly
3570 * Locking: none - tty in question must not be exposed at this point
3573 static void initialize_tty_struct(struct tty_struct *tty)
3575 memset(tty, 0, sizeof(struct tty_struct));
3576 tty->magic = TTY_MAGIC;
3577 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3579 tty->overrun_time = jiffies;
3580 tty->buf.head = tty->buf.tail = NULL;
3581 tty_buffer_init(tty);
3582 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
3583 init_MUTEX(&tty->buf.pty_sem);
3584 mutex_init(&tty->termios_mutex);
3585 init_waitqueue_head(&tty->write_wait);
3586 init_waitqueue_head(&tty->read_wait);
3587 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
3588 mutex_init(&tty->atomic_read_lock);
3589 mutex_init(&tty->atomic_write_lock);
3590 spin_lock_init(&tty->read_lock);
3591 INIT_LIST_HEAD(&tty->tty_files);
3592 INIT_WORK(&tty->SAK_work, NULL, NULL);
3596 * The default put_char routine if the driver did not define one.
3599 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3601 tty->driver->write(tty, &ch, 1);
3604 static struct class *tty_class;
3607 * tty_register_device - register a tty device
3608 * @driver: the tty driver that describes the tty device
3609 * @index: the index in the tty driver for this tty device
3610 * @device: a struct device that is associated with this tty device.
3611 * This field is optional, if there is no known struct device
3612 * for this tty device it can be set to NULL safely.
3614 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
3616 * This call is required to be made to register an individual tty device
3617 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3618 * that bit is not set, this function should not be called by a tty
3624 struct class_device *tty_register_device(struct tty_driver *driver,
3625 unsigned index, struct device *device)
3628 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3630 if (index >= driver->num) {
3631 printk(KERN_ERR "Attempt to register invalid tty line number "
3633 return ERR_PTR(-EINVAL);
3636 if (driver->type == TTY_DRIVER_TYPE_PTY)
3637 pty_line_name(driver, index, name);
3639 tty_line_name(driver, index, name);
3641 return class_device_create(tty_class, NULL, dev, device, "%s", name);
3645 * tty_unregister_device - unregister a tty device
3646 * @driver: the tty driver that describes the tty device
3647 * @index: the index in the tty driver for this tty device
3649 * If a tty device is registered with a call to tty_register_device() then
3650 * this function must be called when the tty device is gone.
3655 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3657 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3660 EXPORT_SYMBOL(tty_register_device);
3661 EXPORT_SYMBOL(tty_unregister_device);
3663 struct tty_driver *alloc_tty_driver(int lines)
3665 struct tty_driver *driver;
3667 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3669 memset(driver, 0, sizeof(struct tty_driver));
3670 driver->magic = TTY_DRIVER_MAGIC;
3671 driver->num = lines;
3672 /* later we'll move allocation of tables here */
3677 void put_tty_driver(struct tty_driver *driver)
3682 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3684 driver->open = op->open;
3685 driver->close = op->close;
3686 driver->write = op->write;
3687 driver->put_char = op->put_char;
3688 driver->flush_chars = op->flush_chars;
3689 driver->write_room = op->write_room;
3690 driver->chars_in_buffer = op->chars_in_buffer;
3691 driver->ioctl = op->ioctl;
3692 driver->set_termios = op->set_termios;
3693 driver->throttle = op->throttle;
3694 driver->unthrottle = op->unthrottle;
3695 driver->stop = op->stop;
3696 driver->start = op->start;
3697 driver->hangup = op->hangup;
3698 driver->break_ctl = op->break_ctl;
3699 driver->flush_buffer = op->flush_buffer;
3700 driver->set_ldisc = op->set_ldisc;
3701 driver->wait_until_sent = op->wait_until_sent;
3702 driver->send_xchar = op->send_xchar;
3703 driver->read_proc = op->read_proc;
3704 driver->write_proc = op->write_proc;
3705 driver->tiocmget = op->tiocmget;
3706 driver->tiocmset = op->tiocmset;
3710 EXPORT_SYMBOL(alloc_tty_driver);
3711 EXPORT_SYMBOL(put_tty_driver);
3712 EXPORT_SYMBOL(tty_set_operations);
3715 * Called by a tty driver to register itself.
3717 int tty_register_driver(struct tty_driver *driver)
3724 if (driver->flags & TTY_DRIVER_INSTALLED)
3727 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3728 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3731 memset(p, 0, driver->num * 3 * sizeof(void *));
3734 if (!driver->major) {
3735 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3736 (char*)driver->name);
3738 driver->major = MAJOR(dev);
3739 driver->minor_start = MINOR(dev);
3742 dev = MKDEV(driver->major, driver->minor_start);
3743 error = register_chrdev_region(dev, driver->num,
3744 (char*)driver->name);
3752 driver->ttys = (struct tty_struct **)p;
3753 driver->termios = (struct termios **)(p + driver->num);
3754 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3756 driver->ttys = NULL;
3757 driver->termios = NULL;
3758 driver->termios_locked = NULL;
3761 cdev_init(&driver->cdev, &tty_fops);
3762 driver->cdev.owner = driver->owner;
3763 error = cdev_add(&driver->cdev, dev, driver->num);
3765 unregister_chrdev_region(dev, driver->num);
3766 driver->ttys = NULL;
3767 driver->termios = driver->termios_locked = NULL;
3772 if (!driver->put_char)
3773 driver->put_char = tty_default_put_char;
3775 list_add(&driver->tty_drivers, &tty_drivers);
3777 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3778 for(i = 0; i < driver->num; i++)
3779 tty_register_device(driver, i, NULL);
3781 proc_tty_register_driver(driver);
3785 EXPORT_SYMBOL(tty_register_driver);
3788 * Called by a tty driver to unregister itself.
3790 int tty_unregister_driver(struct tty_driver *driver)
3796 if (driver->refcount)
3799 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3802 list_del(&driver->tty_drivers);
3805 * Free the termios and termios_locked structures because
3806 * we don't want to get memory leaks when modular tty
3807 * drivers are removed from the kernel.
3809 for (i = 0; i < driver->num; i++) {
3810 tp = driver->termios[i];
3812 driver->termios[i] = NULL;
3815 tp = driver->termios_locked[i];
3817 driver->termios_locked[i] = NULL;
3820 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3821 tty_unregister_device(driver, i);
3824 proc_tty_unregister_driver(driver);
3825 driver->ttys = NULL;
3826 driver->termios = driver->termios_locked = NULL;
3828 cdev_del(&driver->cdev);
3832 EXPORT_SYMBOL(tty_unregister_driver);
3836 * Initialize the console device. This is called *early*, so
3837 * we can't necessarily depend on lots of kernel help here.
3838 * Just do some early initializations, and do the complex setup
3841 void __init console_init(void)
3845 /* Setup the default TTY line discipline. */
3846 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3849 * set up the console device so that later boot sequences can
3850 * inform about problems etc..
3852 #ifdef CONFIG_EARLY_PRINTK
3853 disable_early_printk();
3855 call = __con_initcall_start;
3856 while (call < __con_initcall_end) {
3863 extern int vty_init(void);
3866 static int __init tty_class_init(void)
3868 tty_class = class_create(THIS_MODULE, "tty");
3869 if (IS_ERR(tty_class))
3870 return PTR_ERR(tty_class);
3874 postcore_initcall(tty_class_init);
3876 /* 3/2004 jmc: why do these devices exist? */
3878 static struct cdev tty_cdev, console_cdev;
3879 #ifdef CONFIG_UNIX98_PTYS
3880 static struct cdev ptmx_cdev;
3883 static struct cdev vc0_cdev;
3887 * Ok, now we can initialize the rest of the tty devices and can count
3888 * on memory allocations, interrupts etc..
3890 static int __init tty_init(void)
3892 cdev_init(&tty_cdev, &tty_fops);
3893 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3894 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3895 panic("Couldn't register /dev/tty driver\n");
3896 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3898 cdev_init(&console_cdev, &console_fops);
3899 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3900 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3901 panic("Couldn't register /dev/console driver\n");
3902 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
3904 #ifdef CONFIG_UNIX98_PTYS
3905 cdev_init(&ptmx_cdev, &ptmx_fops);
3906 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3907 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3908 panic("Couldn't register /dev/ptmx driver\n");
3909 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3913 cdev_init(&vc0_cdev, &console_fops);
3914 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3915 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3916 panic("Couldn't register /dev/tty0 driver\n");
3917 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3923 module_init(tty_init);