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/config.h>
69 #include <linux/types.h>
70 #include <linux/major.h>
71 #include <linux/errno.h>
72 #include <linux/signal.h>
73 #include <linux/fcntl.h>
74 #include <linux/sched.h>
75 #include <linux/interrupt.h>
76 #include <linux/tty.h>
77 #include <linux/tty_driver.h>
78 #include <linux/tty_flip.h>
79 #include <linux/devpts_fs.h>
80 #include <linux/file.h>
81 #include <linux/console.h>
82 #include <linux/timer.h>
83 #include <linux/ctype.h>
86 #include <linux/string.h>
87 #include <linux/slab.h>
88 #include <linux/poll.h>
89 #include <linux/proc_fs.h>
90 #include <linux/init.h>
91 #include <linux/module.h>
92 #include <linux/smp_lock.h>
93 #include <linux/device.h>
94 #include <linux/idr.h>
95 #include <linux/wait.h>
96 #include <linux/bitops.h>
97 #include <linux/delay.h>
99 #include <asm/uaccess.h>
100 #include <asm/system.h>
102 #include <linux/kbd_kern.h>
103 #include <linux/vt_kern.h>
104 #include <linux/selection.h>
105 #include <linux/devfs_fs_kernel.h>
107 #include <linux/kmod.h>
109 #undef TTY_DEBUG_HANGUP
111 #define TTY_PARANOIA_CHECK 1
112 #define CHECK_TTY_COUNT 1
114 struct termios tty_std_termios
= { /* for the benefit of tty drivers */
115 .c_iflag
= ICRNL
| IXON
,
116 .c_oflag
= OPOST
| ONLCR
,
117 .c_cflag
= B38400
| CS8
| CREAD
| HUPCL
,
118 .c_lflag
= ISIG
| ICANON
| ECHO
| ECHOE
| ECHOK
|
119 ECHOCTL
| ECHOKE
| IEXTEN
,
123 EXPORT_SYMBOL(tty_std_termios
);
125 /* This list gets poked at by procfs and various bits of boot up code. This
126 could do with some rationalisation such as pulling the tty proc function
129 LIST_HEAD(tty_drivers
); /* linked list of tty drivers */
131 /* Semaphore to protect creating and releasing a tty. This is shared with
132 vt.c for deeply disgusting hack reasons */
133 DECLARE_MUTEX(tty_sem
);
135 #ifdef CONFIG_UNIX98_PTYS
136 extern struct tty_driver
*ptm_driver
; /* Unix98 pty masters; for /dev/ptmx */
137 extern int pty_limit
; /* Config limit on Unix98 ptys */
138 static DEFINE_IDR(allocated_ptys
);
139 static DECLARE_MUTEX(allocated_ptys_lock
);
140 static int ptmx_open(struct inode
*, struct file
*);
143 extern void disable_early_printk(void);
145 static void initialize_tty_struct(struct tty_struct
*tty
);
147 static ssize_t
tty_read(struct file
*, char __user
*, size_t, loff_t
*);
148 static ssize_t
tty_write(struct file
*, const char __user
*, size_t, loff_t
*);
149 ssize_t
redirected_tty_write(struct file
*, const char __user
*, size_t, loff_t
*);
150 static unsigned int tty_poll(struct file
*, poll_table
*);
151 static int tty_open(struct inode
*, struct file
*);
152 static int tty_release(struct inode
*, struct file
*);
153 int tty_ioctl(struct inode
* inode
, struct file
* file
,
154 unsigned int cmd
, unsigned long arg
);
155 static int tty_fasync(int fd
, struct file
* filp
, int on
);
156 static void release_mem(struct tty_struct
*tty
, int idx
);
159 static struct tty_struct
*alloc_tty_struct(void)
161 struct tty_struct
*tty
;
163 tty
= kmalloc(sizeof(struct tty_struct
), GFP_KERNEL
);
165 memset(tty
, 0, sizeof(struct tty_struct
));
169 static void tty_buffer_free_all(struct tty_struct
*);
171 static inline void free_tty_struct(struct tty_struct
*tty
)
173 kfree(tty
->write_buf
);
174 tty_buffer_free_all(tty
);
178 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
180 char *tty_name(struct tty_struct
*tty
, char *buf
)
182 if (!tty
) /* Hmm. NULL pointer. That's fun. */
183 strcpy(buf
, "NULL tty");
185 strcpy(buf
, tty
->name
);
189 EXPORT_SYMBOL(tty_name
);
191 int tty_paranoia_check(struct tty_struct
*tty
, struct inode
*inode
,
194 #ifdef TTY_PARANOIA_CHECK
197 "null TTY for (%d:%d) in %s\n",
198 imajor(inode
), iminor(inode
), routine
);
201 if (tty
->magic
!= TTY_MAGIC
) {
203 "bad magic number for tty struct (%d:%d) in %s\n",
204 imajor(inode
), iminor(inode
), routine
);
211 static int check_tty_count(struct tty_struct
*tty
, const char *routine
)
213 #ifdef CHECK_TTY_COUNT
218 list_for_each(p
, &tty
->tty_files
) {
222 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
223 tty
->driver
->subtype
== PTY_TYPE_SLAVE
&&
224 tty
->link
&& tty
->link
->count
)
226 if (tty
->count
!= count
) {
227 printk(KERN_WARNING
"Warning: dev (%s) tty->count(%d) "
228 "!= #fd's(%d) in %s\n",
229 tty
->name
, tty
->count
, count
, routine
);
237 * Tty buffer allocation management
240 static void tty_buffer_free_all(struct tty_struct
*tty
)
242 struct tty_buffer
*thead
;
243 while((thead
= tty
->buf
.head
) != NULL
) {
244 tty
->buf
.head
= thead
->next
;
247 while((thead
= tty
->buf
.free
) != NULL
) {
248 tty
->buf
.free
= thead
->next
;
251 tty
->buf
.tail
= NULL
;
254 static void tty_buffer_init(struct tty_struct
*tty
)
256 spin_lock_init(&tty
->buf
.lock
);
257 tty
->buf
.head
= NULL
;
258 tty
->buf
.tail
= NULL
;
259 tty
->buf
.free
= NULL
;
262 static struct tty_buffer
*tty_buffer_alloc(size_t size
)
264 struct tty_buffer
*p
= kmalloc(sizeof(struct tty_buffer
) + 2 * size
, GFP_ATOMIC
);
273 p
->char_buf_ptr
= (char *)(p
->data
);
274 p
->flag_buf_ptr
= (unsigned char *)p
->char_buf_ptr
+ size
;
275 /* printk("Flip create %p\n", p); */
279 /* Must be called with the tty_read lock held. This needs to acquire strategy
280 code to decide if we should kfree or relink a given expired buffer */
282 static void tty_buffer_free(struct tty_struct
*tty
, struct tty_buffer
*b
)
284 /* Dumb strategy for now - should keep some stats */
285 /* printk("Flip dispose %p\n", b); */
289 b
->next
= tty
->buf
.free
;
294 static struct tty_buffer
*tty_buffer_find(struct tty_struct
*tty
, size_t size
)
296 struct tty_buffer
**tbh
= &tty
->buf
.free
;
297 while((*tbh
) != NULL
) {
298 struct tty_buffer
*t
= *tbh
;
299 if(t
->size
>= size
) {
306 memset(t
->data
, '*', size
);
307 /* printk("Flip recycle %p\n", t); */
310 tbh
= &((*tbh
)->next
);
312 /* Round the buffer size out */
313 size
= (size
+ 0xFF) & ~ 0xFF;
314 return tty_buffer_alloc(size
);
315 /* Should possibly check if this fails for the largest buffer we
316 have queued and recycle that ? */
319 int tty_buffer_request_room(struct tty_struct
*tty
, size_t size
)
321 struct tty_buffer
*b
, *n
;
325 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
327 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
328 remove this conditional if its worth it. This would be invisible
330 if ((b
= tty
->buf
.tail
) != NULL
) {
331 left
= b
->size
- b
->used
;
337 /* This is the slow path - looking for new buffers to use */
338 if ((n
= tty_buffer_find(tty
, size
)) != NULL
) {
351 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
355 EXPORT_SYMBOL_GPL(tty_buffer_request_room
);
357 int tty_insert_flip_string(struct tty_struct
*tty
, unsigned char *chars
, size_t size
)
361 int space
= tty_buffer_request_room(tty
, size
- copied
);
362 struct tty_buffer
*tb
= tty
->buf
.tail
;
363 /* If there is no space then tb may be NULL */
364 if(unlikely(space
== 0))
366 memcpy(tb
->char_buf_ptr
+ tb
->used
, chars
, space
);
367 memset(tb
->flag_buf_ptr
+ tb
->used
, TTY_NORMAL
, space
);
371 /* printk("Flip insert %d.\n", space); */
373 /* There is a small chance that we need to split the data over
374 several buffers. If this is the case we must loop */
375 while (unlikely(size
> copied
));
379 EXPORT_SYMBOL_GPL(tty_insert_flip_string
);
381 int tty_insert_flip_string_flags(struct tty_struct
*tty
, unsigned char *chars
, char *flags
, size_t size
)
385 int space
= tty_buffer_request_room(tty
, size
- copied
);
386 struct tty_buffer
*tb
= tty
->buf
.tail
;
387 /* If there is no space then tb may be NULL */
388 if(unlikely(space
== 0))
390 memcpy(tb
->char_buf_ptr
+ tb
->used
, chars
, space
);
391 memcpy(tb
->flag_buf_ptr
+ tb
->used
, flags
, space
);
397 /* There is a small chance that we need to split the data over
398 several buffers. If this is the case we must loop */
399 while (unlikely(size
> copied
));
403 EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags
);
407 * Prepare a block of space in the buffer for data. Returns the length
408 * available and buffer pointer to the space which is now allocated and
409 * accounted for as ready for normal characters. This is used for drivers
410 * that need their own block copy routines into the buffer. There is no
411 * guarantee the buffer is a DMA target!
414 int tty_prepare_flip_string(struct tty_struct
*tty
, unsigned char **chars
, size_t size
)
416 int space
= tty_buffer_request_room(tty
, size
);
418 struct tty_buffer
*tb
= tty
->buf
.tail
;
419 *chars
= tb
->char_buf_ptr
+ tb
->used
;
420 memset(tb
->flag_buf_ptr
+ tb
->used
, TTY_NORMAL
, space
);
426 EXPORT_SYMBOL_GPL(tty_prepare_flip_string
);
429 * Prepare a block of space in the buffer for data. Returns the length
430 * available and buffer pointer to the space which is now allocated and
431 * accounted for as ready for characters. This is used for drivers
432 * that need their own block copy routines into the buffer. There is no
433 * guarantee the buffer is a DMA target!
436 int tty_prepare_flip_string_flags(struct tty_struct
*tty
, unsigned char **chars
, char **flags
, size_t size
)
438 int space
= tty_buffer_request_room(tty
, size
);
440 struct tty_buffer
*tb
= tty
->buf
.tail
;
441 *chars
= tb
->char_buf_ptr
+ tb
->used
;
442 *flags
= tb
->flag_buf_ptr
+ tb
->used
;
448 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags
);
453 * This is probably overkill for real world processors but
454 * they are not on hot paths so a little discipline won't do
458 static void tty_set_termios_ldisc(struct tty_struct
*tty
, int num
)
460 down(&tty
->termios_sem
);
461 tty
->termios
->c_line
= num
;
462 up(&tty
->termios_sem
);
466 * This guards the refcounted line discipline lists. The lock
467 * must be taken with irqs off because there are hangup path
468 * callers who will do ldisc lookups and cannot sleep.
471 static DEFINE_SPINLOCK(tty_ldisc_lock
);
472 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait
);
473 static struct tty_ldisc tty_ldiscs
[NR_LDISCS
]; /* line disc dispatch table */
475 int tty_register_ldisc(int disc
, struct tty_ldisc
*new_ldisc
)
480 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
483 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
484 tty_ldiscs
[disc
] = *new_ldisc
;
485 tty_ldiscs
[disc
].num
= disc
;
486 tty_ldiscs
[disc
].flags
|= LDISC_FLAG_DEFINED
;
487 tty_ldiscs
[disc
].refcount
= 0;
488 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
492 EXPORT_SYMBOL(tty_register_ldisc
);
494 int tty_unregister_ldisc(int disc
)
499 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
502 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
503 if (tty_ldiscs
[disc
].refcount
)
506 tty_ldiscs
[disc
].flags
&= ~LDISC_FLAG_DEFINED
;
507 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
511 EXPORT_SYMBOL(tty_unregister_ldisc
);
513 struct tty_ldisc
*tty_ldisc_get(int disc
)
516 struct tty_ldisc
*ld
;
518 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
521 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
523 ld
= &tty_ldiscs
[disc
];
524 /* Check the entry is defined */
525 if(ld
->flags
& LDISC_FLAG_DEFINED
)
527 /* If the module is being unloaded we can't use it */
528 if (!try_module_get(ld
->owner
))
535 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
539 EXPORT_SYMBOL_GPL(tty_ldisc_get
);
541 void tty_ldisc_put(int disc
)
543 struct tty_ldisc
*ld
;
546 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
549 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
550 ld
= &tty_ldiscs
[disc
];
551 if(ld
->refcount
== 0)
554 module_put(ld
->owner
);
555 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
558 EXPORT_SYMBOL_GPL(tty_ldisc_put
);
560 static void tty_ldisc_assign(struct tty_struct
*tty
, struct tty_ldisc
*ld
)
563 tty
->ldisc
.refcount
= 0;
567 * tty_ldisc_try - internal helper
570 * Make a single attempt to grab and bump the refcount on
571 * the tty ldisc. Return 0 on failure or 1 on success. This is
572 * used to implement both the waiting and non waiting versions
576 static int tty_ldisc_try(struct tty_struct
*tty
)
579 struct tty_ldisc
*ld
;
582 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
584 if(test_bit(TTY_LDISC
, &tty
->flags
))
589 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
594 * tty_ldisc_ref_wait - wait for the tty ldisc
597 * Dereference the line discipline for the terminal and take a
598 * reference to it. If the line discipline is in flux then
599 * wait patiently until it changes.
601 * Note: Must not be called from an IRQ/timer context. The caller
602 * must also be careful not to hold other locks that will deadlock
603 * against a discipline change, such as an existing ldisc reference
604 * (which we check for)
607 struct tty_ldisc
*tty_ldisc_ref_wait(struct tty_struct
*tty
)
609 /* wait_event is a macro */
610 wait_event(tty_ldisc_wait
, tty_ldisc_try(tty
));
611 if(tty
->ldisc
.refcount
== 0)
612 printk(KERN_ERR
"tty_ldisc_ref_wait\n");
616 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait
);
619 * tty_ldisc_ref - get the tty ldisc
622 * Dereference the line discipline for the terminal and take a
623 * reference to it. If the line discipline is in flux then
624 * return NULL. Can be called from IRQ and timer functions.
627 struct tty_ldisc
*tty_ldisc_ref(struct tty_struct
*tty
)
629 if(tty_ldisc_try(tty
))
634 EXPORT_SYMBOL_GPL(tty_ldisc_ref
);
637 * tty_ldisc_deref - free a tty ldisc reference
638 * @ld: reference to free up
640 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
641 * be called in IRQ context.
644 void tty_ldisc_deref(struct tty_ldisc
*ld
)
651 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
652 if(ld
->refcount
== 0)
653 printk(KERN_ERR
"tty_ldisc_deref: no references.\n");
656 if(ld
->refcount
== 0)
657 wake_up(&tty_ldisc_wait
);
658 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
661 EXPORT_SYMBOL_GPL(tty_ldisc_deref
);
664 * tty_ldisc_enable - allow ldisc use
665 * @tty: terminal to activate ldisc on
667 * Set the TTY_LDISC flag when the line discipline can be called
668 * again. Do neccessary wakeups for existing sleepers.
670 * Note: nobody should set this bit except via this function. Clearing
671 * directly is allowed.
674 static void tty_ldisc_enable(struct tty_struct
*tty
)
676 set_bit(TTY_LDISC
, &tty
->flags
);
677 wake_up(&tty_ldisc_wait
);
681 * tty_set_ldisc - set line discipline
682 * @tty: the terminal to set
683 * @ldisc: the line discipline
685 * Set the discipline of a tty line. Must be called from a process
689 static int tty_set_ldisc(struct tty_struct
*tty
, int ldisc
)
692 struct tty_ldisc o_ldisc
;
696 struct tty_ldisc
*ld
;
697 struct tty_struct
*o_tty
;
699 if ((ldisc
< N_TTY
) || (ldisc
>= NR_LDISCS
))
704 ld
= tty_ldisc_get(ldisc
);
705 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
706 /* Cyrus Durgin <cider@speakeasy.org> */
708 request_module("tty-ldisc-%d", ldisc
);
709 ld
= tty_ldisc_get(ldisc
);
715 * No more input please, we are switching. The new ldisc
716 * will update this value in the ldisc open function
719 tty
->receive_room
= 0;
722 * Problem: What do we do if this blocks ?
725 tty_wait_until_sent(tty
, 0);
727 if (tty
->ldisc
.num
== ldisc
) {
728 tty_ldisc_put(ldisc
);
732 o_ldisc
= tty
->ldisc
;
736 * Make sure we don't change while someone holds a
737 * reference to the line discipline. The TTY_LDISC bit
738 * prevents anyone taking a reference once it is clear.
739 * We need the lock to avoid racing reference takers.
742 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
743 if (tty
->ldisc
.refcount
|| (o_tty
&& o_tty
->ldisc
.refcount
)) {
744 if(tty
->ldisc
.refcount
) {
745 /* Free the new ldisc we grabbed. Must drop the lock
747 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
748 tty_ldisc_put(ldisc
);
750 * There are several reasons we may be busy, including
751 * random momentary I/O traffic. We must therefore
752 * retry. We could distinguish between blocking ops
753 * and retries if we made tty_ldisc_wait() smarter. That
754 * is up for discussion.
756 if (wait_event_interruptible(tty_ldisc_wait
, tty
->ldisc
.refcount
== 0) < 0)
760 if(o_tty
&& o_tty
->ldisc
.refcount
) {
761 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
762 tty_ldisc_put(ldisc
);
763 if (wait_event_interruptible(tty_ldisc_wait
, o_tty
->ldisc
.refcount
== 0) < 0)
769 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
771 if (!test_bit(TTY_LDISC
, &tty
->flags
)) {
772 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
773 tty_ldisc_put(ldisc
);
774 ld
= tty_ldisc_ref_wait(tty
);
779 clear_bit(TTY_LDISC
, &tty
->flags
);
780 clear_bit(TTY_DONT_FLIP
, &tty
->flags
);
782 clear_bit(TTY_LDISC
, &o_tty
->flags
);
783 clear_bit(TTY_DONT_FLIP
, &o_tty
->flags
);
785 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
788 * From this point on we know nobody has an ldisc
789 * usage reference, nor can they obtain one until
790 * we say so later on.
793 work
= cancel_delayed_work(&tty
->buf
.work
);
795 * Wait for ->hangup_work and ->buf.work handlers to terminate
798 flush_scheduled_work();
799 /* Shutdown the current discipline. */
800 if (tty
->ldisc
.close
)
801 (tty
->ldisc
.close
)(tty
);
803 /* Now set up the new line discipline. */
804 tty_ldisc_assign(tty
, ld
);
805 tty_set_termios_ldisc(tty
, ldisc
);
807 retval
= (tty
->ldisc
.open
)(tty
);
809 tty_ldisc_put(ldisc
);
810 /* There is an outstanding reference here so this is safe */
811 tty_ldisc_assign(tty
, tty_ldisc_get(o_ldisc
.num
));
812 tty_set_termios_ldisc(tty
, tty
->ldisc
.num
);
813 if (tty
->ldisc
.open
&& (tty
->ldisc
.open(tty
) < 0)) {
814 tty_ldisc_put(o_ldisc
.num
);
815 /* This driver is always present */
816 tty_ldisc_assign(tty
, tty_ldisc_get(N_TTY
));
817 tty_set_termios_ldisc(tty
, N_TTY
);
818 if (tty
->ldisc
.open
) {
819 int r
= tty
->ldisc
.open(tty
);
822 panic("Couldn't open N_TTY ldisc for "
824 tty_name(tty
, buf
), r
);
828 /* At this point we hold a reference to the new ldisc and a
829 a reference to the old ldisc. If we ended up flipping back
830 to the existing ldisc we have two references to it */
832 if (tty
->ldisc
.num
!= o_ldisc
.num
&& tty
->driver
->set_ldisc
)
833 tty
->driver
->set_ldisc(tty
);
835 tty_ldisc_put(o_ldisc
.num
);
838 * Allow ldisc referencing to occur as soon as the driver
839 * ldisc callback completes.
842 tty_ldisc_enable(tty
);
844 tty_ldisc_enable(o_tty
);
846 /* Restart it in case no characters kick it off. Safe if
849 schedule_delayed_work(&tty
->buf
.work
, 1);
854 * This routine returns a tty driver structure, given a device number
856 static struct tty_driver
*get_tty_driver(dev_t device
, int *index
)
858 struct tty_driver
*p
;
860 list_for_each_entry(p
, &tty_drivers
, tty_drivers
) {
861 dev_t base
= MKDEV(p
->major
, p
->minor_start
);
862 if (device
< base
|| device
>= base
+ p
->num
)
864 *index
= device
- base
;
871 * If we try to write to, or set the state of, a terminal and we're
872 * not in the foreground, send a SIGTTOU. If the signal is blocked or
873 * ignored, go ahead and perform the operation. (POSIX 7.2)
875 int tty_check_change(struct tty_struct
* tty
)
877 if (current
->signal
->tty
!= tty
)
879 if (tty
->pgrp
<= 0) {
880 printk(KERN_WARNING
"tty_check_change: tty->pgrp <= 0!\n");
883 if (process_group(current
) == tty
->pgrp
)
885 if (is_ignored(SIGTTOU
))
887 if (is_orphaned_pgrp(process_group(current
)))
889 (void) kill_pg(process_group(current
), SIGTTOU
, 1);
893 EXPORT_SYMBOL(tty_check_change
);
895 static ssize_t
hung_up_tty_read(struct file
* file
, char __user
* buf
,
896 size_t count
, loff_t
*ppos
)
901 static ssize_t
hung_up_tty_write(struct file
* file
, const char __user
* buf
,
902 size_t count
, loff_t
*ppos
)
907 /* No kernel lock held - none needed ;) */
908 static unsigned int hung_up_tty_poll(struct file
* filp
, poll_table
* wait
)
910 return POLLIN
| POLLOUT
| POLLERR
| POLLHUP
| POLLRDNORM
| POLLWRNORM
;
913 static int hung_up_tty_ioctl(struct inode
* inode
, struct file
* file
,
914 unsigned int cmd
, unsigned long arg
)
916 return cmd
== TIOCSPGRP
? -ENOTTY
: -EIO
;
919 static struct file_operations tty_fops
= {
926 .release
= tty_release
,
927 .fasync
= tty_fasync
,
930 #ifdef CONFIG_UNIX98_PTYS
931 static struct file_operations ptmx_fops
= {
938 .release
= tty_release
,
939 .fasync
= tty_fasync
,
943 static struct file_operations console_fops
= {
946 .write
= redirected_tty_write
,
950 .release
= tty_release
,
951 .fasync
= tty_fasync
,
954 static struct file_operations hung_up_tty_fops
= {
956 .read
= hung_up_tty_read
,
957 .write
= hung_up_tty_write
,
958 .poll
= hung_up_tty_poll
,
959 .ioctl
= hung_up_tty_ioctl
,
960 .release
= tty_release
,
963 static DEFINE_SPINLOCK(redirect_lock
);
964 static struct file
*redirect
;
967 * tty_wakeup - request more data
970 * Internal and external helper for wakeups of tty. This function
971 * informs the line discipline if present that the driver is ready
972 * to receive more output data.
975 void tty_wakeup(struct tty_struct
*tty
)
977 struct tty_ldisc
*ld
;
979 if (test_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
)) {
980 ld
= tty_ldisc_ref(tty
);
983 ld
->write_wakeup(tty
);
987 wake_up_interruptible(&tty
->write_wait
);
990 EXPORT_SYMBOL_GPL(tty_wakeup
);
993 * tty_ldisc_flush - flush line discipline queue
996 * Flush the line discipline queue (if any) for this tty. If there
997 * is no line discipline active this is a no-op.
1000 void tty_ldisc_flush(struct tty_struct
*tty
)
1002 struct tty_ldisc
*ld
= tty_ldisc_ref(tty
);
1004 if(ld
->flush_buffer
)
1005 ld
->flush_buffer(tty
);
1006 tty_ldisc_deref(ld
);
1010 EXPORT_SYMBOL_GPL(tty_ldisc_flush
);
1013 * This can be called by the "eventd" kernel thread. That is process synchronous,
1014 * but doesn't hold any locks, so we need to make sure we have the appropriate
1015 * locks for what we're doing..
1017 static void do_tty_hangup(void *data
)
1019 struct tty_struct
*tty
= (struct tty_struct
*) data
;
1020 struct file
* cons_filp
= NULL
;
1021 struct file
*filp
, *f
= NULL
;
1022 struct task_struct
*p
;
1023 struct tty_ldisc
*ld
;
1024 int closecount
= 0, n
;
1029 /* inuse_filps is protected by the single kernel lock */
1032 spin_lock(&redirect_lock
);
1033 if (redirect
&& redirect
->private_data
== tty
) {
1037 spin_unlock(&redirect_lock
);
1039 check_tty_count(tty
, "do_tty_hangup");
1041 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1042 list_for_each_entry(filp
, &tty
->tty_files
, f_u
.fu_list
) {
1043 if (filp
->f_op
->write
== redirected_tty_write
)
1045 if (filp
->f_op
->write
!= tty_write
)
1048 tty_fasync(-1, filp
, 0); /* can't block */
1049 filp
->f_op
= &hung_up_tty_fops
;
1053 /* FIXME! What are the locking issues here? This may me overdoing things..
1054 * this question is especially important now that we've removed the irqlock. */
1056 ld
= tty_ldisc_ref(tty
);
1057 if(ld
!= NULL
) /* We may have no line discipline at this point */
1059 if (ld
->flush_buffer
)
1060 ld
->flush_buffer(tty
);
1061 if (tty
->driver
->flush_buffer
)
1062 tty
->driver
->flush_buffer(tty
);
1063 if ((test_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
)) &&
1065 ld
->write_wakeup(tty
);
1070 /* FIXME: Once we trust the LDISC code better we can wait here for
1071 ldisc completion and fix the driver call race */
1073 wake_up_interruptible(&tty
->write_wait
);
1074 wake_up_interruptible(&tty
->read_wait
);
1077 * Shutdown the current line discipline, and reset it to
1080 if (tty
->driver
->flags
& TTY_DRIVER_RESET_TERMIOS
)
1082 down(&tty
->termios_sem
);
1083 *tty
->termios
= tty
->driver
->init_termios
;
1084 up(&tty
->termios_sem
);
1087 /* Defer ldisc switch */
1088 /* tty_deferred_ldisc_switch(N_TTY);
1090 This should get done automatically when the port closes and
1091 tty_release is called */
1093 read_lock(&tasklist_lock
);
1094 if (tty
->session
> 0) {
1095 do_each_task_pid(tty
->session
, PIDTYPE_SID
, p
) {
1096 if (p
->signal
->tty
== tty
)
1097 p
->signal
->tty
= NULL
;
1098 if (!p
->signal
->leader
)
1100 send_group_sig_info(SIGHUP
, SEND_SIG_PRIV
, p
);
1101 send_group_sig_info(SIGCONT
, SEND_SIG_PRIV
, p
);
1103 p
->signal
->tty_old_pgrp
= tty
->pgrp
;
1104 } while_each_task_pid(tty
->session
, PIDTYPE_SID
, p
);
1106 read_unlock(&tasklist_lock
);
1111 tty
->ctrl_status
= 0;
1113 * If one of the devices matches a console pointer, we
1114 * cannot just call hangup() because that will cause
1115 * tty->count and state->count to go out of sync.
1116 * So we just call close() the right number of times.
1119 if (tty
->driver
->close
)
1120 for (n
= 0; n
< closecount
; n
++)
1121 tty
->driver
->close(tty
, cons_filp
);
1122 } else if (tty
->driver
->hangup
)
1123 (tty
->driver
->hangup
)(tty
);
1125 /* We don't want to have driver/ldisc interactions beyond
1126 the ones we did here. The driver layer expects no
1127 calls after ->hangup() from the ldisc side. However we
1128 can't yet guarantee all that */
1130 set_bit(TTY_HUPPED
, &tty
->flags
);
1132 tty_ldisc_enable(tty
);
1133 tty_ldisc_deref(ld
);
1140 void tty_hangup(struct tty_struct
* tty
)
1142 #ifdef TTY_DEBUG_HANGUP
1145 printk(KERN_DEBUG
"%s hangup...\n", tty_name(tty
, buf
));
1147 schedule_work(&tty
->hangup_work
);
1150 EXPORT_SYMBOL(tty_hangup
);
1152 void tty_vhangup(struct tty_struct
* tty
)
1154 #ifdef TTY_DEBUG_HANGUP
1157 printk(KERN_DEBUG
"%s vhangup...\n", tty_name(tty
, buf
));
1159 do_tty_hangup((void *) tty
);
1161 EXPORT_SYMBOL(tty_vhangup
);
1163 int tty_hung_up_p(struct file
* filp
)
1165 return (filp
->f_op
== &hung_up_tty_fops
);
1168 EXPORT_SYMBOL(tty_hung_up_p
);
1171 * This function is typically called only by the session leader, when
1172 * it wants to disassociate itself from its controlling tty.
1174 * It performs the following functions:
1175 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1176 * (2) Clears the tty from being controlling the session
1177 * (3) Clears the controlling tty for all processes in the
1180 * The argument on_exit is set to 1 if called when a process is
1181 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1183 void disassociate_ctty(int on_exit
)
1185 struct tty_struct
*tty
;
1186 struct task_struct
*p
;
1192 tty
= current
->signal
->tty
;
1194 tty_pgrp
= tty
->pgrp
;
1196 if (on_exit
&& tty
->driver
->type
!= TTY_DRIVER_TYPE_PTY
)
1199 if (current
->signal
->tty_old_pgrp
) {
1200 kill_pg(current
->signal
->tty_old_pgrp
, SIGHUP
, on_exit
);
1201 kill_pg(current
->signal
->tty_old_pgrp
, SIGCONT
, on_exit
);
1208 kill_pg(tty_pgrp
, SIGHUP
, on_exit
);
1210 kill_pg(tty_pgrp
, SIGCONT
, on_exit
);
1213 /* Must lock changes to tty_old_pgrp */
1215 current
->signal
->tty_old_pgrp
= 0;
1219 /* Now clear signal->tty under the lock */
1220 read_lock(&tasklist_lock
);
1221 do_each_task_pid(current
->signal
->session
, PIDTYPE_SID
, p
) {
1222 p
->signal
->tty
= NULL
;
1223 } while_each_task_pid(current
->signal
->session
, PIDTYPE_SID
, p
);
1224 read_unlock(&tasklist_lock
);
1229 void stop_tty(struct tty_struct
*tty
)
1234 if (tty
->link
&& tty
->link
->packet
) {
1235 tty
->ctrl_status
&= ~TIOCPKT_START
;
1236 tty
->ctrl_status
|= TIOCPKT_STOP
;
1237 wake_up_interruptible(&tty
->link
->read_wait
);
1239 if (tty
->driver
->stop
)
1240 (tty
->driver
->stop
)(tty
);
1243 EXPORT_SYMBOL(stop_tty
);
1245 void start_tty(struct tty_struct
*tty
)
1247 if (!tty
->stopped
|| tty
->flow_stopped
)
1250 if (tty
->link
&& tty
->link
->packet
) {
1251 tty
->ctrl_status
&= ~TIOCPKT_STOP
;
1252 tty
->ctrl_status
|= TIOCPKT_START
;
1253 wake_up_interruptible(&tty
->link
->read_wait
);
1255 if (tty
->driver
->start
)
1256 (tty
->driver
->start
)(tty
);
1258 /* If we have a running line discipline it may need kicking */
1260 wake_up_interruptible(&tty
->write_wait
);
1263 EXPORT_SYMBOL(start_tty
);
1265 static ssize_t
tty_read(struct file
* file
, char __user
* buf
, size_t count
,
1269 struct tty_struct
* tty
;
1270 struct inode
*inode
;
1271 struct tty_ldisc
*ld
;
1273 tty
= (struct tty_struct
*)file
->private_data
;
1274 inode
= file
->f_dentry
->d_inode
;
1275 if (tty_paranoia_check(tty
, inode
, "tty_read"))
1277 if (!tty
|| (test_bit(TTY_IO_ERROR
, &tty
->flags
)))
1280 /* We want to wait for the line discipline to sort out in this
1282 ld
= tty_ldisc_ref_wait(tty
);
1285 i
= (ld
->read
)(tty
,file
,buf
,count
);
1288 tty_ldisc_deref(ld
);
1291 inode
->i_atime
= current_fs_time(inode
->i_sb
);
1296 * Split writes up in sane blocksizes to avoid
1297 * denial-of-service type attacks
1299 static inline ssize_t
do_tty_write(
1300 ssize_t (*write
)(struct tty_struct
*, struct file
*, const unsigned char *, size_t),
1301 struct tty_struct
*tty
,
1303 const char __user
*buf
,
1306 ssize_t ret
= 0, written
= 0;
1309 if (down_interruptible(&tty
->atomic_write
)) {
1310 return -ERESTARTSYS
;
1314 * We chunk up writes into a temporary buffer. This
1315 * simplifies low-level drivers immensely, since they
1316 * don't have locking issues and user mode accesses.
1318 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1321 * The default chunk-size is 2kB, because the NTTY
1322 * layer has problems with bigger chunks. It will
1323 * claim to be able to handle more characters than
1327 if (test_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
))
1332 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1333 if (tty
->write_cnt
< chunk
) {
1339 buf
= kmalloc(chunk
, GFP_KERNEL
);
1341 up(&tty
->atomic_write
);
1344 kfree(tty
->write_buf
);
1345 tty
->write_cnt
= chunk
;
1346 tty
->write_buf
= buf
;
1349 /* Do the write .. */
1351 size_t size
= count
;
1355 if (copy_from_user(tty
->write_buf
, buf
, size
))
1358 ret
= write(tty
, file
, tty
->write_buf
, size
);
1368 if (signal_pending(current
))
1373 struct inode
*inode
= file
->f_dentry
->d_inode
;
1374 inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1377 up(&tty
->atomic_write
);
1382 static ssize_t
tty_write(struct file
* file
, const char __user
* buf
, size_t count
,
1385 struct tty_struct
* tty
;
1386 struct inode
*inode
= file
->f_dentry
->d_inode
;
1388 struct tty_ldisc
*ld
;
1390 tty
= (struct tty_struct
*)file
->private_data
;
1391 if (tty_paranoia_check(tty
, inode
, "tty_write"))
1393 if (!tty
|| !tty
->driver
->write
|| (test_bit(TTY_IO_ERROR
, &tty
->flags
)))
1396 ld
= tty_ldisc_ref_wait(tty
);
1400 ret
= do_tty_write(ld
->write
, tty
, file
, buf
, count
);
1401 tty_ldisc_deref(ld
);
1405 ssize_t
redirected_tty_write(struct file
* file
, const char __user
* buf
, size_t count
,
1408 struct file
*p
= NULL
;
1410 spin_lock(&redirect_lock
);
1415 spin_unlock(&redirect_lock
);
1419 res
= vfs_write(p
, buf
, count
, &p
->f_pos
);
1424 return tty_write(file
, buf
, count
, ppos
);
1427 static char ptychar
[] = "pqrstuvwxyzabcde";
1429 static inline void pty_line_name(struct tty_driver
*driver
, int index
, char *p
)
1431 int i
= index
+ driver
->name_base
;
1432 /* ->name is initialized to "ttyp", but "tty" is expected */
1433 sprintf(p
, "%s%c%x",
1434 driver
->subtype
== PTY_TYPE_SLAVE
? "tty" : driver
->name
,
1435 ptychar
[i
>> 4 & 0xf], i
& 0xf);
1438 static inline void tty_line_name(struct tty_driver
*driver
, int index
, char *p
)
1440 sprintf(p
, "%s%d", driver
->name
, index
+ driver
->name_base
);
1444 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1445 * failed open. The new code protects the open with a semaphore, so it's
1446 * really quite straightforward. The semaphore locking can probably be
1447 * relaxed for the (most common) case of reopening a tty.
1449 static int init_dev(struct tty_driver
*driver
, int idx
,
1450 struct tty_struct
**ret_tty
)
1452 struct tty_struct
*tty
, *o_tty
;
1453 struct termios
*tp
, **tp_loc
, *o_tp
, **o_tp_loc
;
1454 struct termios
*ltp
, **ltp_loc
, *o_ltp
, **o_ltp_loc
;
1457 /* check whether we're reopening an existing tty */
1458 if (driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) {
1459 tty
= devpts_get_tty(idx
);
1460 if (tty
&& driver
->subtype
== PTY_TYPE_MASTER
)
1463 tty
= driver
->ttys
[idx
];
1465 if (tty
) goto fast_track
;
1468 * First time open is complex, especially for PTY devices.
1469 * This code guarantees that either everything succeeds and the
1470 * TTY is ready for operation, or else the table slots are vacated
1471 * and the allocated memory released. (Except that the termios
1472 * and locked termios may be retained.)
1475 if (!try_module_get(driver
->owner
)) {
1484 tty
= alloc_tty_struct();
1487 initialize_tty_struct(tty
);
1488 tty
->driver
= driver
;
1490 tty_line_name(driver
, idx
, tty
->name
);
1492 if (driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) {
1493 tp_loc
= &tty
->termios
;
1494 ltp_loc
= &tty
->termios_locked
;
1496 tp_loc
= &driver
->termios
[idx
];
1497 ltp_loc
= &driver
->termios_locked
[idx
];
1501 tp
= (struct termios
*) kmalloc(sizeof(struct termios
),
1505 *tp
= driver
->init_termios
;
1509 ltp
= (struct termios
*) kmalloc(sizeof(struct termios
),
1513 memset(ltp
, 0, sizeof(struct termios
));
1516 if (driver
->type
== TTY_DRIVER_TYPE_PTY
) {
1517 o_tty
= alloc_tty_struct();
1520 initialize_tty_struct(o_tty
);
1521 o_tty
->driver
= driver
->other
;
1523 tty_line_name(driver
->other
, idx
, o_tty
->name
);
1525 if (driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) {
1526 o_tp_loc
= &o_tty
->termios
;
1527 o_ltp_loc
= &o_tty
->termios_locked
;
1529 o_tp_loc
= &driver
->other
->termios
[idx
];
1530 o_ltp_loc
= &driver
->other
->termios_locked
[idx
];
1534 o_tp
= (struct termios
*)
1535 kmalloc(sizeof(struct termios
), GFP_KERNEL
);
1538 *o_tp
= driver
->other
->init_termios
;
1542 o_ltp
= (struct termios
*)
1543 kmalloc(sizeof(struct termios
), GFP_KERNEL
);
1546 memset(o_ltp
, 0, sizeof(struct termios
));
1550 * Everything allocated ... set up the o_tty structure.
1552 if (!(driver
->other
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
1553 driver
->other
->ttys
[idx
] = o_tty
;
1559 o_tty
->termios
= *o_tp_loc
;
1560 o_tty
->termios_locked
= *o_ltp_loc
;
1561 driver
->other
->refcount
++;
1562 if (driver
->subtype
== PTY_TYPE_MASTER
)
1565 /* Establish the links in both directions */
1571 * All structures have been allocated, so now we install them.
1572 * Failures after this point use release_mem to clean up, so
1573 * there's no need to null out the local pointers.
1575 if (!(driver
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
1576 driver
->ttys
[idx
] = tty
;
1583 tty
->termios
= *tp_loc
;
1584 tty
->termios_locked
= *ltp_loc
;
1589 * Structures all installed ... call the ldisc open routines.
1590 * If we fail here just call release_mem to clean up. No need
1591 * to decrement the use counts, as release_mem doesn't care.
1594 if (tty
->ldisc
.open
) {
1595 retval
= (tty
->ldisc
.open
)(tty
);
1597 goto release_mem_out
;
1599 if (o_tty
&& o_tty
->ldisc
.open
) {
1600 retval
= (o_tty
->ldisc
.open
)(o_tty
);
1602 if (tty
->ldisc
.close
)
1603 (tty
->ldisc
.close
)(tty
);
1604 goto release_mem_out
;
1606 tty_ldisc_enable(o_tty
);
1608 tty_ldisc_enable(tty
);
1612 * This fast open can be used if the tty is already open.
1613 * No memory is allocated, and the only failures are from
1614 * attempting to open a closing tty or attempting multiple
1615 * opens on a pty master.
1618 if (test_bit(TTY_CLOSING
, &tty
->flags
)) {
1622 if (driver
->type
== TTY_DRIVER_TYPE_PTY
&&
1623 driver
->subtype
== PTY_TYPE_MASTER
) {
1625 * special case for PTY masters: only one open permitted,
1626 * and the slave side open count is incremented as well.
1635 tty
->driver
= driver
; /* N.B. why do this every time?? */
1638 if(!test_bit(TTY_LDISC
, &tty
->flags
))
1639 printk(KERN_ERR
"init_dev but no ldisc\n");
1643 /* All paths come through here to release the semaphore */
1647 /* Release locally allocated memory ... nothing placed in slots */
1651 free_tty_struct(o_tty
);
1654 free_tty_struct(tty
);
1657 module_put(driver
->owner
);
1661 /* call the tty release_mem routine to clean out this slot */
1663 printk(KERN_INFO
"init_dev: ldisc open failed, "
1664 "clearing slot %d\n", idx
);
1665 release_mem(tty
, idx
);
1670 * Releases memory associated with a tty structure, and clears out the
1671 * driver table slots.
1673 static void release_mem(struct tty_struct
*tty
, int idx
)
1675 struct tty_struct
*o_tty
;
1677 int devpts
= tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
;
1679 if ((o_tty
= tty
->link
) != NULL
) {
1681 o_tty
->driver
->ttys
[idx
] = NULL
;
1682 if (o_tty
->driver
->flags
& TTY_DRIVER_RESET_TERMIOS
) {
1683 tp
= o_tty
->termios
;
1685 o_tty
->driver
->termios
[idx
] = NULL
;
1688 tp
= o_tty
->termios_locked
;
1690 o_tty
->driver
->termios_locked
[idx
] = NULL
;
1694 o_tty
->driver
->refcount
--;
1696 list_del_init(&o_tty
->tty_files
);
1698 free_tty_struct(o_tty
);
1702 tty
->driver
->ttys
[idx
] = NULL
;
1703 if (tty
->driver
->flags
& TTY_DRIVER_RESET_TERMIOS
) {
1706 tty
->driver
->termios
[idx
] = NULL
;
1709 tp
= tty
->termios_locked
;
1711 tty
->driver
->termios_locked
[idx
] = NULL
;
1716 tty
->driver
->refcount
--;
1718 list_del_init(&tty
->tty_files
);
1720 module_put(tty
->driver
->owner
);
1721 free_tty_struct(tty
);
1725 * Even releasing the tty structures is a tricky business.. We have
1726 * to be very careful that the structures are all released at the
1727 * same time, as interrupts might otherwise get the wrong pointers.
1729 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1730 * lead to double frees or releasing memory still in use.
1732 static void release_dev(struct file
* filp
)
1734 struct tty_struct
*tty
, *o_tty
;
1735 int pty_master
, tty_closing
, o_tty_closing
, do_sleep
;
1736 int devpts_master
, devpts
;
1739 unsigned long flags
;
1741 tty
= (struct tty_struct
*)filp
->private_data
;
1742 if (tty_paranoia_check(tty
, filp
->f_dentry
->d_inode
, "release_dev"))
1745 check_tty_count(tty
, "release_dev");
1747 tty_fasync(-1, filp
, 0);
1750 pty_master
= (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
1751 tty
->driver
->subtype
== PTY_TYPE_MASTER
);
1752 devpts
= (tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) != 0;
1753 devpts_master
= pty_master
&& devpts
;
1756 #ifdef TTY_PARANOIA_CHECK
1757 if (idx
< 0 || idx
>= tty
->driver
->num
) {
1758 printk(KERN_DEBUG
"release_dev: bad idx when trying to "
1759 "free (%s)\n", tty
->name
);
1762 if (!(tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
1763 if (tty
!= tty
->driver
->ttys
[idx
]) {
1764 printk(KERN_DEBUG
"release_dev: driver.table[%d] not tty "
1765 "for (%s)\n", idx
, tty
->name
);
1768 if (tty
->termios
!= tty
->driver
->termios
[idx
]) {
1769 printk(KERN_DEBUG
"release_dev: driver.termios[%d] not termios "
1774 if (tty
->termios_locked
!= tty
->driver
->termios_locked
[idx
]) {
1775 printk(KERN_DEBUG
"release_dev: driver.termios_locked[%d] not "
1776 "termios_locked for (%s)\n",
1783 #ifdef TTY_DEBUG_HANGUP
1784 printk(KERN_DEBUG
"release_dev of %s (tty count=%d)...",
1785 tty_name(tty
, buf
), tty
->count
);
1788 #ifdef TTY_PARANOIA_CHECK
1789 if (tty
->driver
->other
&&
1790 !(tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
1791 if (o_tty
!= tty
->driver
->other
->ttys
[idx
]) {
1792 printk(KERN_DEBUG
"release_dev: other->table[%d] "
1793 "not o_tty for (%s)\n",
1797 if (o_tty
->termios
!= tty
->driver
->other
->termios
[idx
]) {
1798 printk(KERN_DEBUG
"release_dev: other->termios[%d] "
1799 "not o_termios for (%s)\n",
1803 if (o_tty
->termios_locked
!=
1804 tty
->driver
->other
->termios_locked
[idx
]) {
1805 printk(KERN_DEBUG
"release_dev: other->termios_locked["
1806 "%d] not o_termios_locked for (%s)\n",
1810 if (o_tty
->link
!= tty
) {
1811 printk(KERN_DEBUG
"release_dev: bad pty pointers\n");
1816 if (tty
->driver
->close
)
1817 tty
->driver
->close(tty
, filp
);
1820 * Sanity check: if tty->count is going to zero, there shouldn't be
1821 * any waiters on tty->read_wait or tty->write_wait. We test the
1822 * wait queues and kick everyone out _before_ actually starting to
1823 * close. This ensures that we won't block while releasing the tty
1826 * The test for the o_tty closing is necessary, since the master and
1827 * slave sides may close in any order. If the slave side closes out
1828 * first, its count will be one, since the master side holds an open.
1829 * Thus this test wouldn't be triggered at the time the slave closes,
1832 * Note that it's possible for the tty to be opened again while we're
1833 * flushing out waiters. By recalculating the closing flags before
1834 * each iteration we avoid any problems.
1837 /* Guard against races with tty->count changes elsewhere and
1838 opens on /dev/tty */
1841 tty_closing
= tty
->count
<= 1;
1842 o_tty_closing
= o_tty
&&
1843 (o_tty
->count
<= (pty_master
? 1 : 0));
1848 if (waitqueue_active(&tty
->read_wait
)) {
1849 wake_up(&tty
->read_wait
);
1852 if (waitqueue_active(&tty
->write_wait
)) {
1853 wake_up(&tty
->write_wait
);
1857 if (o_tty_closing
) {
1858 if (waitqueue_active(&o_tty
->read_wait
)) {
1859 wake_up(&o_tty
->read_wait
);
1862 if (waitqueue_active(&o_tty
->write_wait
)) {
1863 wake_up(&o_tty
->write_wait
);
1870 printk(KERN_WARNING
"release_dev: %s: read/write wait queue "
1871 "active!\n", tty_name(tty
, buf
));
1876 * The closing flags are now consistent with the open counts on
1877 * both sides, and we've completed the last operation that could
1878 * block, so it's safe to proceed with closing.
1883 if (--o_tty
->count
< 0) {
1884 printk(KERN_WARNING
"release_dev: bad pty slave count "
1886 o_tty
->count
, tty_name(o_tty
, buf
));
1890 if (--tty
->count
< 0) {
1891 printk(KERN_WARNING
"release_dev: bad tty->count (%d) for %s\n",
1892 tty
->count
, tty_name(tty
, buf
));
1898 * We've decremented tty->count, so we need to remove this file
1899 * descriptor off the tty->tty_files list; this serves two
1901 * - check_tty_count sees the correct number of file descriptors
1902 * associated with this tty.
1903 * - do_tty_hangup no longer sees this file descriptor as
1904 * something that needs to be handled for hangups.
1907 filp
->private_data
= NULL
;
1910 * Perform some housekeeping before deciding whether to return.
1912 * Set the TTY_CLOSING flag if this was the last open. In the
1913 * case of a pty we may have to wait around for the other side
1914 * to close, and TTY_CLOSING makes sure we can't be reopened.
1917 set_bit(TTY_CLOSING
, &tty
->flags
);
1919 set_bit(TTY_CLOSING
, &o_tty
->flags
);
1922 * If _either_ side is closing, make sure there aren't any
1923 * processes that still think tty or o_tty is their controlling
1926 if (tty_closing
|| o_tty_closing
) {
1927 struct task_struct
*p
;
1929 read_lock(&tasklist_lock
);
1930 do_each_task_pid(tty
->session
, PIDTYPE_SID
, p
) {
1931 p
->signal
->tty
= NULL
;
1932 } while_each_task_pid(tty
->session
, PIDTYPE_SID
, p
);
1934 do_each_task_pid(o_tty
->session
, PIDTYPE_SID
, p
) {
1935 p
->signal
->tty
= NULL
;
1936 } while_each_task_pid(o_tty
->session
, PIDTYPE_SID
, p
);
1937 read_unlock(&tasklist_lock
);
1940 /* check whether both sides are closing ... */
1941 if (!tty_closing
|| (o_tty
&& !o_tty_closing
))
1944 #ifdef TTY_DEBUG_HANGUP
1945 printk(KERN_DEBUG
"freeing tty structure...");
1948 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1949 * kill any delayed work. As this is the final close it does not
1950 * race with the set_ldisc code path.
1952 clear_bit(TTY_LDISC
, &tty
->flags
);
1953 clear_bit(TTY_DONT_FLIP
, &tty
->flags
);
1954 cancel_delayed_work(&tty
->buf
.work
);
1957 * Wait for ->hangup_work and ->buf.work handlers to terminate
1960 flush_scheduled_work();
1963 * Wait for any short term users (we know they are just driver
1964 * side waiters as the file is closing so user count on the file
1967 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
1968 while(tty
->ldisc
.refcount
)
1970 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
1971 wait_event(tty_ldisc_wait
, tty
->ldisc
.refcount
== 0);
1972 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
1974 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
1976 * Shutdown the current line discipline, and reset it to N_TTY.
1977 * N.B. why reset ldisc when we're releasing the memory??
1979 * FIXME: this MUST get fixed for the new reflocking
1981 if (tty
->ldisc
.close
)
1982 (tty
->ldisc
.close
)(tty
);
1983 tty_ldisc_put(tty
->ldisc
.num
);
1986 * Switch the line discipline back
1988 tty_ldisc_assign(tty
, tty_ldisc_get(N_TTY
));
1989 tty_set_termios_ldisc(tty
,N_TTY
);
1991 /* FIXME: could o_tty be in setldisc here ? */
1992 clear_bit(TTY_LDISC
, &o_tty
->flags
);
1993 if (o_tty
->ldisc
.close
)
1994 (o_tty
->ldisc
.close
)(o_tty
);
1995 tty_ldisc_put(o_tty
->ldisc
.num
);
1996 tty_ldisc_assign(o_tty
, tty_ldisc_get(N_TTY
));
1997 tty_set_termios_ldisc(o_tty
,N_TTY
);
2000 * The release_mem function takes care of the details of clearing
2001 * the slots and preserving the termios structure.
2003 release_mem(tty
, idx
);
2005 #ifdef CONFIG_UNIX98_PTYS
2006 /* Make this pty number available for reallocation */
2008 down(&allocated_ptys_lock
);
2009 idr_remove(&allocated_ptys
, idx
);
2010 up(&allocated_ptys_lock
);
2017 * tty_open and tty_release keep up the tty count that contains the
2018 * number of opens done on a tty. We cannot use the inode-count, as
2019 * different inodes might point to the same tty.
2021 * Open-counting is needed for pty masters, as well as for keeping
2022 * track of serial lines: DTR is dropped when the last close happens.
2023 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2025 * The termios state of a pty is reset on first open so that
2026 * settings don't persist across reuse.
2028 static int tty_open(struct inode
* inode
, struct file
* filp
)
2030 struct tty_struct
*tty
;
2032 struct tty_driver
*driver
;
2034 dev_t device
= inode
->i_rdev
;
2035 unsigned short saved_flags
= filp
->f_flags
;
2037 nonseekable_open(inode
, filp
);
2040 noctty
= filp
->f_flags
& O_NOCTTY
;
2046 if (device
== MKDEV(TTYAUX_MAJOR
,0)) {
2047 if (!current
->signal
->tty
) {
2051 driver
= current
->signal
->tty
->driver
;
2052 index
= current
->signal
->tty
->index
;
2053 filp
->f_flags
|= O_NONBLOCK
; /* Don't let /dev/tty block */
2058 if (device
== MKDEV(TTY_MAJOR
,0)) {
2059 extern struct tty_driver
*console_driver
;
2060 driver
= console_driver
;
2066 if (device
== MKDEV(TTYAUX_MAJOR
,1)) {
2067 driver
= console_device(&index
);
2069 /* Don't let /dev/console block */
2070 filp
->f_flags
|= O_NONBLOCK
;
2078 driver
= get_tty_driver(device
, &index
);
2084 retval
= init_dev(driver
, index
, &tty
);
2089 filp
->private_data
= tty
;
2090 file_move(filp
, &tty
->tty_files
);
2091 check_tty_count(tty
, "tty_open");
2092 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
2093 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
2095 #ifdef TTY_DEBUG_HANGUP
2096 printk(KERN_DEBUG
"opening %s...", tty
->name
);
2099 if (tty
->driver
->open
)
2100 retval
= tty
->driver
->open(tty
, filp
);
2104 filp
->f_flags
= saved_flags
;
2106 if (!retval
&& test_bit(TTY_EXCLUSIVE
, &tty
->flags
) && !capable(CAP_SYS_ADMIN
))
2110 #ifdef TTY_DEBUG_HANGUP
2111 printk(KERN_DEBUG
"error %d in opening %s...", retval
,
2115 if (retval
!= -ERESTARTSYS
)
2117 if (signal_pending(current
))
2121 * Need to reset f_op in case a hangup happened.
2123 if (filp
->f_op
== &hung_up_tty_fops
)
2124 filp
->f_op
= &tty_fops
;
2128 current
->signal
->leader
&&
2129 !current
->signal
->tty
&&
2130 tty
->session
== 0) {
2132 current
->signal
->tty
= tty
;
2133 task_unlock(current
);
2134 current
->signal
->tty_old_pgrp
= 0;
2135 tty
->session
= current
->signal
->session
;
2136 tty
->pgrp
= process_group(current
);
2141 #ifdef CONFIG_UNIX98_PTYS
2142 static int ptmx_open(struct inode
* inode
, struct file
* filp
)
2144 struct tty_struct
*tty
;
2149 nonseekable_open(inode
, filp
);
2151 /* find a device that is not in use. */
2152 down(&allocated_ptys_lock
);
2153 if (!idr_pre_get(&allocated_ptys
, GFP_KERNEL
)) {
2154 up(&allocated_ptys_lock
);
2157 idr_ret
= idr_get_new(&allocated_ptys
, NULL
, &index
);
2159 up(&allocated_ptys_lock
);
2160 if (idr_ret
== -EAGAIN
)
2164 if (index
>= pty_limit
) {
2165 idr_remove(&allocated_ptys
, index
);
2166 up(&allocated_ptys_lock
);
2169 up(&allocated_ptys_lock
);
2172 retval
= init_dev(ptm_driver
, index
, &tty
);
2178 set_bit(TTY_PTY_LOCK
, &tty
->flags
); /* LOCK THE SLAVE */
2179 filp
->private_data
= tty
;
2180 file_move(filp
, &tty
->tty_files
);
2183 if (devpts_pty_new(tty
->link
))
2186 check_tty_count(tty
, "tty_open");
2187 retval
= ptm_driver
->open(tty
, filp
);
2193 down(&allocated_ptys_lock
);
2194 idr_remove(&allocated_ptys
, index
);
2195 up(&allocated_ptys_lock
);
2200 static int tty_release(struct inode
* inode
, struct file
* filp
)
2208 /* No kernel lock held - fine */
2209 static unsigned int tty_poll(struct file
* filp
, poll_table
* wait
)
2211 struct tty_struct
* tty
;
2212 struct tty_ldisc
*ld
;
2215 tty
= (struct tty_struct
*)filp
->private_data
;
2216 if (tty_paranoia_check(tty
, filp
->f_dentry
->d_inode
, "tty_poll"))
2219 ld
= tty_ldisc_ref_wait(tty
);
2221 ret
= (ld
->poll
)(tty
, filp
, wait
);
2222 tty_ldisc_deref(ld
);
2226 static int tty_fasync(int fd
, struct file
* filp
, int on
)
2228 struct tty_struct
* tty
;
2231 tty
= (struct tty_struct
*)filp
->private_data
;
2232 if (tty_paranoia_check(tty
, filp
->f_dentry
->d_inode
, "tty_fasync"))
2235 retval
= fasync_helper(fd
, filp
, on
, &tty
->fasync
);
2240 if (!waitqueue_active(&tty
->read_wait
))
2241 tty
->minimum_to_wake
= 1;
2242 retval
= f_setown(filp
, (-tty
->pgrp
) ? : current
->pid
, 0);
2246 if (!tty
->fasync
&& !waitqueue_active(&tty
->read_wait
))
2247 tty
->minimum_to_wake
= N_TTY_BUF_SIZE
;
2252 static int tiocsti(struct tty_struct
*tty
, char __user
*p
)
2255 struct tty_ldisc
*ld
;
2257 if ((current
->signal
->tty
!= tty
) && !capable(CAP_SYS_ADMIN
))
2259 if (get_user(ch
, p
))
2261 ld
= tty_ldisc_ref_wait(tty
);
2262 ld
->receive_buf(tty
, &ch
, &mbz
, 1);
2263 tty_ldisc_deref(ld
);
2267 static int tiocgwinsz(struct tty_struct
*tty
, struct winsize __user
* arg
)
2269 if (copy_to_user(arg
, &tty
->winsize
, sizeof(*arg
)))
2274 static int tiocswinsz(struct tty_struct
*tty
, struct tty_struct
*real_tty
,
2275 struct winsize __user
* arg
)
2277 struct winsize tmp_ws
;
2279 if (copy_from_user(&tmp_ws
, arg
, sizeof(*arg
)))
2281 if (!memcmp(&tmp_ws
, &tty
->winsize
, sizeof(*arg
)))
2284 if (tty
->driver
->type
== TTY_DRIVER_TYPE_CONSOLE
) {
2287 acquire_console_sem();
2288 rc
= vc_resize(tty
->driver_data
, tmp_ws
.ws_col
, tmp_ws
.ws_row
);
2289 release_console_sem();
2295 kill_pg(tty
->pgrp
, SIGWINCH
, 1);
2296 if ((real_tty
->pgrp
!= tty
->pgrp
) && (real_tty
->pgrp
> 0))
2297 kill_pg(real_tty
->pgrp
, SIGWINCH
, 1);
2298 tty
->winsize
= tmp_ws
;
2299 real_tty
->winsize
= tmp_ws
;
2303 static int tioccons(struct file
*file
)
2305 if (!capable(CAP_SYS_ADMIN
))
2307 if (file
->f_op
->write
== redirected_tty_write
) {
2309 spin_lock(&redirect_lock
);
2312 spin_unlock(&redirect_lock
);
2317 spin_lock(&redirect_lock
);
2319 spin_unlock(&redirect_lock
);
2324 spin_unlock(&redirect_lock
);
2329 static int fionbio(struct file
*file
, int __user
*p
)
2333 if (get_user(nonblock
, p
))
2337 file
->f_flags
|= O_NONBLOCK
;
2339 file
->f_flags
&= ~O_NONBLOCK
;
2343 static int tiocsctty(struct tty_struct
*tty
, int arg
)
2347 if (current
->signal
->leader
&&
2348 (current
->signal
->session
== tty
->session
))
2351 * The process must be a session leader and
2352 * not have a controlling tty already.
2354 if (!current
->signal
->leader
|| current
->signal
->tty
)
2356 if (tty
->session
> 0) {
2358 * This tty is already the controlling
2359 * tty for another session group!
2361 if ((arg
== 1) && capable(CAP_SYS_ADMIN
)) {
2366 read_lock(&tasklist_lock
);
2367 do_each_task_pid(tty
->session
, PIDTYPE_SID
, p
) {
2368 p
->signal
->tty
= NULL
;
2369 } while_each_task_pid(tty
->session
, PIDTYPE_SID
, p
);
2370 read_unlock(&tasklist_lock
);
2375 current
->signal
->tty
= tty
;
2376 task_unlock(current
);
2377 current
->signal
->tty_old_pgrp
= 0;
2378 tty
->session
= current
->signal
->session
;
2379 tty
->pgrp
= process_group(current
);
2383 static int tiocgpgrp(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
2386 * (tty == real_tty) is a cheap way of
2387 * testing if the tty is NOT a master pty.
2389 if (tty
== real_tty
&& current
->signal
->tty
!= real_tty
)
2391 return put_user(real_tty
->pgrp
, p
);
2394 static int tiocspgrp(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
2397 int retval
= tty_check_change(real_tty
);
2403 if (!current
->signal
->tty
||
2404 (current
->signal
->tty
!= real_tty
) ||
2405 (real_tty
->session
!= current
->signal
->session
))
2407 if (get_user(pgrp
, p
))
2411 if (session_of_pgrp(pgrp
) != current
->signal
->session
)
2413 real_tty
->pgrp
= pgrp
;
2417 static int tiocgsid(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
2420 * (tty == real_tty) is a cheap way of
2421 * testing if the tty is NOT a master pty.
2423 if (tty
== real_tty
&& current
->signal
->tty
!= real_tty
)
2425 if (real_tty
->session
<= 0)
2427 return put_user(real_tty
->session
, p
);
2430 static int tiocsetd(struct tty_struct
*tty
, int __user
*p
)
2434 if (get_user(ldisc
, p
))
2436 return tty_set_ldisc(tty
, ldisc
);
2439 static int send_break(struct tty_struct
*tty
, unsigned int duration
)
2441 tty
->driver
->break_ctl(tty
, -1);
2442 if (!signal_pending(current
)) {
2443 msleep_interruptible(duration
);
2445 tty
->driver
->break_ctl(tty
, 0);
2446 if (signal_pending(current
))
2452 tty_tiocmget(struct tty_struct
*tty
, struct file
*file
, int __user
*p
)
2454 int retval
= -EINVAL
;
2456 if (tty
->driver
->tiocmget
) {
2457 retval
= tty
->driver
->tiocmget(tty
, file
);
2460 retval
= put_user(retval
, p
);
2466 tty_tiocmset(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
,
2469 int retval
= -EINVAL
;
2471 if (tty
->driver
->tiocmset
) {
2472 unsigned int set
, clear
, val
;
2474 retval
= get_user(val
, p
);
2492 set
&= TIOCM_DTR
|TIOCM_RTS
|TIOCM_OUT1
|TIOCM_OUT2
|TIOCM_LOOP
;
2493 clear
&= TIOCM_DTR
|TIOCM_RTS
|TIOCM_OUT1
|TIOCM_OUT2
|TIOCM_LOOP
;
2495 retval
= tty
->driver
->tiocmset(tty
, file
, set
, clear
);
2501 * Split this up, as gcc can choke on it otherwise..
2503 int tty_ioctl(struct inode
* inode
, struct file
* file
,
2504 unsigned int cmd
, unsigned long arg
)
2506 struct tty_struct
*tty
, *real_tty
;
2507 void __user
*p
= (void __user
*)arg
;
2509 struct tty_ldisc
*ld
;
2511 tty
= (struct tty_struct
*)file
->private_data
;
2512 if (tty_paranoia_check(tty
, inode
, "tty_ioctl"))
2516 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
2517 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
2518 real_tty
= tty
->link
;
2521 * Break handling by driver
2523 if (!tty
->driver
->break_ctl
) {
2527 if (tty
->driver
->ioctl
)
2528 return tty
->driver
->ioctl(tty
, file
, cmd
, arg
);
2531 /* These two ioctl's always return success; even if */
2532 /* the driver doesn't support them. */
2535 if (!tty
->driver
->ioctl
)
2537 retval
= tty
->driver
->ioctl(tty
, file
, cmd
, arg
);
2538 if (retval
== -ENOIOCTLCMD
)
2545 * Factor out some common prep work
2553 retval
= tty_check_change(tty
);
2556 if (cmd
!= TIOCCBRK
) {
2557 tty_wait_until_sent(tty
, 0);
2558 if (signal_pending(current
))
2566 return tiocsti(tty
, p
);
2568 return tiocgwinsz(tty
, p
);
2570 return tiocswinsz(tty
, real_tty
, p
);
2572 return real_tty
!=tty
? -EINVAL
: tioccons(file
);
2574 return fionbio(file
, p
);
2576 set_bit(TTY_EXCLUSIVE
, &tty
->flags
);
2579 clear_bit(TTY_EXCLUSIVE
, &tty
->flags
);
2582 if (current
->signal
->tty
!= tty
)
2584 if (current
->signal
->leader
)
2585 disassociate_ctty(0);
2587 current
->signal
->tty
= NULL
;
2588 task_unlock(current
);
2591 return tiocsctty(tty
, arg
);
2593 return tiocgpgrp(tty
, real_tty
, p
);
2595 return tiocspgrp(tty
, real_tty
, p
);
2597 return tiocgsid(tty
, real_tty
, p
);
2599 /* FIXME: check this is ok */
2600 return put_user(tty
->ldisc
.num
, (int __user
*)p
);
2602 return tiocsetd(tty
, p
);
2605 return tioclinux(tty
, arg
);
2610 case TIOCSBRK
: /* Turn break on, unconditionally */
2611 tty
->driver
->break_ctl(tty
, -1);
2614 case TIOCCBRK
: /* Turn break off, unconditionally */
2615 tty
->driver
->break_ctl(tty
, 0);
2617 case TCSBRK
: /* SVID version: non-zero arg --> no break */
2619 * XXX is the above comment correct, or the
2620 * code below correct? Is this ioctl used at
2624 return send_break(tty
, 250);
2626 case TCSBRKP
: /* support for POSIX tcsendbreak() */
2627 return send_break(tty
, arg
? arg
*100 : 250);
2630 return tty_tiocmget(tty
, file
, p
);
2635 return tty_tiocmset(tty
, file
, cmd
, p
);
2637 if (tty
->driver
->ioctl
) {
2638 retval
= (tty
->driver
->ioctl
)(tty
, file
, cmd
, arg
);
2639 if (retval
!= -ENOIOCTLCMD
)
2642 ld
= tty_ldisc_ref_wait(tty
);
2645 retval
= ld
->ioctl(tty
, file
, cmd
, arg
);
2646 if (retval
== -ENOIOCTLCMD
)
2649 tty_ldisc_deref(ld
);
2655 * This implements the "Secure Attention Key" --- the idea is to
2656 * prevent trojan horses by killing all processes associated with this
2657 * tty when the user hits the "Secure Attention Key". Required for
2658 * super-paranoid applications --- see the Orange Book for more details.
2660 * This code could be nicer; ideally it should send a HUP, wait a few
2661 * seconds, then send a INT, and then a KILL signal. But you then
2662 * have to coordinate with the init process, since all processes associated
2663 * with the current tty must be dead before the new getty is allowed
2666 * Now, if it would be correct ;-/ The current code has a nasty hole -
2667 * it doesn't catch files in flight. We may send the descriptor to ourselves
2668 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2670 * Nasty bug: do_SAK is being called in interrupt context. This can
2671 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2673 static void __do_SAK(void *arg
)
2678 struct tty_struct
*tty
= arg
;
2679 struct task_struct
*p
;
2683 struct tty_ldisc
*disc
;
2684 struct fdtable
*fdt
;
2688 session
= tty
->session
;
2690 /* We don't want an ldisc switch during this */
2691 disc
= tty_ldisc_ref(tty
);
2692 if (disc
&& disc
->flush_buffer
)
2693 disc
->flush_buffer(tty
);
2694 tty_ldisc_deref(disc
);
2696 if (tty
->driver
->flush_buffer
)
2697 tty
->driver
->flush_buffer(tty
);
2699 read_lock(&tasklist_lock
);
2700 do_each_task_pid(session
, PIDTYPE_SID
, p
) {
2701 if (p
->signal
->tty
== tty
|| session
> 0) {
2702 printk(KERN_NOTICE
"SAK: killed process %d"
2703 " (%s): p->signal->session==tty->session\n",
2705 send_sig(SIGKILL
, p
, 1);
2711 fdt
= files_fdtable(p
->files
);
2712 for (i
=0; i
< fdt
->max_fds
; i
++) {
2713 filp
= fcheck_files(p
->files
, i
);
2716 if (filp
->f_op
->read
== tty_read
&&
2717 filp
->private_data
== tty
) {
2718 printk(KERN_NOTICE
"SAK: killed process %d"
2719 " (%s): fd#%d opened to the tty\n",
2720 p
->pid
, p
->comm
, i
);
2721 send_sig(SIGKILL
, p
, 1);
2728 } while_each_task_pid(session
, PIDTYPE_SID
, p
);
2729 read_unlock(&tasklist_lock
);
2734 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2735 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2736 * the values which we write to it will be identical to the values which it
2737 * already has. --akpm
2739 void do_SAK(struct tty_struct
*tty
)
2743 PREPARE_WORK(&tty
->SAK_work
, __do_SAK
, tty
);
2744 schedule_work(&tty
->SAK_work
);
2747 EXPORT_SYMBOL(do_SAK
);
2750 * This routine is called out of the software interrupt to flush data
2751 * from the buffer chain to the line discipline.
2754 static void flush_to_ldisc(void *private_
)
2756 struct tty_struct
*tty
= (struct tty_struct
*) private_
;
2757 unsigned long flags
;
2758 struct tty_ldisc
*disc
;
2759 struct tty_buffer
*tbuf
;
2762 unsigned char *flag_buf
;
2764 disc
= tty_ldisc_ref(tty
);
2765 if (disc
== NULL
) /* !TTY_LDISC */
2768 if (test_bit(TTY_DONT_FLIP
, &tty
->flags
)) {
2770 * Do it after the next timer tick:
2772 schedule_delayed_work(&tty
->buf
.work
, 1);
2775 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
2776 while((tbuf
= tty
->buf
.head
) != NULL
) {
2777 while ((count
= tbuf
->commit
- tbuf
->read
) != 0) {
2778 char_buf
= tbuf
->char_buf_ptr
+ tbuf
->read
;
2779 flag_buf
= tbuf
->flag_buf_ptr
+ tbuf
->read
;
2780 tbuf
->read
+= count
;
2781 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
2782 disc
->receive_buf(tty
, char_buf
, flag_buf
, count
);
2783 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
2787 tty
->buf
.head
= tbuf
->next
;
2788 if (tty
->buf
.head
== NULL
)
2789 tty
->buf
.tail
= NULL
;
2790 tty_buffer_free(tty
, tbuf
);
2792 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
2794 tty_ldisc_deref(disc
);
2798 * Routine which returns the baud rate of the tty
2800 * Note that the baud_table needs to be kept in sync with the
2801 * include/asm/termbits.h file.
2803 static int baud_table
[] = {
2804 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2805 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2807 76800, 153600, 307200, 614400, 921600
2809 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2810 2500000, 3000000, 3500000, 4000000
2814 static int n_baud_table
= ARRAY_SIZE(baud_table
);
2817 * tty_termios_baud_rate
2818 * @termios: termios structure
2820 * Convert termios baud rate data into a speed. This should be called
2821 * with the termios lock held if this termios is a terminal termios
2822 * structure. May change the termios data.
2825 int tty_termios_baud_rate(struct termios
*termios
)
2829 cbaud
= termios
->c_cflag
& CBAUD
;
2831 if (cbaud
& CBAUDEX
) {
2834 if (cbaud
< 1 || cbaud
+ 15 > n_baud_table
)
2835 termios
->c_cflag
&= ~CBAUDEX
;
2839 return baud_table
[cbaud
];
2842 EXPORT_SYMBOL(tty_termios_baud_rate
);
2845 * tty_get_baud_rate - get tty bit rates
2846 * @tty: tty to query
2848 * Returns the baud rate as an integer for this terminal. The
2849 * termios lock must be held by the caller and the terminal bit
2850 * flags may be updated.
2853 int tty_get_baud_rate(struct tty_struct
*tty
)
2855 int baud
= tty_termios_baud_rate(tty
->termios
);
2857 if (baud
== 38400 && tty
->alt_speed
) {
2859 printk(KERN_WARNING
"Use of setserial/setrocket to "
2860 "set SPD_* flags is deprecated\n");
2863 baud
= tty
->alt_speed
;
2869 EXPORT_SYMBOL(tty_get_baud_rate
);
2872 * tty_flip_buffer_push - terminal
2875 * Queue a push of the terminal flip buffers to the line discipline. This
2876 * function must not be called from IRQ context if tty->low_latency is set.
2878 * In the event of the queue being busy for flipping the work will be
2879 * held off and retried later.
2882 void tty_flip_buffer_push(struct tty_struct
*tty
)
2884 unsigned long flags
;
2885 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
2886 if (tty
->buf
.tail
!= NULL
) {
2887 tty
->buf
.tail
->active
= 0;
2888 tty
->buf
.tail
->commit
= tty
->buf
.tail
->used
;
2890 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
2892 if (tty
->low_latency
)
2893 flush_to_ldisc((void *) tty
);
2895 schedule_delayed_work(&tty
->buf
.work
, 1);
2898 EXPORT_SYMBOL(tty_flip_buffer_push
);
2902 * This subroutine initializes a tty structure.
2904 static void initialize_tty_struct(struct tty_struct
*tty
)
2906 memset(tty
, 0, sizeof(struct tty_struct
));
2907 tty
->magic
= TTY_MAGIC
;
2908 tty_ldisc_assign(tty
, tty_ldisc_get(N_TTY
));
2910 tty
->overrun_time
= jiffies
;
2911 tty
->buf
.head
= tty
->buf
.tail
= NULL
;
2912 tty_buffer_init(tty
);
2913 INIT_WORK(&tty
->buf
.work
, flush_to_ldisc
, tty
);
2914 init_MUTEX(&tty
->buf
.pty_sem
);
2915 init_MUTEX(&tty
->termios_sem
);
2916 init_waitqueue_head(&tty
->write_wait
);
2917 init_waitqueue_head(&tty
->read_wait
);
2918 INIT_WORK(&tty
->hangup_work
, do_tty_hangup
, tty
);
2919 sema_init(&tty
->atomic_read
, 1);
2920 sema_init(&tty
->atomic_write
, 1);
2921 spin_lock_init(&tty
->read_lock
);
2922 INIT_LIST_HEAD(&tty
->tty_files
);
2923 INIT_WORK(&tty
->SAK_work
, NULL
, NULL
);
2927 * The default put_char routine if the driver did not define one.
2929 static void tty_default_put_char(struct tty_struct
*tty
, unsigned char ch
)
2931 tty
->driver
->write(tty
, &ch
, 1);
2934 static struct class *tty_class
;
2937 * tty_register_device - register a tty device
2938 * @driver: the tty driver that describes the tty device
2939 * @index: the index in the tty driver for this tty device
2940 * @device: a struct device that is associated with this tty device.
2941 * This field is optional, if there is no known struct device for this
2942 * tty device it can be set to NULL safely.
2944 * This call is required to be made to register an individual tty device if
2945 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2946 * bit is not set, this function should not be called.
2948 void tty_register_device(struct tty_driver
*driver
, unsigned index
,
2949 struct device
*device
)
2952 dev_t dev
= MKDEV(driver
->major
, driver
->minor_start
) + index
;
2954 if (index
>= driver
->num
) {
2955 printk(KERN_ERR
"Attempt to register invalid tty line number "
2960 devfs_mk_cdev(dev
, S_IFCHR
| S_IRUSR
| S_IWUSR
,
2961 "%s%d", driver
->devfs_name
, index
+ driver
->name_base
);
2963 if (driver
->type
== TTY_DRIVER_TYPE_PTY
)
2964 pty_line_name(driver
, index
, name
);
2966 tty_line_name(driver
, index
, name
);
2967 class_device_create(tty_class
, NULL
, dev
, device
, "%s", name
);
2971 * tty_unregister_device - unregister a tty device
2972 * @driver: the tty driver that describes the tty device
2973 * @index: the index in the tty driver for this tty device
2975 * If a tty device is registered with a call to tty_register_device() then
2976 * this function must be made when the tty device is gone.
2978 void tty_unregister_device(struct tty_driver
*driver
, unsigned index
)
2980 devfs_remove("%s%d", driver
->devfs_name
, index
+ driver
->name_base
);
2981 class_device_destroy(tty_class
, MKDEV(driver
->major
, driver
->minor_start
) + index
);
2984 EXPORT_SYMBOL(tty_register_device
);
2985 EXPORT_SYMBOL(tty_unregister_device
);
2987 struct tty_driver
*alloc_tty_driver(int lines
)
2989 struct tty_driver
*driver
;
2991 driver
= kmalloc(sizeof(struct tty_driver
), GFP_KERNEL
);
2993 memset(driver
, 0, sizeof(struct tty_driver
));
2994 driver
->magic
= TTY_DRIVER_MAGIC
;
2995 driver
->num
= lines
;
2996 /* later we'll move allocation of tables here */
3001 void put_tty_driver(struct tty_driver
*driver
)
3006 void tty_set_operations(struct tty_driver
*driver
, struct tty_operations
*op
)
3008 driver
->open
= op
->open
;
3009 driver
->close
= op
->close
;
3010 driver
->write
= op
->write
;
3011 driver
->put_char
= op
->put_char
;
3012 driver
->flush_chars
= op
->flush_chars
;
3013 driver
->write_room
= op
->write_room
;
3014 driver
->chars_in_buffer
= op
->chars_in_buffer
;
3015 driver
->ioctl
= op
->ioctl
;
3016 driver
->set_termios
= op
->set_termios
;
3017 driver
->throttle
= op
->throttle
;
3018 driver
->unthrottle
= op
->unthrottle
;
3019 driver
->stop
= op
->stop
;
3020 driver
->start
= op
->start
;
3021 driver
->hangup
= op
->hangup
;
3022 driver
->break_ctl
= op
->break_ctl
;
3023 driver
->flush_buffer
= op
->flush_buffer
;
3024 driver
->set_ldisc
= op
->set_ldisc
;
3025 driver
->wait_until_sent
= op
->wait_until_sent
;
3026 driver
->send_xchar
= op
->send_xchar
;
3027 driver
->read_proc
= op
->read_proc
;
3028 driver
->write_proc
= op
->write_proc
;
3029 driver
->tiocmget
= op
->tiocmget
;
3030 driver
->tiocmset
= op
->tiocmset
;
3034 EXPORT_SYMBOL(alloc_tty_driver
);
3035 EXPORT_SYMBOL(put_tty_driver
);
3036 EXPORT_SYMBOL(tty_set_operations
);
3039 * Called by a tty driver to register itself.
3041 int tty_register_driver(struct tty_driver
*driver
)
3048 if (driver
->flags
& TTY_DRIVER_INSTALLED
)
3051 if (!(driver
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
3052 p
= kmalloc(driver
->num
* 3 * sizeof(void *), GFP_KERNEL
);
3055 memset(p
, 0, driver
->num
* 3 * sizeof(void *));
3058 if (!driver
->major
) {
3059 error
= alloc_chrdev_region(&dev
, driver
->minor_start
, driver
->num
,
3060 (char*)driver
->name
);
3062 driver
->major
= MAJOR(dev
);
3063 driver
->minor_start
= MINOR(dev
);
3066 dev
= MKDEV(driver
->major
, driver
->minor_start
);
3067 error
= register_chrdev_region(dev
, driver
->num
,
3068 (char*)driver
->name
);
3076 driver
->ttys
= (struct tty_struct
**)p
;
3077 driver
->termios
= (struct termios
**)(p
+ driver
->num
);
3078 driver
->termios_locked
= (struct termios
**)(p
+ driver
->num
* 2);
3080 driver
->ttys
= NULL
;
3081 driver
->termios
= NULL
;
3082 driver
->termios_locked
= NULL
;
3085 cdev_init(&driver
->cdev
, &tty_fops
);
3086 driver
->cdev
.owner
= driver
->owner
;
3087 error
= cdev_add(&driver
->cdev
, dev
, driver
->num
);
3089 cdev_del(&driver
->cdev
);
3090 unregister_chrdev_region(dev
, driver
->num
);
3091 driver
->ttys
= NULL
;
3092 driver
->termios
= driver
->termios_locked
= NULL
;
3097 if (!driver
->put_char
)
3098 driver
->put_char
= tty_default_put_char
;
3100 list_add(&driver
->tty_drivers
, &tty_drivers
);
3102 if ( !(driver
->flags
& TTY_DRIVER_NO_DEVFS
) ) {
3103 for(i
= 0; i
< driver
->num
; i
++)
3104 tty_register_device(driver
, i
, NULL
);
3106 proc_tty_register_driver(driver
);
3110 EXPORT_SYMBOL(tty_register_driver
);
3113 * Called by a tty driver to unregister itself.
3115 int tty_unregister_driver(struct tty_driver
*driver
)
3121 if (driver
->refcount
)
3124 unregister_chrdev_region(MKDEV(driver
->major
, driver
->minor_start
),
3127 list_del(&driver
->tty_drivers
);
3130 * Free the termios and termios_locked structures because
3131 * we don't want to get memory leaks when modular tty
3132 * drivers are removed from the kernel.
3134 for (i
= 0; i
< driver
->num
; i
++) {
3135 tp
= driver
->termios
[i
];
3137 driver
->termios
[i
] = NULL
;
3140 tp
= driver
->termios_locked
[i
];
3142 driver
->termios_locked
[i
] = NULL
;
3145 if (!(driver
->flags
& TTY_DRIVER_NO_DEVFS
))
3146 tty_unregister_device(driver
, i
);
3149 proc_tty_unregister_driver(driver
);
3150 driver
->ttys
= NULL
;
3151 driver
->termios
= driver
->termios_locked
= NULL
;
3153 cdev_del(&driver
->cdev
);
3157 EXPORT_SYMBOL(tty_unregister_driver
);
3161 * Initialize the console device. This is called *early*, so
3162 * we can't necessarily depend on lots of kernel help here.
3163 * Just do some early initializations, and do the complex setup
3166 void __init
console_init(void)
3170 /* Setup the default TTY line discipline. */
3171 (void) tty_register_ldisc(N_TTY
, &tty_ldisc_N_TTY
);
3174 * set up the console device so that later boot sequences can
3175 * inform about problems etc..
3177 #ifdef CONFIG_EARLY_PRINTK
3178 disable_early_printk();
3180 call
= __con_initcall_start
;
3181 while (call
< __con_initcall_end
) {
3188 extern int vty_init(void);
3191 static int __init
tty_class_init(void)
3193 tty_class
= class_create(THIS_MODULE
, "tty");
3194 if (IS_ERR(tty_class
))
3195 return PTR_ERR(tty_class
);
3199 postcore_initcall(tty_class_init
);
3201 /* 3/2004 jmc: why do these devices exist? */
3203 static struct cdev tty_cdev
, console_cdev
;
3204 #ifdef CONFIG_UNIX98_PTYS
3205 static struct cdev ptmx_cdev
;
3208 static struct cdev vc0_cdev
;
3212 * Ok, now we can initialize the rest of the tty devices and can count
3213 * on memory allocations, interrupts etc..
3215 static int __init
tty_init(void)
3217 cdev_init(&tty_cdev
, &tty_fops
);
3218 if (cdev_add(&tty_cdev
, MKDEV(TTYAUX_MAJOR
, 0), 1) ||
3219 register_chrdev_region(MKDEV(TTYAUX_MAJOR
, 0), 1, "/dev/tty") < 0)
3220 panic("Couldn't register /dev/tty driver\n");
3221 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR
, 0), S_IFCHR
|S_IRUGO
|S_IWUGO
, "tty");
3222 class_device_create(tty_class
, NULL
, MKDEV(TTYAUX_MAJOR
, 0), NULL
, "tty");
3224 cdev_init(&console_cdev
, &console_fops
);
3225 if (cdev_add(&console_cdev
, MKDEV(TTYAUX_MAJOR
, 1), 1) ||
3226 register_chrdev_region(MKDEV(TTYAUX_MAJOR
, 1), 1, "/dev/console") < 0)
3227 panic("Couldn't register /dev/console driver\n");
3228 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR
, 1), S_IFCHR
|S_IRUSR
|S_IWUSR
, "console");
3229 class_device_create(tty_class
, NULL
, MKDEV(TTYAUX_MAJOR
, 1), NULL
, "console");
3231 #ifdef CONFIG_UNIX98_PTYS
3232 cdev_init(&ptmx_cdev
, &ptmx_fops
);
3233 if (cdev_add(&ptmx_cdev
, MKDEV(TTYAUX_MAJOR
, 2), 1) ||
3234 register_chrdev_region(MKDEV(TTYAUX_MAJOR
, 2), 1, "/dev/ptmx") < 0)
3235 panic("Couldn't register /dev/ptmx driver\n");
3236 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR
, 2), S_IFCHR
|S_IRUGO
|S_IWUGO
, "ptmx");
3237 class_device_create(tty_class
, NULL
, MKDEV(TTYAUX_MAJOR
, 2), NULL
, "ptmx");
3241 cdev_init(&vc0_cdev
, &console_fops
);
3242 if (cdev_add(&vc0_cdev
, MKDEV(TTY_MAJOR
, 0), 1) ||
3243 register_chrdev_region(MKDEV(TTY_MAJOR
, 0), 1, "/dev/vc/0") < 0)
3244 panic("Couldn't register /dev/tty0 driver\n");
3245 devfs_mk_cdev(MKDEV(TTY_MAJOR
, 0), S_IFCHR
|S_IRUSR
|S_IWUSR
, "vc/0");
3246 class_device_create(tty_class
, NULL
, MKDEV(TTY_MAJOR
, 0), NULL
, "tty0");
3252 module_init(tty_init
);