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 /* Mutex 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
263 * tty_buffer_free_all - free buffers used by a tty
264 * @tty: tty to free from
266 * Remove all the buffers pending on a tty whether queued with data
267 * or in the free ring. Must be called when the tty is no longer in use
272 static void tty_buffer_free_all(struct tty_struct *tty)
274 struct tty_buffer *thead;
275 while((thead = tty->buf.head) != NULL) {
276 tty->buf.head = thead->next;
279 while((thead = tty->buf.free) != NULL) {
280 tty->buf.free = thead->next;
283 tty->buf.tail = NULL;
284 tty->buf.memory_used = 0;
288 * tty_buffer_init - prepare a tty buffer structure
289 * @tty: tty to initialise
291 * Set up the initial state of the buffer management for a tty device.
292 * Must be called before the other tty buffer functions are used.
297 static void tty_buffer_init(struct tty_struct *tty)
299 spin_lock_init(&tty->buf.lock);
300 tty->buf.head = NULL;
301 tty->buf.tail = NULL;
302 tty->buf.free = NULL;
303 tty->buf.memory_used = 0;
307 * tty_buffer_alloc - allocate a tty buffer
309 * @size: desired size (characters)
311 * Allocate a new tty buffer to hold the desired number of characters.
312 * Return NULL if out of memory or the allocation would exceed the
315 * Locking: Caller must hold tty->buf.lock
318 static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
320 struct tty_buffer *p;
322 if (tty->buf.memory_used + size > 65536)
324 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
332 p->char_buf_ptr = (char *)(p->data);
333 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
334 tty->buf.memory_used += size;
339 * tty_buffer_free - free a tty buffer
340 * @tty: tty owning the buffer
341 * @b: the buffer to free
343 * Free a tty buffer, or add it to the free list according to our
346 * Locking: Caller must hold tty->buf.lock
349 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
351 /* Dumb strategy for now - should keep some stats */
352 tty->buf.memory_used -= b->size;
353 WARN_ON(tty->buf.memory_used < 0);
358 b->next = tty->buf.free;
364 * tty_buffer_find - find a free tty buffer
365 * @tty: tty owning the buffer
366 * @size: characters wanted
368 * Locate an existing suitable tty buffer or if we are lacking one then
369 * allocate a new one. We round our buffers off in 256 character chunks
370 * to get better allocation behaviour.
372 * Locking: Caller must hold tty->buf.lock
375 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
377 struct tty_buffer **tbh = &tty->buf.free;
378 while((*tbh) != NULL) {
379 struct tty_buffer *t = *tbh;
380 if(t->size >= size) {
386 tty->buf.memory_used += t->size;
389 tbh = &((*tbh)->next);
391 /* Round the buffer size out */
392 size = (size + 0xFF) & ~ 0xFF;
393 return tty_buffer_alloc(tty, size);
394 /* Should possibly check if this fails for the largest buffer we
395 have queued and recycle that ? */
399 * tty_buffer_request_room - grow tty buffer if needed
400 * @tty: tty structure
401 * @size: size desired
403 * Make at least size bytes of linear space available for the tty
404 * buffer. If we fail return the size we managed to find.
406 * Locking: Takes tty->buf.lock
408 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
410 struct tty_buffer *b, *n;
414 spin_lock_irqsave(&tty->buf.lock, flags);
416 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
417 remove this conditional if its worth it. This would be invisible
419 if ((b = tty->buf.tail) != NULL)
420 left = b->size - b->used;
425 /* This is the slow path - looking for new buffers to use */
426 if ((n = tty_buffer_find(tty, size)) != NULL) {
437 spin_unlock_irqrestore(&tty->buf.lock, flags);
440 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
443 * tty_insert_flip_string - Add characters to the tty buffer
444 * @tty: tty structure
448 * Queue a series of bytes to the tty buffering. All the characters
449 * passed are marked as without error. Returns the number added.
451 * Locking: Called functions may take tty->buf.lock
454 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
459 int space = tty_buffer_request_room(tty, size - copied);
460 struct tty_buffer *tb = tty->buf.tail;
461 /* If there is no space then tb may be NULL */
462 if(unlikely(space == 0))
464 memcpy(tb->char_buf_ptr + tb->used, chars, space);
465 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
469 /* There is a small chance that we need to split the data over
470 several buffers. If this is the case we must loop */
471 } while (unlikely(size > copied));
474 EXPORT_SYMBOL(tty_insert_flip_string);
477 * tty_insert_flip_string_flags - Add characters to the tty buffer
478 * @tty: tty structure
483 * Queue a series of bytes to the tty buffering. For each character
484 * the flags array indicates the status of the character. Returns the
487 * Locking: Called functions may take tty->buf.lock
490 int tty_insert_flip_string_flags(struct tty_struct *tty,
491 const unsigned char *chars, const char *flags, size_t size)
495 int space = tty_buffer_request_room(tty, size - copied);
496 struct tty_buffer *tb = tty->buf.tail;
497 /* If there is no space then tb may be NULL */
498 if(unlikely(space == 0))
500 memcpy(tb->char_buf_ptr + tb->used, chars, space);
501 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
506 /* There is a small chance that we need to split the data over
507 several buffers. If this is the case we must loop */
508 } while (unlikely(size > copied));
511 EXPORT_SYMBOL(tty_insert_flip_string_flags);
514 * tty_schedule_flip - push characters to ldisc
515 * @tty: tty to push from
517 * Takes any pending buffers and transfers their ownership to the
518 * ldisc side of the queue. It then schedules those characters for
519 * processing by the line discipline.
521 * Locking: Takes tty->buf.lock
524 void tty_schedule_flip(struct tty_struct *tty)
527 spin_lock_irqsave(&tty->buf.lock, flags);
528 if (tty->buf.tail != NULL)
529 tty->buf.tail->commit = tty->buf.tail->used;
530 spin_unlock_irqrestore(&tty->buf.lock, flags);
531 schedule_delayed_work(&tty->buf.work, 1);
533 EXPORT_SYMBOL(tty_schedule_flip);
536 * tty_prepare_flip_string - make room for characters
538 * @chars: return pointer for character write area
539 * @size: desired size
541 * Prepare a block of space in the buffer for data. Returns the length
542 * available and buffer pointer to the space which is now allocated and
543 * accounted for as ready for normal characters. This is used for drivers
544 * that need their own block copy routines into the buffer. There is no
545 * guarantee the buffer is a DMA target!
547 * Locking: May call functions taking tty->buf.lock
550 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
552 int space = tty_buffer_request_room(tty, size);
554 struct tty_buffer *tb = tty->buf.tail;
555 *chars = tb->char_buf_ptr + tb->used;
556 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
562 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
565 * tty_prepare_flip_string_flags - make room for characters
567 * @chars: return pointer for character write area
568 * @flags: return pointer for status flag write area
569 * @size: desired size
571 * Prepare a block of space in the buffer for data. Returns the length
572 * available and buffer pointer to the space which is now allocated and
573 * accounted for as ready for characters. This is used for drivers
574 * that need their own block copy routines into the buffer. There is no
575 * guarantee the buffer is a DMA target!
577 * Locking: May call functions taking tty->buf.lock
580 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
582 int space = tty_buffer_request_room(tty, size);
584 struct tty_buffer *tb = tty->buf.tail;
585 *chars = tb->char_buf_ptr + tb->used;
586 *flags = tb->flag_buf_ptr + tb->used;
592 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
597 * tty_set_termios_ldisc - set ldisc field
598 * @tty: tty structure
599 * @num: line discipline number
601 * This is probably overkill for real world processors but
602 * they are not on hot paths so a little discipline won't do
605 * Locking: takes termios_mutex
608 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
610 mutex_lock(&tty->termios_mutex);
611 tty->termios->c_line = num;
612 mutex_unlock(&tty->termios_mutex);
616 * This guards the refcounted line discipline lists. The lock
617 * must be taken with irqs off because there are hangup path
618 * callers who will do ldisc lookups and cannot sleep.
621 static DEFINE_SPINLOCK(tty_ldisc_lock);
622 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
623 static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
626 * tty_register_ldisc - install a line discipline
627 * @disc: ldisc number
628 * @new_ldisc: pointer to the ldisc object
630 * Installs a new line discipline into the kernel. The discipline
631 * is set up as unreferenced and then made available to the kernel
632 * from this point onwards.
635 * takes tty_ldisc_lock to guard against ldisc races
638 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
643 if (disc < N_TTY || disc >= NR_LDISCS)
646 spin_lock_irqsave(&tty_ldisc_lock, flags);
647 tty_ldiscs[disc] = *new_ldisc;
648 tty_ldiscs[disc].num = disc;
649 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
650 tty_ldiscs[disc].refcount = 0;
651 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
655 EXPORT_SYMBOL(tty_register_ldisc);
658 * tty_unregister_ldisc - unload a line discipline
659 * @disc: ldisc number
660 * @new_ldisc: pointer to the ldisc object
662 * Remove a line discipline from the kernel providing it is not
666 * takes tty_ldisc_lock to guard against ldisc races
669 int tty_unregister_ldisc(int disc)
674 if (disc < N_TTY || disc >= NR_LDISCS)
677 spin_lock_irqsave(&tty_ldisc_lock, flags);
678 if (tty_ldiscs[disc].refcount)
681 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
682 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
686 EXPORT_SYMBOL(tty_unregister_ldisc);
689 * tty_ldisc_get - take a reference to an ldisc
690 * @disc: ldisc number
692 * Takes a reference to a line discipline. Deals with refcounts and
693 * module locking counts. Returns NULL if the discipline is not available.
694 * Returns a pointer to the discipline and bumps the ref count if it is
698 * takes tty_ldisc_lock to guard against ldisc races
701 struct tty_ldisc *tty_ldisc_get(int disc)
704 struct tty_ldisc *ld;
706 if (disc < N_TTY || disc >= NR_LDISCS)
709 spin_lock_irqsave(&tty_ldisc_lock, flags);
711 ld = &tty_ldiscs[disc];
712 /* Check the entry is defined */
713 if(ld->flags & LDISC_FLAG_DEFINED)
715 /* If the module is being unloaded we can't use it */
716 if (!try_module_get(ld->owner))
723 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
727 EXPORT_SYMBOL_GPL(tty_ldisc_get);
730 * tty_ldisc_put - drop ldisc reference
731 * @disc: ldisc number
733 * Drop a reference to a line discipline. Manage refcounts and
734 * module usage counts
737 * takes tty_ldisc_lock to guard against ldisc races
740 void tty_ldisc_put(int disc)
742 struct tty_ldisc *ld;
745 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
747 spin_lock_irqsave(&tty_ldisc_lock, flags);
748 ld = &tty_ldiscs[disc];
749 BUG_ON(ld->refcount == 0);
751 module_put(ld->owner);
752 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
755 EXPORT_SYMBOL_GPL(tty_ldisc_put);
758 * tty_ldisc_assign - set ldisc on a tty
759 * @tty: tty to assign
760 * @ld: line discipline
762 * Install an instance of a line discipline into a tty structure. The
763 * ldisc must have a reference count above zero to ensure it remains/
764 * The tty instance refcount starts at zero.
767 * Caller must hold references
770 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
773 tty->ldisc.refcount = 0;
777 * tty_ldisc_try - internal helper
780 * Make a single attempt to grab and bump the refcount on
781 * the tty ldisc. Return 0 on failure or 1 on success. This is
782 * used to implement both the waiting and non waiting versions
785 * Locking: takes tty_ldisc_lock
788 static int tty_ldisc_try(struct tty_struct *tty)
791 struct tty_ldisc *ld;
794 spin_lock_irqsave(&tty_ldisc_lock, flags);
796 if(test_bit(TTY_LDISC, &tty->flags))
801 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
806 * tty_ldisc_ref_wait - wait for the tty ldisc
809 * Dereference the line discipline for the terminal and take a
810 * reference to it. If the line discipline is in flux then
811 * wait patiently until it changes.
813 * Note: Must not be called from an IRQ/timer context. The caller
814 * must also be careful not to hold other locks that will deadlock
815 * against a discipline change, such as an existing ldisc reference
816 * (which we check for)
818 * Locking: call functions take tty_ldisc_lock
821 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
823 /* wait_event is a macro */
824 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
825 if(tty->ldisc.refcount == 0)
826 printk(KERN_ERR "tty_ldisc_ref_wait\n");
830 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
833 * tty_ldisc_ref - get the tty ldisc
836 * Dereference the line discipline for the terminal and take a
837 * reference to it. If the line discipline is in flux then
838 * return NULL. Can be called from IRQ and timer functions.
840 * Locking: called functions take tty_ldisc_lock
843 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
845 if(tty_ldisc_try(tty))
850 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
853 * tty_ldisc_deref - free a tty ldisc reference
854 * @ld: reference to free up
856 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
857 * be called in IRQ context.
859 * Locking: takes tty_ldisc_lock
862 void tty_ldisc_deref(struct tty_ldisc *ld)
868 spin_lock_irqsave(&tty_ldisc_lock, flags);
869 if(ld->refcount == 0)
870 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
873 if(ld->refcount == 0)
874 wake_up(&tty_ldisc_wait);
875 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
878 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
881 * tty_ldisc_enable - allow ldisc use
882 * @tty: terminal to activate ldisc on
884 * Set the TTY_LDISC flag when the line discipline can be called
885 * again. Do neccessary wakeups for existing sleepers.
887 * Note: nobody should set this bit except via this function. Clearing
888 * directly is allowed.
891 static void tty_ldisc_enable(struct tty_struct *tty)
893 set_bit(TTY_LDISC, &tty->flags);
894 wake_up(&tty_ldisc_wait);
898 * tty_set_ldisc - set line discipline
899 * @tty: the terminal to set
900 * @ldisc: the line discipline
902 * Set the discipline of a tty line. Must be called from a process
905 * Locking: takes tty_ldisc_lock.
906 * called functions take termios_mutex
909 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
912 struct tty_ldisc o_ldisc;
916 struct tty_ldisc *ld;
917 struct tty_struct *o_tty;
919 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
924 ld = tty_ldisc_get(ldisc);
925 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
926 /* Cyrus Durgin <cider@speakeasy.org> */
928 request_module("tty-ldisc-%d", ldisc);
929 ld = tty_ldisc_get(ldisc);
935 * No more input please, we are switching. The new ldisc
936 * will update this value in the ldisc open function
939 tty->receive_room = 0;
942 * Problem: What do we do if this blocks ?
945 tty_wait_until_sent(tty, 0);
947 if (tty->ldisc.num == ldisc) {
948 tty_ldisc_put(ldisc);
952 o_ldisc = tty->ldisc;
956 * Make sure we don't change while someone holds a
957 * reference to the line discipline. The TTY_LDISC bit
958 * prevents anyone taking a reference once it is clear.
959 * We need the lock to avoid racing reference takers.
962 spin_lock_irqsave(&tty_ldisc_lock, flags);
963 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
964 if(tty->ldisc.refcount) {
965 /* Free the new ldisc we grabbed. Must drop the lock
967 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
968 tty_ldisc_put(ldisc);
970 * There are several reasons we may be busy, including
971 * random momentary I/O traffic. We must therefore
972 * retry. We could distinguish between blocking ops
973 * and retries if we made tty_ldisc_wait() smarter. That
974 * is up for discussion.
976 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
980 if(o_tty && o_tty->ldisc.refcount) {
981 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
982 tty_ldisc_put(ldisc);
983 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
989 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
991 if (!test_bit(TTY_LDISC, &tty->flags)) {
992 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
993 tty_ldisc_put(ldisc);
994 ld = tty_ldisc_ref_wait(tty);
999 clear_bit(TTY_LDISC, &tty->flags);
1001 clear_bit(TTY_LDISC, &o_tty->flags);
1002 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1005 * From this point on we know nobody has an ldisc
1006 * usage reference, nor can they obtain one until
1007 * we say so later on.
1010 work = cancel_delayed_work(&tty->buf.work);
1012 * Wait for ->hangup_work and ->buf.work handlers to terminate
1015 flush_scheduled_work();
1016 /* Shutdown the current discipline. */
1017 if (tty->ldisc.close)
1018 (tty->ldisc.close)(tty);
1020 /* Now set up the new line discipline. */
1021 tty_ldisc_assign(tty, ld);
1022 tty_set_termios_ldisc(tty, ldisc);
1023 if (tty->ldisc.open)
1024 retval = (tty->ldisc.open)(tty);
1026 tty_ldisc_put(ldisc);
1027 /* There is an outstanding reference here so this is safe */
1028 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1029 tty_set_termios_ldisc(tty, tty->ldisc.num);
1030 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1031 tty_ldisc_put(o_ldisc.num);
1032 /* This driver is always present */
1033 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1034 tty_set_termios_ldisc(tty, N_TTY);
1035 if (tty->ldisc.open) {
1036 int r = tty->ldisc.open(tty);
1039 panic("Couldn't open N_TTY ldisc for "
1041 tty_name(tty, buf), r);
1045 /* At this point we hold a reference to the new ldisc and a
1046 a reference to the old ldisc. If we ended up flipping back
1047 to the existing ldisc we have two references to it */
1049 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1050 tty->driver->set_ldisc(tty);
1052 tty_ldisc_put(o_ldisc.num);
1055 * Allow ldisc referencing to occur as soon as the driver
1056 * ldisc callback completes.
1059 tty_ldisc_enable(tty);
1061 tty_ldisc_enable(o_tty);
1063 /* Restart it in case no characters kick it off. Safe if
1066 schedule_delayed_work(&tty->buf.work, 1);
1071 * get_tty_driver - find device of a tty
1072 * @dev_t: device identifier
1073 * @index: returns the index of the tty
1075 * This routine returns a tty driver structure, given a device number
1076 * and also passes back the index number.
1078 * Locking: caller must hold tty_mutex
1081 static struct tty_driver *get_tty_driver(dev_t device, int *index)
1083 struct tty_driver *p;
1085 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1086 dev_t base = MKDEV(p->major, p->minor_start);
1087 if (device < base || device >= base + p->num)
1089 *index = device - base;
1096 * tty_check_change - check for POSIX terminal changes
1097 * @tty: tty to check
1099 * If we try to write to, or set the state of, a terminal and we're
1100 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1101 * ignored, go ahead and perform the operation. (POSIX 7.2)
1106 int tty_check_change(struct tty_struct * tty)
1108 if (current->signal->tty != tty)
1110 if (tty->pgrp <= 0) {
1111 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1114 if (process_group(current) == tty->pgrp)
1116 if (is_ignored(SIGTTOU))
1118 if (is_orphaned_pgrp(process_group(current)))
1120 (void) kill_pg(process_group(current), SIGTTOU, 1);
1121 return -ERESTARTSYS;
1124 EXPORT_SYMBOL(tty_check_change);
1126 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1127 size_t count, loff_t *ppos)
1132 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1133 size_t count, loff_t *ppos)
1138 /* No kernel lock held - none needed ;) */
1139 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1141 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1144 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1145 unsigned int cmd, unsigned long arg)
1147 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1150 static const struct file_operations tty_fops = {
1151 .llseek = no_llseek,
1157 .release = tty_release,
1158 .fasync = tty_fasync,
1161 #ifdef CONFIG_UNIX98_PTYS
1162 static const struct file_operations ptmx_fops = {
1163 .llseek = no_llseek,
1169 .release = tty_release,
1170 .fasync = tty_fasync,
1174 static const struct file_operations console_fops = {
1175 .llseek = no_llseek,
1177 .write = redirected_tty_write,
1181 .release = tty_release,
1182 .fasync = tty_fasync,
1185 static const struct file_operations hung_up_tty_fops = {
1186 .llseek = no_llseek,
1187 .read = hung_up_tty_read,
1188 .write = hung_up_tty_write,
1189 .poll = hung_up_tty_poll,
1190 .ioctl = hung_up_tty_ioctl,
1191 .release = tty_release,
1194 static DEFINE_SPINLOCK(redirect_lock);
1195 static struct file *redirect;
1198 * tty_wakeup - request more data
1201 * Internal and external helper for wakeups of tty. This function
1202 * informs the line discipline if present that the driver is ready
1203 * to receive more output data.
1206 void tty_wakeup(struct tty_struct *tty)
1208 struct tty_ldisc *ld;
1210 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1211 ld = tty_ldisc_ref(tty);
1213 if(ld->write_wakeup)
1214 ld->write_wakeup(tty);
1215 tty_ldisc_deref(ld);
1218 wake_up_interruptible(&tty->write_wait);
1221 EXPORT_SYMBOL_GPL(tty_wakeup);
1224 * tty_ldisc_flush - flush line discipline queue
1227 * Flush the line discipline queue (if any) for this tty. If there
1228 * is no line discipline active this is a no-op.
1231 void tty_ldisc_flush(struct tty_struct *tty)
1233 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1235 if(ld->flush_buffer)
1236 ld->flush_buffer(tty);
1237 tty_ldisc_deref(ld);
1241 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1244 * do_tty_hangup - actual handler for hangup events
1247 * This can be called by the "eventd" kernel thread. That is process
1248 * synchronous but doesn't hold any locks, so we need to make sure we
1249 * have the appropriate locks for what we're doing.
1251 * The hangup event clears any pending redirections onto the hung up
1252 * device. It ensures future writes will error and it does the needed
1253 * line discipline hangup and signal delivery. The tty object itself
1258 * redirect lock for undoing redirection
1259 * file list lock for manipulating list of ttys
1260 * tty_ldisc_lock from called functions
1261 * termios_mutex resetting termios data
1262 * tasklist_lock to walk task list for hangup event
1263 * ->siglock to protect ->signal/->sighand
1265 static void do_tty_hangup(struct work_struct *work)
1267 struct tty_struct *tty =
1268 container_of(work, struct tty_struct, hangup_work);
1269 struct file * cons_filp = NULL;
1270 struct file *filp, *f = NULL;
1271 struct task_struct *p;
1272 struct tty_ldisc *ld;
1273 int closecount = 0, n;
1278 /* inuse_filps is protected by the single kernel lock */
1281 spin_lock(&redirect_lock);
1282 if (redirect && redirect->private_data == tty) {
1286 spin_unlock(&redirect_lock);
1288 check_tty_count(tty, "do_tty_hangup");
1290 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1291 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1292 if (filp->f_op->write == redirected_tty_write)
1294 if (filp->f_op->write != tty_write)
1297 tty_fasync(-1, filp, 0); /* can't block */
1298 filp->f_op = &hung_up_tty_fops;
1302 /* FIXME! What are the locking issues here? This may me overdoing things..
1303 * this question is especially important now that we've removed the irqlock. */
1305 ld = tty_ldisc_ref(tty);
1306 if(ld != NULL) /* We may have no line discipline at this point */
1308 if (ld->flush_buffer)
1309 ld->flush_buffer(tty);
1310 if (tty->driver->flush_buffer)
1311 tty->driver->flush_buffer(tty);
1312 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1314 ld->write_wakeup(tty);
1319 /* FIXME: Once we trust the LDISC code better we can wait here for
1320 ldisc completion and fix the driver call race */
1322 wake_up_interruptible(&tty->write_wait);
1323 wake_up_interruptible(&tty->read_wait);
1326 * Shutdown the current line discipline, and reset it to
1329 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1331 mutex_lock(&tty->termios_mutex);
1332 *tty->termios = tty->driver->init_termios;
1333 mutex_unlock(&tty->termios_mutex);
1336 /* Defer ldisc switch */
1337 /* tty_deferred_ldisc_switch(N_TTY);
1339 This should get done automatically when the port closes and
1340 tty_release is called */
1342 read_lock(&tasklist_lock);
1343 if (tty->session > 0) {
1344 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1345 spin_lock_irq(&p->sighand->siglock);
1346 if (p->signal->tty == tty)
1347 p->signal->tty = NULL;
1348 if (!p->signal->leader) {
1349 spin_unlock_irq(&p->sighand->siglock);
1352 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1353 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1355 p->signal->tty_old_pgrp = tty->pgrp;
1356 spin_unlock_irq(&p->sighand->siglock);
1357 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1359 read_unlock(&tasklist_lock);
1364 tty->ctrl_status = 0;
1366 * If one of the devices matches a console pointer, we
1367 * cannot just call hangup() because that will cause
1368 * tty->count and state->count to go out of sync.
1369 * So we just call close() the right number of times.
1372 if (tty->driver->close)
1373 for (n = 0; n < closecount; n++)
1374 tty->driver->close(tty, cons_filp);
1375 } else if (tty->driver->hangup)
1376 (tty->driver->hangup)(tty);
1378 /* We don't want to have driver/ldisc interactions beyond
1379 the ones we did here. The driver layer expects no
1380 calls after ->hangup() from the ldisc side. However we
1381 can't yet guarantee all that */
1383 set_bit(TTY_HUPPED, &tty->flags);
1385 tty_ldisc_enable(tty);
1386 tty_ldisc_deref(ld);
1394 * tty_hangup - trigger a hangup event
1395 * @tty: tty to hangup
1397 * A carrier loss (virtual or otherwise) has occurred on this like
1398 * schedule a hangup sequence to run after this event.
1401 void tty_hangup(struct tty_struct * tty)
1403 #ifdef TTY_DEBUG_HANGUP
1406 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1408 schedule_work(&tty->hangup_work);
1411 EXPORT_SYMBOL(tty_hangup);
1414 * tty_vhangup - process vhangup
1415 * @tty: tty to hangup
1417 * The user has asked via system call for the terminal to be hung up.
1418 * We do this synchronously so that when the syscall returns the process
1419 * is complete. That guarantee is neccessary for security reasons.
1422 void tty_vhangup(struct tty_struct * tty)
1424 #ifdef TTY_DEBUG_HANGUP
1427 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1429 do_tty_hangup(&tty->hangup_work);
1431 EXPORT_SYMBOL(tty_vhangup);
1434 * tty_hung_up_p - was tty hung up
1435 * @filp: file pointer of tty
1437 * Return true if the tty has been subject to a vhangup or a carrier
1441 int tty_hung_up_p(struct file * filp)
1443 return (filp->f_op == &hung_up_tty_fops);
1446 EXPORT_SYMBOL(tty_hung_up_p);
1448 static void session_clear_tty(pid_t session)
1450 struct task_struct *p;
1451 do_each_task_pid(session, PIDTYPE_SID, p) {
1453 } while_each_task_pid(session, PIDTYPE_SID, 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.
1473 * BKL is taken for hysterical raisins
1474 * tty_mutex is taken to protect tty
1475 * ->siglock is taken to protect ->signal/->sighand
1476 * tasklist_lock is taken to walk process list for sessions
1477 * ->siglock is taken to protect ->signal/->sighand
1480 void disassociate_ctty(int on_exit)
1482 struct tty_struct *tty;
1488 mutex_lock(&tty_mutex);
1489 tty = get_current_tty();
1491 tty_pgrp = tty->pgrp;
1492 mutex_unlock(&tty_mutex);
1493 /* XXX: here we race, there is nothing protecting tty */
1494 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1497 pid_t old_pgrp = current->signal->tty_old_pgrp;
1499 kill_pg(old_pgrp, SIGHUP, on_exit);
1500 kill_pg(old_pgrp, SIGCONT, on_exit);
1502 mutex_unlock(&tty_mutex);
1507 kill_pg(tty_pgrp, SIGHUP, on_exit);
1509 kill_pg(tty_pgrp, SIGCONT, on_exit);
1512 spin_lock_irq(¤t->sighand->siglock);
1513 current->signal->tty_old_pgrp = 0;
1514 session = current->signal->session;
1515 spin_unlock_irq(¤t->sighand->siglock);
1517 mutex_lock(&tty_mutex);
1518 /* It is possible that do_tty_hangup has free'd this tty */
1519 tty = get_current_tty();
1524 #ifdef TTY_DEBUG_HANGUP
1525 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
1529 mutex_unlock(&tty_mutex);
1531 /* Now clear signal->tty under the lock */
1532 read_lock(&tasklist_lock);
1533 session_clear_tty(session);
1534 read_unlock(&tasklist_lock);
1540 * stop_tty - propogate flow control
1543 * Perform flow control to the driver. For PTY/TTY pairs we
1544 * must also propogate the TIOCKPKT status. May be called
1545 * on an already stopped device and will not re-call the driver
1548 * This functionality is used by both the line disciplines for
1549 * halting incoming flow and by the driver. It may therefore be
1550 * called from any context, may be under the tty atomic_write_lock
1554 * Broken. Relies on BKL which is unsafe here.
1557 void stop_tty(struct tty_struct *tty)
1562 if (tty->link && tty->link->packet) {
1563 tty->ctrl_status &= ~TIOCPKT_START;
1564 tty->ctrl_status |= TIOCPKT_STOP;
1565 wake_up_interruptible(&tty->link->read_wait);
1567 if (tty->driver->stop)
1568 (tty->driver->stop)(tty);
1571 EXPORT_SYMBOL(stop_tty);
1574 * start_tty - propogate flow control
1575 * @tty: tty to start
1577 * Start a tty that has been stopped if at all possible. Perform
1578 * any neccessary wakeups and propogate the TIOCPKT status. If this
1579 * is the tty was previous stopped and is being started then the
1580 * driver start method is invoked and the line discipline woken.
1583 * Broken. Relies on BKL which is unsafe here.
1586 void start_tty(struct tty_struct *tty)
1588 if (!tty->stopped || tty->flow_stopped)
1591 if (tty->link && tty->link->packet) {
1592 tty->ctrl_status &= ~TIOCPKT_STOP;
1593 tty->ctrl_status |= TIOCPKT_START;
1594 wake_up_interruptible(&tty->link->read_wait);
1596 if (tty->driver->start)
1597 (tty->driver->start)(tty);
1599 /* If we have a running line discipline it may need kicking */
1601 wake_up_interruptible(&tty->write_wait);
1604 EXPORT_SYMBOL(start_tty);
1607 * tty_read - read method for tty device files
1608 * @file: pointer to tty file
1610 * @count: size of user buffer
1613 * Perform the read system call function on this terminal device. Checks
1614 * for hung up devices before calling the line discipline method.
1617 * Locks the line discipline internally while needed
1618 * For historical reasons the line discipline read method is
1619 * invoked under the BKL. This will go away in time so do not rely on it
1620 * in new code. Multiple read calls may be outstanding in parallel.
1623 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1627 struct tty_struct * tty;
1628 struct inode *inode;
1629 struct tty_ldisc *ld;
1631 tty = (struct tty_struct *)file->private_data;
1632 inode = file->f_dentry->d_inode;
1633 if (tty_paranoia_check(tty, inode, "tty_read"))
1635 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1638 /* We want to wait for the line discipline to sort out in this
1640 ld = tty_ldisc_ref_wait(tty);
1643 i = (ld->read)(tty,file,buf,count);
1646 tty_ldisc_deref(ld);
1649 inode->i_atime = current_fs_time(inode->i_sb);
1654 * Split writes up in sane blocksizes to avoid
1655 * denial-of-service type attacks
1657 static inline ssize_t do_tty_write(
1658 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1659 struct tty_struct *tty,
1661 const char __user *buf,
1664 ssize_t ret = 0, written = 0;
1667 /* FIXME: O_NDELAY ... */
1668 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1669 return -ERESTARTSYS;
1673 * We chunk up writes into a temporary buffer. This
1674 * simplifies low-level drivers immensely, since they
1675 * don't have locking issues and user mode accesses.
1677 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1680 * The default chunk-size is 2kB, because the NTTY
1681 * layer has problems with bigger chunks. It will
1682 * claim to be able to handle more characters than
1685 * FIXME: This can probably go away now except that 64K chunks
1686 * are too likely to fail unless switched to vmalloc...
1689 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1694 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1695 if (tty->write_cnt < chunk) {
1701 buf = kmalloc(chunk, GFP_KERNEL);
1703 mutex_unlock(&tty->atomic_write_lock);
1706 kfree(tty->write_buf);
1707 tty->write_cnt = chunk;
1708 tty->write_buf = buf;
1711 /* Do the write .. */
1713 size_t size = count;
1717 if (copy_from_user(tty->write_buf, buf, size))
1720 ret = write(tty, file, tty->write_buf, size);
1730 if (signal_pending(current))
1735 struct inode *inode = file->f_dentry->d_inode;
1736 inode->i_mtime = current_fs_time(inode->i_sb);
1739 mutex_unlock(&tty->atomic_write_lock);
1745 * tty_write - write method for tty device file
1746 * @file: tty file pointer
1747 * @buf: user data to write
1748 * @count: bytes to write
1751 * Write data to a tty device via the line discipline.
1754 * Locks the line discipline as required
1755 * Writes to the tty driver are serialized by the atomic_write_lock
1756 * and are then processed in chunks to the device. The line discipline
1757 * write method will not be involked in parallel for each device
1758 * The line discipline write method is called under the big
1759 * kernel lock for historical reasons. New code should not rely on this.
1762 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1765 struct tty_struct * tty;
1766 struct inode *inode = file->f_dentry->d_inode;
1768 struct tty_ldisc *ld;
1770 tty = (struct tty_struct *)file->private_data;
1771 if (tty_paranoia_check(tty, inode, "tty_write"))
1773 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1776 ld = tty_ldisc_ref_wait(tty);
1780 ret = do_tty_write(ld->write, tty, file, buf, count);
1781 tty_ldisc_deref(ld);
1785 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1788 struct file *p = NULL;
1790 spin_lock(&redirect_lock);
1795 spin_unlock(&redirect_lock);
1799 res = vfs_write(p, buf, count, &p->f_pos);
1804 return tty_write(file, buf, count, ppos);
1807 static char ptychar[] = "pqrstuvwxyzabcde";
1810 * pty_line_name - generate name for a pty
1811 * @driver: the tty driver in use
1812 * @index: the minor number
1813 * @p: output buffer of at least 6 bytes
1815 * Generate a name from a driver reference and write it to the output
1820 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1822 int i = index + driver->name_base;
1823 /* ->name is initialized to "ttyp", but "tty" is expected */
1824 sprintf(p, "%s%c%x",
1825 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1826 ptychar[i >> 4 & 0xf], i & 0xf);
1830 * pty_line_name - generate name for a tty
1831 * @driver: the tty driver in use
1832 * @index: the minor number
1833 * @p: output buffer of at least 7 bytes
1835 * Generate a name from a driver reference and write it to the output
1840 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1842 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1846 * init_dev - initialise a tty device
1847 * @driver: tty driver we are opening a device on
1848 * @idx: device index
1849 * @tty: returned tty structure
1851 * Prepare a tty device. This may not be a "new" clean device but
1852 * could also be an active device. The pty drivers require special
1853 * handling because of this.
1856 * The function is called under the tty_mutex, which
1857 * protects us from the tty struct or driver itself going away.
1859 * On exit the tty device has the line discipline attached and
1860 * a reference count of 1. If a pair was created for pty/tty use
1861 * and the other was a pty master then it too has a reference count of 1.
1863 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1864 * failed open. The new code protects the open with a mutex, so it's
1865 * really quite straightforward. The mutex locking can probably be
1866 * relaxed for the (most common) case of reopening a tty.
1869 static int init_dev(struct tty_driver *driver, int idx,
1870 struct tty_struct **ret_tty)
1872 struct tty_struct *tty, *o_tty;
1873 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1874 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1877 /* check whether we're reopening an existing tty */
1878 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1879 tty = devpts_get_tty(idx);
1880 if (tty && driver->subtype == PTY_TYPE_MASTER)
1883 tty = driver->ttys[idx];
1885 if (tty) goto fast_track;
1888 * First time open is complex, especially for PTY devices.
1889 * This code guarantees that either everything succeeds and the
1890 * TTY is ready for operation, or else the table slots are vacated
1891 * and the allocated memory released. (Except that the termios
1892 * and locked termios may be retained.)
1895 if (!try_module_get(driver->owner)) {
1904 tty = alloc_tty_struct();
1907 initialize_tty_struct(tty);
1908 tty->driver = driver;
1910 tty_line_name(driver, idx, tty->name);
1912 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1913 tp_loc = &tty->termios;
1914 ltp_loc = &tty->termios_locked;
1916 tp_loc = &driver->termios[idx];
1917 ltp_loc = &driver->termios_locked[idx];
1921 tp = (struct termios *) kmalloc(sizeof(struct termios),
1925 *tp = driver->init_termios;
1929 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1933 memset(ltp, 0, sizeof(struct termios));
1936 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1937 o_tty = alloc_tty_struct();
1940 initialize_tty_struct(o_tty);
1941 o_tty->driver = driver->other;
1943 tty_line_name(driver->other, idx, o_tty->name);
1945 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1946 o_tp_loc = &o_tty->termios;
1947 o_ltp_loc = &o_tty->termios_locked;
1949 o_tp_loc = &driver->other->termios[idx];
1950 o_ltp_loc = &driver->other->termios_locked[idx];
1954 o_tp = (struct termios *)
1955 kmalloc(sizeof(struct termios), GFP_KERNEL);
1958 *o_tp = driver->other->init_termios;
1962 o_ltp = (struct termios *)
1963 kmalloc(sizeof(struct termios), GFP_KERNEL);
1966 memset(o_ltp, 0, sizeof(struct termios));
1970 * Everything allocated ... set up the o_tty structure.
1972 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1973 driver->other->ttys[idx] = o_tty;
1979 o_tty->termios = *o_tp_loc;
1980 o_tty->termios_locked = *o_ltp_loc;
1981 driver->other->refcount++;
1982 if (driver->subtype == PTY_TYPE_MASTER)
1985 /* Establish the links in both directions */
1991 * All structures have been allocated, so now we install them.
1992 * Failures after this point use release_mem to clean up, so
1993 * there's no need to null out the local pointers.
1995 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1996 driver->ttys[idx] = tty;
2003 tty->termios = *tp_loc;
2004 tty->termios_locked = *ltp_loc;
2009 * Structures all installed ... call the ldisc open routines.
2010 * If we fail here just call release_mem to clean up. No need
2011 * to decrement the use counts, as release_mem doesn't care.
2014 if (tty->ldisc.open) {
2015 retval = (tty->ldisc.open)(tty);
2017 goto release_mem_out;
2019 if (o_tty && o_tty->ldisc.open) {
2020 retval = (o_tty->ldisc.open)(o_tty);
2022 if (tty->ldisc.close)
2023 (tty->ldisc.close)(tty);
2024 goto release_mem_out;
2026 tty_ldisc_enable(o_tty);
2028 tty_ldisc_enable(tty);
2032 * This fast open can be used if the tty is already open.
2033 * No memory is allocated, and the only failures are from
2034 * attempting to open a closing tty or attempting multiple
2035 * opens on a pty master.
2038 if (test_bit(TTY_CLOSING, &tty->flags)) {
2042 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2043 driver->subtype == PTY_TYPE_MASTER) {
2045 * special case for PTY masters: only one open permitted,
2046 * and the slave side open count is incremented as well.
2055 tty->driver = driver; /* N.B. why do this every time?? */
2058 if(!test_bit(TTY_LDISC, &tty->flags))
2059 printk(KERN_ERR "init_dev but no ldisc\n");
2063 /* All paths come through here to release the mutex */
2067 /* Release locally allocated memory ... nothing placed in slots */
2071 free_tty_struct(o_tty);
2074 free_tty_struct(tty);
2077 module_put(driver->owner);
2081 /* call the tty release_mem routine to clean out this slot */
2083 if (printk_ratelimit())
2084 printk(KERN_INFO "init_dev: ldisc open failed, "
2085 "clearing slot %d\n", idx);
2086 release_mem(tty, idx);
2091 * release_mem - release tty structure memory
2093 * Releases memory associated with a tty structure, and clears out the
2094 * driver table slots. This function is called when a device is no longer
2095 * in use. It also gets called when setup of a device fails.
2098 * tty_mutex - sometimes only
2099 * takes the file list lock internally when working on the list
2100 * of ttys that the driver keeps.
2101 * FIXME: should we require tty_mutex is held here ??
2104 static void release_mem(struct tty_struct *tty, int idx)
2106 struct tty_struct *o_tty;
2108 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2110 if ((o_tty = tty->link) != NULL) {
2112 o_tty->driver->ttys[idx] = NULL;
2113 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2114 tp = o_tty->termios;
2116 o_tty->driver->termios[idx] = NULL;
2119 tp = o_tty->termios_locked;
2121 o_tty->driver->termios_locked[idx] = NULL;
2125 o_tty->driver->refcount--;
2127 list_del_init(&o_tty->tty_files);
2129 free_tty_struct(o_tty);
2133 tty->driver->ttys[idx] = NULL;
2134 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2137 tty->driver->termios[idx] = NULL;
2140 tp = tty->termios_locked;
2142 tty->driver->termios_locked[idx] = NULL;
2147 tty->driver->refcount--;
2149 list_del_init(&tty->tty_files);
2151 module_put(tty->driver->owner);
2152 free_tty_struct(tty);
2156 * Even releasing the tty structures is a tricky business.. We have
2157 * to be very careful that the structures are all released at the
2158 * same time, as interrupts might otherwise get the wrong pointers.
2160 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2161 * lead to double frees or releasing memory still in use.
2163 static void release_dev(struct file * filp)
2165 struct tty_struct *tty, *o_tty;
2166 int pty_master, tty_closing, o_tty_closing, do_sleep;
2170 unsigned long flags;
2172 tty = (struct tty_struct *)filp->private_data;
2173 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2176 check_tty_count(tty, "release_dev");
2178 tty_fasync(-1, filp, 0);
2181 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2182 tty->driver->subtype == PTY_TYPE_MASTER);
2183 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2186 #ifdef TTY_PARANOIA_CHECK
2187 if (idx < 0 || idx >= tty->driver->num) {
2188 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2189 "free (%s)\n", tty->name);
2192 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2193 if (tty != tty->driver->ttys[idx]) {
2194 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2195 "for (%s)\n", idx, tty->name);
2198 if (tty->termios != tty->driver->termios[idx]) {
2199 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2204 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2205 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2206 "termios_locked for (%s)\n",
2213 #ifdef TTY_DEBUG_HANGUP
2214 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2215 tty_name(tty, buf), tty->count);
2218 #ifdef TTY_PARANOIA_CHECK
2219 if (tty->driver->other &&
2220 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2221 if (o_tty != tty->driver->other->ttys[idx]) {
2222 printk(KERN_DEBUG "release_dev: other->table[%d] "
2223 "not o_tty for (%s)\n",
2227 if (o_tty->termios != tty->driver->other->termios[idx]) {
2228 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2229 "not o_termios for (%s)\n",
2233 if (o_tty->termios_locked !=
2234 tty->driver->other->termios_locked[idx]) {
2235 printk(KERN_DEBUG "release_dev: other->termios_locked["
2236 "%d] not o_termios_locked for (%s)\n",
2240 if (o_tty->link != tty) {
2241 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2246 if (tty->driver->close)
2247 tty->driver->close(tty, filp);
2250 * Sanity check: if tty->count is going to zero, there shouldn't be
2251 * any waiters on tty->read_wait or tty->write_wait. We test the
2252 * wait queues and kick everyone out _before_ actually starting to
2253 * close. This ensures that we won't block while releasing the tty
2256 * The test for the o_tty closing is necessary, since the master and
2257 * slave sides may close in any order. If the slave side closes out
2258 * first, its count will be one, since the master side holds an open.
2259 * Thus this test wouldn't be triggered at the time the slave closes,
2262 * Note that it's possible for the tty to be opened again while we're
2263 * flushing out waiters. By recalculating the closing flags before
2264 * each iteration we avoid any problems.
2267 /* Guard against races with tty->count changes elsewhere and
2268 opens on /dev/tty */
2270 mutex_lock(&tty_mutex);
2271 tty_closing = tty->count <= 1;
2272 o_tty_closing = o_tty &&
2273 (o_tty->count <= (pty_master ? 1 : 0));
2277 if (waitqueue_active(&tty->read_wait)) {
2278 wake_up(&tty->read_wait);
2281 if (waitqueue_active(&tty->write_wait)) {
2282 wake_up(&tty->write_wait);
2286 if (o_tty_closing) {
2287 if (waitqueue_active(&o_tty->read_wait)) {
2288 wake_up(&o_tty->read_wait);
2291 if (waitqueue_active(&o_tty->write_wait)) {
2292 wake_up(&o_tty->write_wait);
2299 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2300 "active!\n", tty_name(tty, buf));
2301 mutex_unlock(&tty_mutex);
2306 * The closing flags are now consistent with the open counts on
2307 * both sides, and we've completed the last operation that could
2308 * block, so it's safe to proceed with closing.
2311 if (--o_tty->count < 0) {
2312 printk(KERN_WARNING "release_dev: bad pty slave count "
2314 o_tty->count, tty_name(o_tty, buf));
2318 if (--tty->count < 0) {
2319 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2320 tty->count, tty_name(tty, buf));
2325 * We've decremented tty->count, so we need to remove this file
2326 * descriptor off the tty->tty_files list; this serves two
2328 * - check_tty_count sees the correct number of file descriptors
2329 * associated with this tty.
2330 * - do_tty_hangup no longer sees this file descriptor as
2331 * something that needs to be handled for hangups.
2334 filp->private_data = NULL;
2337 * Perform some housekeeping before deciding whether to return.
2339 * Set the TTY_CLOSING flag if this was the last open. In the
2340 * case of a pty we may have to wait around for the other side
2341 * to close, and TTY_CLOSING makes sure we can't be reopened.
2344 set_bit(TTY_CLOSING, &tty->flags);
2346 set_bit(TTY_CLOSING, &o_tty->flags);
2349 * If _either_ side is closing, make sure there aren't any
2350 * processes that still think tty or o_tty is their controlling
2353 if (tty_closing || o_tty_closing) {
2354 read_lock(&tasklist_lock);
2355 session_clear_tty(tty->session);
2357 session_clear_tty(o_tty->session);
2358 read_unlock(&tasklist_lock);
2361 mutex_unlock(&tty_mutex);
2363 /* check whether both sides are closing ... */
2364 if (!tty_closing || (o_tty && !o_tty_closing))
2367 #ifdef TTY_DEBUG_HANGUP
2368 printk(KERN_DEBUG "freeing tty structure...");
2371 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2372 * kill any delayed work. As this is the final close it does not
2373 * race with the set_ldisc code path.
2375 clear_bit(TTY_LDISC, &tty->flags);
2376 cancel_delayed_work(&tty->buf.work);
2379 * Wait for ->hangup_work and ->buf.work handlers to terminate
2382 flush_scheduled_work();
2385 * Wait for any short term users (we know they are just driver
2386 * side waiters as the file is closing so user count on the file
2389 spin_lock_irqsave(&tty_ldisc_lock, flags);
2390 while(tty->ldisc.refcount)
2392 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2393 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2394 spin_lock_irqsave(&tty_ldisc_lock, flags);
2396 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2398 * Shutdown the current line discipline, and reset it to N_TTY.
2399 * N.B. why reset ldisc when we're releasing the memory??
2401 * FIXME: this MUST get fixed for the new reflocking
2403 if (tty->ldisc.close)
2404 (tty->ldisc.close)(tty);
2405 tty_ldisc_put(tty->ldisc.num);
2408 * Switch the line discipline back
2410 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2411 tty_set_termios_ldisc(tty,N_TTY);
2413 /* FIXME: could o_tty be in setldisc here ? */
2414 clear_bit(TTY_LDISC, &o_tty->flags);
2415 if (o_tty->ldisc.close)
2416 (o_tty->ldisc.close)(o_tty);
2417 tty_ldisc_put(o_tty->ldisc.num);
2418 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2419 tty_set_termios_ldisc(o_tty,N_TTY);
2422 * The release_mem function takes care of the details of clearing
2423 * the slots and preserving the termios structure.
2425 release_mem(tty, idx);
2427 #ifdef CONFIG_UNIX98_PTYS
2428 /* Make this pty number available for reallocation */
2430 down(&allocated_ptys_lock);
2431 idr_remove(&allocated_ptys, idx);
2432 up(&allocated_ptys_lock);
2439 * tty_open - open a tty device
2440 * @inode: inode of device file
2441 * @filp: file pointer to tty
2443 * tty_open and tty_release keep up the tty count that contains the
2444 * number of opens done on a tty. We cannot use the inode-count, as
2445 * different inodes might point to the same tty.
2447 * Open-counting is needed for pty masters, as well as for keeping
2448 * track of serial lines: DTR is dropped when the last close happens.
2449 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2451 * The termios state of a pty is reset on first open so that
2452 * settings don't persist across reuse.
2454 * Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2455 * tty->count should protect the rest.
2456 * ->siglock protects ->signal/->sighand
2459 static int tty_open(struct inode * inode, struct file * filp)
2461 struct tty_struct *tty;
2463 struct tty_driver *driver;
2465 dev_t device = inode->i_rdev;
2466 unsigned short saved_flags = filp->f_flags;
2468 nonseekable_open(inode, filp);
2471 noctty = filp->f_flags & O_NOCTTY;
2475 mutex_lock(&tty_mutex);
2477 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2478 tty = get_current_tty();
2480 mutex_unlock(&tty_mutex);
2483 driver = tty->driver;
2485 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2490 if (device == MKDEV(TTY_MAJOR,0)) {
2491 extern struct tty_driver *console_driver;
2492 driver = console_driver;
2498 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2499 driver = console_device(&index);
2501 /* Don't let /dev/console block */
2502 filp->f_flags |= O_NONBLOCK;
2506 mutex_unlock(&tty_mutex);
2510 driver = get_tty_driver(device, &index);
2512 mutex_unlock(&tty_mutex);
2516 retval = init_dev(driver, index, &tty);
2517 mutex_unlock(&tty_mutex);
2521 filp->private_data = tty;
2522 file_move(filp, &tty->tty_files);
2523 check_tty_count(tty, "tty_open");
2524 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2525 tty->driver->subtype == PTY_TYPE_MASTER)
2527 #ifdef TTY_DEBUG_HANGUP
2528 printk(KERN_DEBUG "opening %s...", tty->name);
2531 if (tty->driver->open)
2532 retval = tty->driver->open(tty, filp);
2536 filp->f_flags = saved_flags;
2538 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2542 #ifdef TTY_DEBUG_HANGUP
2543 printk(KERN_DEBUG "error %d in opening %s...", retval,
2547 if (retval != -ERESTARTSYS)
2549 if (signal_pending(current))
2553 * Need to reset f_op in case a hangup happened.
2555 if (filp->f_op == &hung_up_tty_fops)
2556 filp->f_op = &tty_fops;
2560 mutex_lock(&tty_mutex);
2561 spin_lock_irq(¤t->sighand->siglock);
2563 current->signal->leader &&
2564 !current->signal->tty &&
2566 __proc_set_tty(current, tty);
2567 spin_unlock_irq(¤t->sighand->siglock);
2568 mutex_unlock(&tty_mutex);
2572 #ifdef CONFIG_UNIX98_PTYS
2574 * ptmx_open - open a unix 98 pty master
2575 * @inode: inode of device file
2576 * @filp: file pointer to tty
2578 * Allocate a unix98 pty master device from the ptmx driver.
2580 * Locking: tty_mutex protects theinit_dev work. tty->count should
2582 * allocated_ptys_lock handles the list of free pty numbers
2585 static int ptmx_open(struct inode * inode, struct file * filp)
2587 struct tty_struct *tty;
2592 nonseekable_open(inode, filp);
2594 /* find a device that is not in use. */
2595 down(&allocated_ptys_lock);
2596 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2597 up(&allocated_ptys_lock);
2600 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2602 up(&allocated_ptys_lock);
2603 if (idr_ret == -EAGAIN)
2607 if (index >= pty_limit) {
2608 idr_remove(&allocated_ptys, index);
2609 up(&allocated_ptys_lock);
2612 up(&allocated_ptys_lock);
2614 mutex_lock(&tty_mutex);
2615 retval = init_dev(ptm_driver, index, &tty);
2616 mutex_unlock(&tty_mutex);
2621 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2622 filp->private_data = tty;
2623 file_move(filp, &tty->tty_files);
2626 if (devpts_pty_new(tty->link))
2629 check_tty_count(tty, "tty_open");
2630 retval = ptm_driver->open(tty, filp);
2637 down(&allocated_ptys_lock);
2638 idr_remove(&allocated_ptys, index);
2639 up(&allocated_ptys_lock);
2645 * tty_release - vfs callback for close
2646 * @inode: inode of tty
2647 * @filp: file pointer for handle to tty
2649 * Called the last time each file handle is closed that references
2650 * this tty. There may however be several such references.
2653 * Takes bkl. See release_dev
2656 static int tty_release(struct inode * inode, struct file * filp)
2665 * tty_poll - check tty status
2666 * @filp: file being polled
2667 * @wait: poll wait structures to update
2669 * Call the line discipline polling method to obtain the poll
2670 * status of the device.
2672 * Locking: locks called line discipline but ldisc poll method
2673 * may be re-entered freely by other callers.
2676 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2678 struct tty_struct * tty;
2679 struct tty_ldisc *ld;
2682 tty = (struct tty_struct *)filp->private_data;
2683 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2686 ld = tty_ldisc_ref_wait(tty);
2688 ret = (ld->poll)(tty, filp, wait);
2689 tty_ldisc_deref(ld);
2693 static int tty_fasync(int fd, struct file * filp, int on)
2695 struct tty_struct * tty;
2698 tty = (struct tty_struct *)filp->private_data;
2699 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2702 retval = fasync_helper(fd, filp, on, &tty->fasync);
2707 if (!waitqueue_active(&tty->read_wait))
2708 tty->minimum_to_wake = 1;
2709 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2713 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2714 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2720 * tiocsti - fake input character
2721 * @tty: tty to fake input into
2722 * @p: pointer to character
2724 * Fake input to a tty device. Does the neccessary locking and
2727 * FIXME: does not honour flow control ??
2730 * Called functions take tty_ldisc_lock
2731 * current->signal->tty check is safe without locks
2733 * FIXME: may race normal receive processing
2736 static int tiocsti(struct tty_struct *tty, char __user *p)
2739 struct tty_ldisc *ld;
2741 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2743 if (get_user(ch, p))
2745 ld = tty_ldisc_ref_wait(tty);
2746 ld->receive_buf(tty, &ch, &mbz, 1);
2747 tty_ldisc_deref(ld);
2752 * tiocgwinsz - implement window query ioctl
2754 * @arg: user buffer for result
2756 * Copies the kernel idea of the window size into the user buffer.
2758 * Locking: tty->termios_mutex is taken to ensure the winsize data
2762 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2766 mutex_lock(&tty->termios_mutex);
2767 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2768 mutex_unlock(&tty->termios_mutex);
2770 return err ? -EFAULT: 0;
2774 * tiocswinsz - implement window size set ioctl
2776 * @arg: user buffer for result
2778 * Copies the user idea of the window size to the kernel. Traditionally
2779 * this is just advisory information but for the Linux console it
2780 * actually has driver level meaning and triggers a VC resize.
2783 * Called function use the console_sem is used to ensure we do
2784 * not try and resize the console twice at once.
2785 * The tty->termios_mutex is used to ensure we don't double
2786 * resize and get confused. Lock order - tty->termios_mutex before
2790 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2791 struct winsize __user * arg)
2793 struct winsize tmp_ws;
2795 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2798 mutex_lock(&tty->termios_mutex);
2799 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2803 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2804 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2806 mutex_unlock(&tty->termios_mutex);
2812 kill_pg(tty->pgrp, SIGWINCH, 1);
2813 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2814 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2815 tty->winsize = tmp_ws;
2816 real_tty->winsize = tmp_ws;
2818 mutex_unlock(&tty->termios_mutex);
2823 * tioccons - allow admin to move logical console
2824 * @file: the file to become console
2826 * Allow the adminstrator to move the redirected console device
2828 * Locking: uses redirect_lock to guard the redirect information
2831 static int tioccons(struct file *file)
2833 if (!capable(CAP_SYS_ADMIN))
2835 if (file->f_op->write == redirected_tty_write) {
2837 spin_lock(&redirect_lock);
2840 spin_unlock(&redirect_lock);
2845 spin_lock(&redirect_lock);
2847 spin_unlock(&redirect_lock);
2852 spin_unlock(&redirect_lock);
2857 * fionbio - non blocking ioctl
2858 * @file: file to set blocking value
2859 * @p: user parameter
2861 * Historical tty interfaces had a blocking control ioctl before
2862 * the generic functionality existed. This piece of history is preserved
2863 * in the expected tty API of posix OS's.
2865 * Locking: none, the open fle handle ensures it won't go away.
2868 static int fionbio(struct file *file, int __user *p)
2872 if (get_user(nonblock, p))
2876 file->f_flags |= O_NONBLOCK;
2878 file->f_flags &= ~O_NONBLOCK;
2883 * tiocsctty - set controlling tty
2884 * @tty: tty structure
2885 * @arg: user argument
2887 * This ioctl is used to manage job control. It permits a session
2888 * leader to set this tty as the controlling tty for the session.
2891 * Takes tty_mutex() to protect tty instance
2892 * Takes tasklist_lock internally to walk sessions
2893 * Takes ->siglock() when updating signal->tty
2896 static int tiocsctty(struct tty_struct *tty, int arg)
2899 if (current->signal->leader &&
2900 (current->signal->session == tty->session))
2903 mutex_lock(&tty_mutex);
2905 * The process must be a session leader and
2906 * not have a controlling tty already.
2908 if (!current->signal->leader || current->signal->tty) {
2913 if (tty->session > 0) {
2915 * This tty is already the controlling
2916 * tty for another session group!
2918 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2922 read_lock(&tasklist_lock);
2923 session_clear_tty(tty->session);
2924 read_unlock(&tasklist_lock);
2930 proc_set_tty(current, tty);
2932 mutex_unlock(&tty_mutex);
2937 * tiocgpgrp - get process group
2938 * @tty: tty passed by user
2939 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2942 * Obtain the process group of the tty. If there is no process group
2945 * Locking: none. Reference to current->signal->tty is safe.
2948 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2951 * (tty == real_tty) is a cheap way of
2952 * testing if the tty is NOT a master pty.
2954 if (tty == real_tty && current->signal->tty != real_tty)
2956 return put_user(real_tty->pgrp, p);
2960 * tiocspgrp - attempt to set process group
2961 * @tty: tty passed by user
2962 * @real_tty: tty side device matching tty passed by user
2965 * Set the process group of the tty to the session passed. Only
2966 * permitted where the tty session is our session.
2971 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2974 int retval = tty_check_change(real_tty);
2980 if (!current->signal->tty ||
2981 (current->signal->tty != real_tty) ||
2982 (real_tty->session != current->signal->session))
2984 if (get_user(pgrp, p))
2988 if (session_of_pgrp(pgrp) != current->signal->session)
2990 real_tty->pgrp = pgrp;
2995 * tiocgsid - get session id
2996 * @tty: tty passed by user
2997 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2998 * @p: pointer to returned session id
3000 * Obtain the session id of the tty. If there is no session
3003 * Locking: none. Reference to current->signal->tty is safe.
3006 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3009 * (tty == real_tty) is a cheap way of
3010 * testing if the tty is NOT a master pty.
3012 if (tty == real_tty && current->signal->tty != real_tty)
3014 if (real_tty->session <= 0)
3016 return put_user(real_tty->session, p);
3020 * tiocsetd - set line discipline
3022 * @p: pointer to user data
3024 * Set the line discipline according to user request.
3026 * Locking: see tty_set_ldisc, this function is just a helper
3029 static int tiocsetd(struct tty_struct *tty, int __user *p)
3033 if (get_user(ldisc, p))
3035 return tty_set_ldisc(tty, ldisc);
3039 * send_break - performed time break
3040 * @tty: device to break on
3041 * @duration: timeout in mS
3043 * Perform a timed break on hardware that lacks its own driver level
3044 * timed break functionality.
3047 * atomic_write_lock serializes
3051 static int send_break(struct tty_struct *tty, unsigned int duration)
3053 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3055 tty->driver->break_ctl(tty, -1);
3056 if (!signal_pending(current)) {
3057 msleep_interruptible(duration);
3059 tty->driver->break_ctl(tty, 0);
3060 mutex_unlock(&tty->atomic_write_lock);
3061 if (signal_pending(current))
3067 * tiocmget - get modem status
3069 * @file: user file pointer
3070 * @p: pointer to result
3072 * Obtain the modem status bits from the tty driver if the feature
3073 * is supported. Return -EINVAL if it is not available.
3075 * Locking: none (up to the driver)
3078 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3080 int retval = -EINVAL;
3082 if (tty->driver->tiocmget) {
3083 retval = tty->driver->tiocmget(tty, file);
3086 retval = put_user(retval, p);
3092 * tiocmset - set modem status
3094 * @file: user file pointer
3095 * @cmd: command - clear bits, set bits or set all
3096 * @p: pointer to desired bits
3098 * Set the modem status bits from the tty driver if the feature
3099 * is supported. Return -EINVAL if it is not available.
3101 * Locking: none (up to the driver)
3104 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3107 int retval = -EINVAL;
3109 if (tty->driver->tiocmset) {
3110 unsigned int set, clear, val;
3112 retval = get_user(val, p);
3130 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3131 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3133 retval = tty->driver->tiocmset(tty, file, set, clear);
3139 * Split this up, as gcc can choke on it otherwise..
3141 int tty_ioctl(struct inode * inode, struct file * file,
3142 unsigned int cmd, unsigned long arg)
3144 struct tty_struct *tty, *real_tty;
3145 void __user *p = (void __user *)arg;
3147 struct tty_ldisc *ld;
3149 tty = (struct tty_struct *)file->private_data;
3150 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3153 /* CHECKME: is this safe as one end closes ? */
3156 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3157 tty->driver->subtype == PTY_TYPE_MASTER)
3158 real_tty = tty->link;
3161 * Break handling by driver
3163 if (!tty->driver->break_ctl) {
3167 if (tty->driver->ioctl)
3168 return tty->driver->ioctl(tty, file, cmd, arg);
3171 /* These two ioctl's always return success; even if */
3172 /* the driver doesn't support them. */
3175 if (!tty->driver->ioctl)
3177 retval = tty->driver->ioctl(tty, file, cmd, arg);
3178 if (retval == -ENOIOCTLCMD)
3185 * Factor out some common prep work
3193 retval = tty_check_change(tty);
3196 if (cmd != TIOCCBRK) {
3197 tty_wait_until_sent(tty, 0);
3198 if (signal_pending(current))
3206 return tiocsti(tty, p);
3208 return tiocgwinsz(tty, p);
3210 return tiocswinsz(tty, real_tty, p);
3212 return real_tty!=tty ? -EINVAL : tioccons(file);
3214 return fionbio(file, p);
3216 set_bit(TTY_EXCLUSIVE, &tty->flags);
3219 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3222 if (current->signal->tty != tty)
3224 if (current->signal->leader)
3225 disassociate_ctty(0);
3226 proc_clear_tty(current);
3229 return tiocsctty(tty, arg);
3231 return tiocgpgrp(tty, real_tty, p);
3233 return tiocspgrp(tty, real_tty, p);
3235 return tiocgsid(tty, real_tty, p);
3237 /* FIXME: check this is ok */
3238 return put_user(tty->ldisc.num, (int __user *)p);
3240 return tiocsetd(tty, p);
3243 return tioclinux(tty, arg);
3248 case TIOCSBRK: /* Turn break on, unconditionally */
3249 tty->driver->break_ctl(tty, -1);
3252 case TIOCCBRK: /* Turn break off, unconditionally */
3253 tty->driver->break_ctl(tty, 0);
3255 case TCSBRK: /* SVID version: non-zero arg --> no break */
3256 /* non-zero arg means wait for all output data
3257 * to be sent (performed above) but don't send break.
3258 * This is used by the tcdrain() termios function.
3261 return send_break(tty, 250);
3263 case TCSBRKP: /* support for POSIX tcsendbreak() */
3264 return send_break(tty, arg ? arg*100 : 250);
3267 return tty_tiocmget(tty, file, p);
3272 return tty_tiocmset(tty, file, cmd, p);
3274 if (tty->driver->ioctl) {
3275 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3276 if (retval != -ENOIOCTLCMD)
3279 ld = tty_ldisc_ref_wait(tty);
3282 retval = ld->ioctl(tty, file, cmd, arg);
3283 if (retval == -ENOIOCTLCMD)
3286 tty_ldisc_deref(ld);
3292 * This implements the "Secure Attention Key" --- the idea is to
3293 * prevent trojan horses by killing all processes associated with this
3294 * tty when the user hits the "Secure Attention Key". Required for
3295 * super-paranoid applications --- see the Orange Book for more details.
3297 * This code could be nicer; ideally it should send a HUP, wait a few
3298 * seconds, then send a INT, and then a KILL signal. But you then
3299 * have to coordinate with the init process, since all processes associated
3300 * with the current tty must be dead before the new getty is allowed
3303 * Now, if it would be correct ;-/ The current code has a nasty hole -
3304 * it doesn't catch files in flight. We may send the descriptor to ourselves
3305 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3307 * Nasty bug: do_SAK is being called in interrupt context. This can
3308 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3310 static void __do_SAK(struct work_struct *work)
3312 struct tty_struct *tty =
3313 container_of(work, struct tty_struct, SAK_work);
3317 struct task_struct *g, *p;
3321 struct tty_ldisc *disc;
3322 struct fdtable *fdt;
3326 session = tty->session;
3328 /* We don't want an ldisc switch during this */
3329 disc = tty_ldisc_ref(tty);
3330 if (disc && disc->flush_buffer)
3331 disc->flush_buffer(tty);
3332 tty_ldisc_deref(disc);
3334 if (tty->driver->flush_buffer)
3335 tty->driver->flush_buffer(tty);
3337 read_lock(&tasklist_lock);
3338 /* Kill the entire session */
3339 do_each_task_pid(session, PIDTYPE_SID, p) {
3340 printk(KERN_NOTICE "SAK: killed process %d"
3341 " (%s): p->signal->session==tty->session\n",
3343 send_sig(SIGKILL, p, 1);
3344 } while_each_task_pid(session, PIDTYPE_SID, p);
3345 /* Now kill any processes that happen to have the
3348 do_each_thread(g, p) {
3349 if (p->signal->tty == tty) {
3350 printk(KERN_NOTICE "SAK: killed process %d"
3351 " (%s): p->signal->session==tty->session\n",
3353 send_sig(SIGKILL, p, 1);
3359 * We don't take a ref to the file, so we must
3360 * hold ->file_lock instead.
3362 spin_lock(&p->files->file_lock);
3363 fdt = files_fdtable(p->files);
3364 for (i=0; i < fdt->max_fds; i++) {
3365 filp = fcheck_files(p->files, i);
3368 if (filp->f_op->read == tty_read &&
3369 filp->private_data == tty) {
3370 printk(KERN_NOTICE "SAK: killed process %d"
3371 " (%s): fd#%d opened to the tty\n",
3372 p->pid, p->comm, i);
3373 force_sig(SIGKILL, p);
3377 spin_unlock(&p->files->file_lock);
3380 } while_each_thread(g, p);
3381 read_unlock(&tasklist_lock);
3386 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3387 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3388 * the values which we write to it will be identical to the values which it
3389 * already has. --akpm
3391 void do_SAK(struct tty_struct *tty)
3395 PREPARE_WORK(&tty->SAK_work, __do_SAK);
3396 schedule_work(&tty->SAK_work);
3399 EXPORT_SYMBOL(do_SAK);
3403 * @work: tty structure passed from work queue.
3405 * This routine is called out of the software interrupt to flush data
3406 * from the buffer chain to the line discipline.
3408 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3409 * while invoking the line discipline receive_buf method. The
3410 * receive_buf method is single threaded for each tty instance.
3413 static void flush_to_ldisc(struct work_struct *work)
3415 struct tty_struct *tty =
3416 container_of(work, struct tty_struct, buf.work.work);
3417 unsigned long flags;
3418 struct tty_ldisc *disc;
3419 struct tty_buffer *tbuf, *head;
3421 unsigned char *flag_buf;
3423 disc = tty_ldisc_ref(tty);
3424 if (disc == NULL) /* !TTY_LDISC */
3427 spin_lock_irqsave(&tty->buf.lock, flags);
3428 head = tty->buf.head;
3430 tty->buf.head = NULL;
3432 int count = head->commit - head->read;
3434 if (head->next == NULL)
3438 tty_buffer_free(tty, tbuf);
3441 if (!tty->receive_room) {
3442 schedule_delayed_work(&tty->buf.work, 1);
3445 if (count > tty->receive_room)
3446 count = tty->receive_room;
3447 char_buf = head->char_buf_ptr + head->read;
3448 flag_buf = head->flag_buf_ptr + head->read;
3449 head->read += count;
3450 spin_unlock_irqrestore(&tty->buf.lock, flags);
3451 disc->receive_buf(tty, char_buf, flag_buf, count);
3452 spin_lock_irqsave(&tty->buf.lock, flags);
3454 tty->buf.head = head;
3456 spin_unlock_irqrestore(&tty->buf.lock, flags);
3458 tty_ldisc_deref(disc);
3462 * Routine which returns the baud rate of the tty
3464 * Note that the baud_table needs to be kept in sync with the
3465 * include/asm/termbits.h file.
3467 static int baud_table[] = {
3468 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3469 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3471 76800, 153600, 307200, 614400, 921600
3473 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3474 2500000, 3000000, 3500000, 4000000
3478 static int n_baud_table = ARRAY_SIZE(baud_table);
3481 * tty_termios_baud_rate
3482 * @termios: termios structure
3484 * Convert termios baud rate data into a speed. This should be called
3485 * with the termios lock held if this termios is a terminal termios
3486 * structure. May change the termios data.
3491 int tty_termios_baud_rate(struct termios *termios)
3495 cbaud = termios->c_cflag & CBAUD;
3497 if (cbaud & CBAUDEX) {
3500 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3501 termios->c_cflag &= ~CBAUDEX;
3505 return baud_table[cbaud];
3508 EXPORT_SYMBOL(tty_termios_baud_rate);
3511 * tty_get_baud_rate - get tty bit rates
3512 * @tty: tty to query
3514 * Returns the baud rate as an integer for this terminal. The
3515 * termios lock must be held by the caller and the terminal bit
3516 * flags may be updated.
3521 int tty_get_baud_rate(struct tty_struct *tty)
3523 int baud = tty_termios_baud_rate(tty->termios);
3525 if (baud == 38400 && tty->alt_speed) {
3527 printk(KERN_WARNING "Use of setserial/setrocket to "
3528 "set SPD_* flags is deprecated\n");
3531 baud = tty->alt_speed;
3537 EXPORT_SYMBOL(tty_get_baud_rate);
3540 * tty_flip_buffer_push - terminal
3543 * Queue a push of the terminal flip buffers to the line discipline. This
3544 * function must not be called from IRQ context if tty->low_latency is set.
3546 * In the event of the queue being busy for flipping the work will be
3547 * held off and retried later.
3549 * Locking: tty buffer lock. Driver locks in low latency mode.
3552 void tty_flip_buffer_push(struct tty_struct *tty)
3554 unsigned long flags;
3555 spin_lock_irqsave(&tty->buf.lock, flags);
3556 if (tty->buf.tail != NULL)
3557 tty->buf.tail->commit = tty->buf.tail->used;
3558 spin_unlock_irqrestore(&tty->buf.lock, flags);
3560 if (tty->low_latency)
3561 flush_to_ldisc(&tty->buf.work.work);
3563 schedule_delayed_work(&tty->buf.work, 1);
3566 EXPORT_SYMBOL(tty_flip_buffer_push);
3570 * initialize_tty_struct
3571 * @tty: tty to initialize
3573 * This subroutine initializes a tty structure that has been newly
3576 * Locking: none - tty in question must not be exposed at this point
3579 static void initialize_tty_struct(struct tty_struct *tty)
3581 memset(tty, 0, sizeof(struct tty_struct));
3582 tty->magic = TTY_MAGIC;
3583 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3585 tty->overrun_time = jiffies;
3586 tty->buf.head = tty->buf.tail = NULL;
3587 tty_buffer_init(tty);
3588 INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
3589 init_MUTEX(&tty->buf.pty_sem);
3590 mutex_init(&tty->termios_mutex);
3591 init_waitqueue_head(&tty->write_wait);
3592 init_waitqueue_head(&tty->read_wait);
3593 INIT_WORK(&tty->hangup_work, do_tty_hangup);
3594 mutex_init(&tty->atomic_read_lock);
3595 mutex_init(&tty->atomic_write_lock);
3596 spin_lock_init(&tty->read_lock);
3597 INIT_LIST_HEAD(&tty->tty_files);
3598 INIT_WORK(&tty->SAK_work, NULL);
3602 * The default put_char routine if the driver did not define one.
3605 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3607 tty->driver->write(tty, &ch, 1);
3610 static struct class *tty_class;
3613 * tty_register_device - register a tty device
3614 * @driver: the tty driver that describes the tty device
3615 * @index: the index in the tty driver for this tty device
3616 * @device: a struct device that is associated with this tty device.
3617 * This field is optional, if there is no known struct device
3618 * for this tty device it can be set to NULL safely.
3620 * Returns a pointer to the struct device for this tty device
3621 * (or ERR_PTR(-EFOO) on error).
3623 * This call is required to be made to register an individual tty device
3624 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3625 * that bit is not set, this function should not be called by a tty
3631 struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3632 struct device *device)
3635 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3637 if (index >= driver->num) {
3638 printk(KERN_ERR "Attempt to register invalid tty line number "
3640 return ERR_PTR(-EINVAL);
3643 if (driver->type == TTY_DRIVER_TYPE_PTY)
3644 pty_line_name(driver, index, name);
3646 tty_line_name(driver, index, name);
3648 return device_create(tty_class, device, dev, name);
3652 * tty_unregister_device - unregister a tty device
3653 * @driver: the tty driver that describes the tty device
3654 * @index: the index in the tty driver for this tty device
3656 * If a tty device is registered with a call to tty_register_device() then
3657 * this function must be called when the tty device is gone.
3662 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3664 device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3667 EXPORT_SYMBOL(tty_register_device);
3668 EXPORT_SYMBOL(tty_unregister_device);
3670 struct tty_driver *alloc_tty_driver(int lines)
3672 struct tty_driver *driver;
3674 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3676 memset(driver, 0, sizeof(struct tty_driver));
3677 driver->magic = TTY_DRIVER_MAGIC;
3678 driver->num = lines;
3679 /* later we'll move allocation of tables here */
3684 void put_tty_driver(struct tty_driver *driver)
3689 void tty_set_operations(struct tty_driver *driver,
3690 const struct tty_operations *op)
3692 driver->open = op->open;
3693 driver->close = op->close;
3694 driver->write = op->write;
3695 driver->put_char = op->put_char;
3696 driver->flush_chars = op->flush_chars;
3697 driver->write_room = op->write_room;
3698 driver->chars_in_buffer = op->chars_in_buffer;
3699 driver->ioctl = op->ioctl;
3700 driver->set_termios = op->set_termios;
3701 driver->throttle = op->throttle;
3702 driver->unthrottle = op->unthrottle;
3703 driver->stop = op->stop;
3704 driver->start = op->start;
3705 driver->hangup = op->hangup;
3706 driver->break_ctl = op->break_ctl;
3707 driver->flush_buffer = op->flush_buffer;
3708 driver->set_ldisc = op->set_ldisc;
3709 driver->wait_until_sent = op->wait_until_sent;
3710 driver->send_xchar = op->send_xchar;
3711 driver->read_proc = op->read_proc;
3712 driver->write_proc = op->write_proc;
3713 driver->tiocmget = op->tiocmget;
3714 driver->tiocmset = op->tiocmset;
3718 EXPORT_SYMBOL(alloc_tty_driver);
3719 EXPORT_SYMBOL(put_tty_driver);
3720 EXPORT_SYMBOL(tty_set_operations);
3723 * Called by a tty driver to register itself.
3725 int tty_register_driver(struct tty_driver *driver)
3732 if (driver->flags & TTY_DRIVER_INSTALLED)
3735 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3736 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3739 memset(p, 0, driver->num * 3 * sizeof(void *));
3742 if (!driver->major) {
3743 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3744 (char*)driver->name);
3746 driver->major = MAJOR(dev);
3747 driver->minor_start = MINOR(dev);
3750 dev = MKDEV(driver->major, driver->minor_start);
3751 error = register_chrdev_region(dev, driver->num,
3752 (char*)driver->name);
3760 driver->ttys = (struct tty_struct **)p;
3761 driver->termios = (struct termios **)(p + driver->num);
3762 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3764 driver->ttys = NULL;
3765 driver->termios = NULL;
3766 driver->termios_locked = NULL;
3769 cdev_init(&driver->cdev, &tty_fops);
3770 driver->cdev.owner = driver->owner;
3771 error = cdev_add(&driver->cdev, dev, driver->num);
3773 unregister_chrdev_region(dev, driver->num);
3774 driver->ttys = NULL;
3775 driver->termios = driver->termios_locked = NULL;
3780 if (!driver->put_char)
3781 driver->put_char = tty_default_put_char;
3783 list_add(&driver->tty_drivers, &tty_drivers);
3785 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3786 for(i = 0; i < driver->num; i++)
3787 tty_register_device(driver, i, NULL);
3789 proc_tty_register_driver(driver);
3793 EXPORT_SYMBOL(tty_register_driver);
3796 * Called by a tty driver to unregister itself.
3798 int tty_unregister_driver(struct tty_driver *driver)
3804 if (driver->refcount)
3807 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3810 list_del(&driver->tty_drivers);
3813 * Free the termios and termios_locked structures because
3814 * we don't want to get memory leaks when modular tty
3815 * drivers are removed from the kernel.
3817 for (i = 0; i < driver->num; i++) {
3818 tp = driver->termios[i];
3820 driver->termios[i] = NULL;
3823 tp = driver->termios_locked[i];
3825 driver->termios_locked[i] = NULL;
3828 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3829 tty_unregister_device(driver, i);
3832 proc_tty_unregister_driver(driver);
3833 driver->ttys = NULL;
3834 driver->termios = driver->termios_locked = NULL;
3836 cdev_del(&driver->cdev);
3839 EXPORT_SYMBOL(tty_unregister_driver);
3841 dev_t tty_devnum(struct tty_struct *tty)
3843 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3845 EXPORT_SYMBOL(tty_devnum);
3847 void proc_clear_tty(struct task_struct *p)
3849 spin_lock_irq(&p->sighand->siglock);
3850 p->signal->tty = NULL;
3851 spin_unlock_irq(&p->sighand->siglock);
3853 EXPORT_SYMBOL(proc_clear_tty);
3855 void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3858 tty->session = tsk->signal->session;
3859 tty->pgrp = process_group(tsk);
3861 tsk->signal->tty = tty;
3862 tsk->signal->tty_old_pgrp = 0;
3865 void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3867 spin_lock_irq(&tsk->sighand->siglock);
3868 __proc_set_tty(tsk, tty);
3869 spin_unlock_irq(&tsk->sighand->siglock);
3872 struct tty_struct *get_current_tty(void)
3874 struct tty_struct *tty;
3875 WARN_ON_ONCE(!mutex_is_locked(&tty_mutex));
3876 tty = current->signal->tty;
3878 * session->tty can be changed/cleared from under us, make sure we
3879 * issue the load. The obtained pointer, when not NULL, is valid as
3880 * long as we hold tty_mutex.
3887 * Initialize the console device. This is called *early*, so
3888 * we can't necessarily depend on lots of kernel help here.
3889 * Just do some early initializations, and do the complex setup
3892 void __init console_init(void)
3896 /* Setup the default TTY line discipline. */
3897 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3900 * set up the console device so that later boot sequences can
3901 * inform about problems etc..
3903 #ifdef CONFIG_EARLY_PRINTK
3904 disable_early_printk();
3906 call = __con_initcall_start;
3907 while (call < __con_initcall_end) {
3914 extern int vty_init(void);
3917 static int __init tty_class_init(void)
3919 tty_class = class_create(THIS_MODULE, "tty");
3920 if (IS_ERR(tty_class))
3921 return PTR_ERR(tty_class);
3925 postcore_initcall(tty_class_init);
3927 /* 3/2004 jmc: why do these devices exist? */
3929 static struct cdev tty_cdev, console_cdev;
3930 #ifdef CONFIG_UNIX98_PTYS
3931 static struct cdev ptmx_cdev;
3934 static struct cdev vc0_cdev;
3938 * Ok, now we can initialize the rest of the tty devices and can count
3939 * on memory allocations, interrupts etc..
3941 static int __init tty_init(void)
3943 cdev_init(&tty_cdev, &tty_fops);
3944 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3945 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3946 panic("Couldn't register /dev/tty driver\n");
3947 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
3949 cdev_init(&console_cdev, &console_fops);
3950 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3951 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3952 panic("Couldn't register /dev/console driver\n");
3953 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
3955 #ifdef CONFIG_UNIX98_PTYS
3956 cdev_init(&ptmx_cdev, &ptmx_fops);
3957 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3958 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3959 panic("Couldn't register /dev/ptmx driver\n");
3960 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
3964 cdev_init(&vc0_cdev, &console_fops);
3965 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3966 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3967 panic("Couldn't register /dev/tty0 driver\n");
3968 device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
3974 module_init(tty_init);