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 ktermios 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
,
123 EXPORT_SYMBOL(tty_std_termios
);
125 /* This list gets poked at by procfs and various bits of boot up code. This
126 could do with some rationalisation such as pulling the tty proc function
129 LIST_HEAD(tty_drivers
); /* linked list of tty drivers */
131 /* Mutex to protect creating and releasing a tty. This is shared with
132 vt.c for deeply disgusting hack reasons */
133 DEFINE_MUTEX(tty_mutex
);
134 EXPORT_SYMBOL(tty_mutex
);
136 #ifdef CONFIG_UNIX98_PTYS
137 extern struct tty_driver
*ptm_driver
; /* Unix98 pty masters; for /dev/ptmx */
138 extern int pty_limit
; /* Config limit on Unix98 ptys */
139 static DEFINE_IDR(allocated_ptys
);
140 static DECLARE_MUTEX(allocated_ptys_lock
);
141 static int ptmx_open(struct inode
*, struct file
*);
144 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
);
155 static long tty_compat_ioctl(struct file
* file
, unsigned int cmd
,
158 #define tty_compat_ioctl NULL
160 static int tty_fasync(int fd
, struct file
* filp
, int on
);
161 static void release_tty(struct tty_struct
*tty
, int idx
);
162 static void __proc_set_tty(struct task_struct
*tsk
, struct tty_struct
*tty
);
163 static void proc_set_tty(struct task_struct
*tsk
, struct tty_struct
*tty
);
166 * alloc_tty_struct - allocate a tty object
168 * Return a new empty tty structure. The data fields have not
169 * been initialized in any way but has been zeroed
174 static struct tty_struct
*alloc_tty_struct(void)
176 return kzalloc(sizeof(struct tty_struct
), GFP_KERNEL
);
179 static void tty_buffer_free_all(struct tty_struct
*);
182 * free_tty_struct - free a disused tty
183 * @tty: tty struct to free
185 * Free the write buffers, tty queue and tty memory itself.
187 * Locking: none. Must be called after tty is definitely unused
190 static inline void free_tty_struct(struct tty_struct
*tty
)
192 kfree(tty
->write_buf
);
193 tty_buffer_free_all(tty
);
197 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
200 * tty_name - return tty naming
201 * @tty: tty structure
202 * @buf: buffer for output
204 * Convert a tty structure into a name. The name reflects the kernel
205 * naming policy and if udev is in use may not reflect user space
210 char *tty_name(struct tty_struct
*tty
, char *buf
)
212 if (!tty
) /* Hmm. NULL pointer. That's fun. */
213 strcpy(buf
, "NULL tty");
215 strcpy(buf
, tty
->name
);
219 EXPORT_SYMBOL(tty_name
);
221 int tty_paranoia_check(struct tty_struct
*tty
, struct inode
*inode
,
224 #ifdef TTY_PARANOIA_CHECK
227 "null TTY for (%d:%d) in %s\n",
228 imajor(inode
), iminor(inode
), routine
);
231 if (tty
->magic
!= TTY_MAGIC
) {
233 "bad magic number for tty struct (%d:%d) in %s\n",
234 imajor(inode
), iminor(inode
), routine
);
241 static int check_tty_count(struct tty_struct
*tty
, const char *routine
)
243 #ifdef CHECK_TTY_COUNT
248 list_for_each(p
, &tty
->tty_files
) {
252 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
253 tty
->driver
->subtype
== PTY_TYPE_SLAVE
&&
254 tty
->link
&& tty
->link
->count
)
256 if (tty
->count
!= count
) {
257 printk(KERN_WARNING
"Warning: dev (%s) tty->count(%d) "
258 "!= #fd's(%d) in %s\n",
259 tty
->name
, tty
->count
, count
, routine
);
267 * Tty buffer allocation management
271 * tty_buffer_free_all - free buffers used by a tty
272 * @tty: tty to free from
274 * Remove all the buffers pending on a tty whether queued with data
275 * or in the free ring. Must be called when the tty is no longer in use
280 static void tty_buffer_free_all(struct tty_struct
*tty
)
282 struct tty_buffer
*thead
;
283 while((thead
= tty
->buf
.head
) != NULL
) {
284 tty
->buf
.head
= thead
->next
;
287 while((thead
= tty
->buf
.free
) != NULL
) {
288 tty
->buf
.free
= thead
->next
;
291 tty
->buf
.tail
= NULL
;
292 tty
->buf
.memory_used
= 0;
296 * tty_buffer_init - prepare a tty buffer structure
297 * @tty: tty to initialise
299 * Set up the initial state of the buffer management for a tty device.
300 * Must be called before the other tty buffer functions are used.
305 static void tty_buffer_init(struct tty_struct
*tty
)
307 spin_lock_init(&tty
->buf
.lock
);
308 tty
->buf
.head
= NULL
;
309 tty
->buf
.tail
= NULL
;
310 tty
->buf
.free
= NULL
;
311 tty
->buf
.memory_used
= 0;
315 * tty_buffer_alloc - allocate a tty buffer
317 * @size: desired size (characters)
319 * Allocate a new tty buffer to hold the desired number of characters.
320 * Return NULL if out of memory or the allocation would exceed the
323 * Locking: Caller must hold tty->buf.lock
326 static struct tty_buffer
*tty_buffer_alloc(struct tty_struct
*tty
, size_t size
)
328 struct tty_buffer
*p
;
330 if (tty
->buf
.memory_used
+ size
> 65536)
332 p
= kmalloc(sizeof(struct tty_buffer
) + 2 * size
, GFP_ATOMIC
);
340 p
->char_buf_ptr
= (char *)(p
->data
);
341 p
->flag_buf_ptr
= (unsigned char *)p
->char_buf_ptr
+ size
;
342 tty
->buf
.memory_used
+= size
;
347 * tty_buffer_free - free a tty buffer
348 * @tty: tty owning the buffer
349 * @b: the buffer to free
351 * Free a tty buffer, or add it to the free list according to our
354 * Locking: Caller must hold tty->buf.lock
357 static void tty_buffer_free(struct tty_struct
*tty
, struct tty_buffer
*b
)
359 /* Dumb strategy for now - should keep some stats */
360 tty
->buf
.memory_used
-= b
->size
;
361 WARN_ON(tty
->buf
.memory_used
< 0);
366 b
->next
= tty
->buf
.free
;
372 * tty_buffer_find - find a free tty buffer
373 * @tty: tty owning the buffer
374 * @size: characters wanted
376 * Locate an existing suitable tty buffer or if we are lacking one then
377 * allocate a new one. We round our buffers off in 256 character chunks
378 * to get better allocation behaviour.
380 * Locking: Caller must hold tty->buf.lock
383 static struct tty_buffer
*tty_buffer_find(struct tty_struct
*tty
, size_t size
)
385 struct tty_buffer
**tbh
= &tty
->buf
.free
;
386 while((*tbh
) != NULL
) {
387 struct tty_buffer
*t
= *tbh
;
388 if(t
->size
>= size
) {
394 tty
->buf
.memory_used
+= t
->size
;
397 tbh
= &((*tbh
)->next
);
399 /* Round the buffer size out */
400 size
= (size
+ 0xFF) & ~ 0xFF;
401 return tty_buffer_alloc(tty
, size
);
402 /* Should possibly check if this fails for the largest buffer we
403 have queued and recycle that ? */
407 * tty_buffer_request_room - grow tty buffer if needed
408 * @tty: tty structure
409 * @size: size desired
411 * Make at least size bytes of linear space available for the tty
412 * buffer. If we fail return the size we managed to find.
414 * Locking: Takes tty->buf.lock
416 int tty_buffer_request_room(struct tty_struct
*tty
, size_t size
)
418 struct tty_buffer
*b
, *n
;
422 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
424 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
425 remove this conditional if its worth it. This would be invisible
427 if ((b
= tty
->buf
.tail
) != NULL
)
428 left
= b
->size
- b
->used
;
433 /* This is the slow path - looking for new buffers to use */
434 if ((n
= tty_buffer_find(tty
, size
)) != NULL
) {
445 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
448 EXPORT_SYMBOL_GPL(tty_buffer_request_room
);
451 * tty_insert_flip_string - Add characters to the tty buffer
452 * @tty: tty structure
456 * Queue a series of bytes to the tty buffering. All the characters
457 * passed are marked as without error. Returns the number added.
459 * Locking: Called functions may take tty->buf.lock
462 int tty_insert_flip_string(struct tty_struct
*tty
, const unsigned char *chars
,
467 int space
= tty_buffer_request_room(tty
, size
- copied
);
468 struct tty_buffer
*tb
= tty
->buf
.tail
;
469 /* If there is no space then tb may be NULL */
470 if(unlikely(space
== 0))
472 memcpy(tb
->char_buf_ptr
+ tb
->used
, chars
, space
);
473 memset(tb
->flag_buf_ptr
+ tb
->used
, TTY_NORMAL
, space
);
477 /* There is a small chance that we need to split the data over
478 several buffers. If this is the case we must loop */
479 } while (unlikely(size
> copied
));
482 EXPORT_SYMBOL(tty_insert_flip_string
);
485 * tty_insert_flip_string_flags - Add characters to the tty buffer
486 * @tty: tty structure
491 * Queue a series of bytes to the tty buffering. For each character
492 * the flags array indicates the status of the character. Returns the
495 * Locking: Called functions may take tty->buf.lock
498 int tty_insert_flip_string_flags(struct tty_struct
*tty
,
499 const unsigned char *chars
, const char *flags
, size_t size
)
503 int space
= tty_buffer_request_room(tty
, size
- copied
);
504 struct tty_buffer
*tb
= tty
->buf
.tail
;
505 /* If there is no space then tb may be NULL */
506 if(unlikely(space
== 0))
508 memcpy(tb
->char_buf_ptr
+ tb
->used
, chars
, space
);
509 memcpy(tb
->flag_buf_ptr
+ tb
->used
, flags
, space
);
514 /* There is a small chance that we need to split the data over
515 several buffers. If this is the case we must loop */
516 } while (unlikely(size
> copied
));
519 EXPORT_SYMBOL(tty_insert_flip_string_flags
);
522 * tty_schedule_flip - push characters to ldisc
523 * @tty: tty to push from
525 * Takes any pending buffers and transfers their ownership to the
526 * ldisc side of the queue. It then schedules those characters for
527 * processing by the line discipline.
529 * Locking: Takes tty->buf.lock
532 void tty_schedule_flip(struct tty_struct
*tty
)
535 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
536 if (tty
->buf
.tail
!= NULL
)
537 tty
->buf
.tail
->commit
= tty
->buf
.tail
->used
;
538 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
539 schedule_delayed_work(&tty
->buf
.work
, 1);
541 EXPORT_SYMBOL(tty_schedule_flip
);
544 * tty_prepare_flip_string - make room for characters
546 * @chars: return pointer for character write area
547 * @size: desired size
549 * Prepare a block of space in the buffer for data. Returns the length
550 * available and buffer pointer to the space which is now allocated and
551 * accounted for as ready for normal characters. This is used for drivers
552 * that need their own block copy routines into the buffer. There is no
553 * guarantee the buffer is a DMA target!
555 * Locking: May call functions taking tty->buf.lock
558 int tty_prepare_flip_string(struct tty_struct
*tty
, unsigned char **chars
, size_t size
)
560 int space
= tty_buffer_request_room(tty
, size
);
562 struct tty_buffer
*tb
= tty
->buf
.tail
;
563 *chars
= tb
->char_buf_ptr
+ tb
->used
;
564 memset(tb
->flag_buf_ptr
+ tb
->used
, TTY_NORMAL
, space
);
570 EXPORT_SYMBOL_GPL(tty_prepare_flip_string
);
573 * tty_prepare_flip_string_flags - make room for characters
575 * @chars: return pointer for character write area
576 * @flags: return pointer for status flag write area
577 * @size: desired size
579 * Prepare a block of space in the buffer for data. Returns the length
580 * available and buffer pointer to the space which is now allocated and
581 * accounted for as ready for characters. This is used for drivers
582 * that need their own block copy routines into the buffer. There is no
583 * guarantee the buffer is a DMA target!
585 * Locking: May call functions taking tty->buf.lock
588 int tty_prepare_flip_string_flags(struct tty_struct
*tty
, unsigned char **chars
, char **flags
, size_t size
)
590 int space
= tty_buffer_request_room(tty
, size
);
592 struct tty_buffer
*tb
= tty
->buf
.tail
;
593 *chars
= tb
->char_buf_ptr
+ tb
->used
;
594 *flags
= tb
->flag_buf_ptr
+ tb
->used
;
600 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags
);
605 * tty_set_termios_ldisc - set ldisc field
606 * @tty: tty structure
607 * @num: line discipline number
609 * This is probably overkill for real world processors but
610 * they are not on hot paths so a little discipline won't do
613 * Locking: takes termios_mutex
616 static void tty_set_termios_ldisc(struct tty_struct
*tty
, int num
)
618 mutex_lock(&tty
->termios_mutex
);
619 tty
->termios
->c_line
= num
;
620 mutex_unlock(&tty
->termios_mutex
);
624 * This guards the refcounted line discipline lists. The lock
625 * must be taken with irqs off because there are hangup path
626 * callers who will do ldisc lookups and cannot sleep.
629 static DEFINE_SPINLOCK(tty_ldisc_lock
);
630 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait
);
631 static struct tty_ldisc tty_ldiscs
[NR_LDISCS
]; /* line disc dispatch table */
634 * tty_register_ldisc - install a line discipline
635 * @disc: ldisc number
636 * @new_ldisc: pointer to the ldisc object
638 * Installs a new line discipline into the kernel. The discipline
639 * is set up as unreferenced and then made available to the kernel
640 * from this point onwards.
643 * takes tty_ldisc_lock to guard against ldisc races
646 int tty_register_ldisc(int disc
, struct tty_ldisc
*new_ldisc
)
651 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
654 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
655 tty_ldiscs
[disc
] = *new_ldisc
;
656 tty_ldiscs
[disc
].num
= disc
;
657 tty_ldiscs
[disc
].flags
|= LDISC_FLAG_DEFINED
;
658 tty_ldiscs
[disc
].refcount
= 0;
659 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
663 EXPORT_SYMBOL(tty_register_ldisc
);
666 * tty_unregister_ldisc - unload a line discipline
667 * @disc: ldisc number
668 * @new_ldisc: pointer to the ldisc object
670 * Remove a line discipline from the kernel providing it is not
674 * takes tty_ldisc_lock to guard against ldisc races
677 int tty_unregister_ldisc(int disc
)
682 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
685 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
686 if (tty_ldiscs
[disc
].refcount
)
689 tty_ldiscs
[disc
].flags
&= ~LDISC_FLAG_DEFINED
;
690 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
694 EXPORT_SYMBOL(tty_unregister_ldisc
);
697 * tty_ldisc_get - take a reference to an ldisc
698 * @disc: ldisc number
700 * Takes a reference to a line discipline. Deals with refcounts and
701 * module locking counts. Returns NULL if the discipline is not available.
702 * Returns a pointer to the discipline and bumps the ref count if it is
706 * takes tty_ldisc_lock to guard against ldisc races
709 struct tty_ldisc
*tty_ldisc_get(int disc
)
712 struct tty_ldisc
*ld
;
714 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
717 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
719 ld
= &tty_ldiscs
[disc
];
720 /* Check the entry is defined */
721 if(ld
->flags
& LDISC_FLAG_DEFINED
)
723 /* If the module is being unloaded we can't use it */
724 if (!try_module_get(ld
->owner
))
731 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
735 EXPORT_SYMBOL_GPL(tty_ldisc_get
);
738 * tty_ldisc_put - drop ldisc reference
739 * @disc: ldisc number
741 * Drop a reference to a line discipline. Manage refcounts and
742 * module usage counts
745 * takes tty_ldisc_lock to guard against ldisc races
748 void tty_ldisc_put(int disc
)
750 struct tty_ldisc
*ld
;
753 BUG_ON(disc
< N_TTY
|| disc
>= NR_LDISCS
);
755 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
756 ld
= &tty_ldiscs
[disc
];
757 BUG_ON(ld
->refcount
== 0);
759 module_put(ld
->owner
);
760 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
763 EXPORT_SYMBOL_GPL(tty_ldisc_put
);
766 * tty_ldisc_assign - set ldisc on a tty
767 * @tty: tty to assign
768 * @ld: line discipline
770 * Install an instance of a line discipline into a tty structure. The
771 * ldisc must have a reference count above zero to ensure it remains/
772 * The tty instance refcount starts at zero.
775 * Caller must hold references
778 static void tty_ldisc_assign(struct tty_struct
*tty
, struct tty_ldisc
*ld
)
781 tty
->ldisc
.refcount
= 0;
785 * tty_ldisc_try - internal helper
788 * Make a single attempt to grab and bump the refcount on
789 * the tty ldisc. Return 0 on failure or 1 on success. This is
790 * used to implement both the waiting and non waiting versions
793 * Locking: takes tty_ldisc_lock
796 static int tty_ldisc_try(struct tty_struct
*tty
)
799 struct tty_ldisc
*ld
;
802 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
804 if(test_bit(TTY_LDISC
, &tty
->flags
))
809 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
814 * tty_ldisc_ref_wait - wait for the tty ldisc
817 * Dereference the line discipline for the terminal and take a
818 * reference to it. If the line discipline is in flux then
819 * wait patiently until it changes.
821 * Note: Must not be called from an IRQ/timer context. The caller
822 * must also be careful not to hold other locks that will deadlock
823 * against a discipline change, such as an existing ldisc reference
824 * (which we check for)
826 * Locking: call functions take tty_ldisc_lock
829 struct tty_ldisc
*tty_ldisc_ref_wait(struct tty_struct
*tty
)
831 /* wait_event is a macro */
832 wait_event(tty_ldisc_wait
, tty_ldisc_try(tty
));
833 if(tty
->ldisc
.refcount
== 0)
834 printk(KERN_ERR
"tty_ldisc_ref_wait\n");
838 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait
);
841 * tty_ldisc_ref - get the tty ldisc
844 * Dereference the line discipline for the terminal and take a
845 * reference to it. If the line discipline is in flux then
846 * return NULL. Can be called from IRQ and timer functions.
848 * Locking: called functions take tty_ldisc_lock
851 struct tty_ldisc
*tty_ldisc_ref(struct tty_struct
*tty
)
853 if(tty_ldisc_try(tty
))
858 EXPORT_SYMBOL_GPL(tty_ldisc_ref
);
861 * tty_ldisc_deref - free a tty ldisc reference
862 * @ld: reference to free up
864 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
865 * be called in IRQ context.
867 * Locking: takes tty_ldisc_lock
870 void tty_ldisc_deref(struct tty_ldisc
*ld
)
876 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
877 if(ld
->refcount
== 0)
878 printk(KERN_ERR
"tty_ldisc_deref: no references.\n");
881 if(ld
->refcount
== 0)
882 wake_up(&tty_ldisc_wait
);
883 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
886 EXPORT_SYMBOL_GPL(tty_ldisc_deref
);
889 * tty_ldisc_enable - allow ldisc use
890 * @tty: terminal to activate ldisc on
892 * Set the TTY_LDISC flag when the line discipline can be called
893 * again. Do neccessary wakeups for existing sleepers.
895 * Note: nobody should set this bit except via this function. Clearing
896 * directly is allowed.
899 static void tty_ldisc_enable(struct tty_struct
*tty
)
901 set_bit(TTY_LDISC
, &tty
->flags
);
902 wake_up(&tty_ldisc_wait
);
906 * tty_set_ldisc - set line discipline
907 * @tty: the terminal to set
908 * @ldisc: the line discipline
910 * Set the discipline of a tty line. Must be called from a process
913 * Locking: takes tty_ldisc_lock.
914 * called functions take termios_mutex
917 static int tty_set_ldisc(struct tty_struct
*tty
, int ldisc
)
920 struct tty_ldisc o_ldisc
;
924 struct tty_ldisc
*ld
;
925 struct tty_struct
*o_tty
;
927 if ((ldisc
< N_TTY
) || (ldisc
>= NR_LDISCS
))
932 ld
= tty_ldisc_get(ldisc
);
933 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
934 /* Cyrus Durgin <cider@speakeasy.org> */
936 request_module("tty-ldisc-%d", ldisc
);
937 ld
= tty_ldisc_get(ldisc
);
943 * Problem: What do we do if this blocks ?
946 tty_wait_until_sent(tty
, 0);
948 if (tty
->ldisc
.num
== ldisc
) {
949 tty_ldisc_put(ldisc
);
954 * No more input please, we are switching. The new ldisc
955 * will update this value in the ldisc open function
958 tty
->receive_room
= 0;
960 o_ldisc
= tty
->ldisc
;
964 * Make sure we don't change while someone holds a
965 * reference to the line discipline. The TTY_LDISC bit
966 * prevents anyone taking a reference once it is clear.
967 * We need the lock to avoid racing reference takers.
970 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
971 if (tty
->ldisc
.refcount
|| (o_tty
&& o_tty
->ldisc
.refcount
)) {
972 if(tty
->ldisc
.refcount
) {
973 /* Free the new ldisc we grabbed. Must drop the lock
975 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
976 tty_ldisc_put(ldisc
);
978 * There are several reasons we may be busy, including
979 * random momentary I/O traffic. We must therefore
980 * retry. We could distinguish between blocking ops
981 * and retries if we made tty_ldisc_wait() smarter. That
982 * is up for discussion.
984 if (wait_event_interruptible(tty_ldisc_wait
, tty
->ldisc
.refcount
== 0) < 0)
988 if(o_tty
&& o_tty
->ldisc
.refcount
) {
989 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
990 tty_ldisc_put(ldisc
);
991 if (wait_event_interruptible(tty_ldisc_wait
, o_tty
->ldisc
.refcount
== 0) < 0)
997 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
999 if (!test_bit(TTY_LDISC
, &tty
->flags
)) {
1000 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
1001 tty_ldisc_put(ldisc
);
1002 ld
= tty_ldisc_ref_wait(tty
);
1003 tty_ldisc_deref(ld
);
1007 clear_bit(TTY_LDISC
, &tty
->flags
);
1009 clear_bit(TTY_LDISC
, &o_tty
->flags
);
1010 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
1013 * From this point on we know nobody has an ldisc
1014 * usage reference, nor can they obtain one until
1015 * we say so later on.
1018 work
= cancel_delayed_work(&tty
->buf
.work
);
1020 * Wait for ->hangup_work and ->buf.work handlers to terminate
1023 flush_scheduled_work();
1024 /* Shutdown the current discipline. */
1025 if (tty
->ldisc
.close
)
1026 (tty
->ldisc
.close
)(tty
);
1028 /* Now set up the new line discipline. */
1029 tty_ldisc_assign(tty
, ld
);
1030 tty_set_termios_ldisc(tty
, ldisc
);
1031 if (tty
->ldisc
.open
)
1032 retval
= (tty
->ldisc
.open
)(tty
);
1034 tty_ldisc_put(ldisc
);
1035 /* There is an outstanding reference here so this is safe */
1036 tty_ldisc_assign(tty
, tty_ldisc_get(o_ldisc
.num
));
1037 tty_set_termios_ldisc(tty
, tty
->ldisc
.num
);
1038 if (tty
->ldisc
.open
&& (tty
->ldisc
.open(tty
) < 0)) {
1039 tty_ldisc_put(o_ldisc
.num
);
1040 /* This driver is always present */
1041 tty_ldisc_assign(tty
, tty_ldisc_get(N_TTY
));
1042 tty_set_termios_ldisc(tty
, N_TTY
);
1043 if (tty
->ldisc
.open
) {
1044 int r
= tty
->ldisc
.open(tty
);
1047 panic("Couldn't open N_TTY ldisc for "
1049 tty_name(tty
, buf
), r
);
1053 /* At this point we hold a reference to the new ldisc and a
1054 a reference to the old ldisc. If we ended up flipping back
1055 to the existing ldisc we have two references to it */
1057 if (tty
->ldisc
.num
!= o_ldisc
.num
&& tty
->driver
->set_ldisc
)
1058 tty
->driver
->set_ldisc(tty
);
1060 tty_ldisc_put(o_ldisc
.num
);
1063 * Allow ldisc referencing to occur as soon as the driver
1064 * ldisc callback completes.
1067 tty_ldisc_enable(tty
);
1069 tty_ldisc_enable(o_tty
);
1071 /* Restart it in case no characters kick it off. Safe if
1074 schedule_delayed_work(&tty
->buf
.work
, 1);
1079 * get_tty_driver - find device of a tty
1080 * @dev_t: device identifier
1081 * @index: returns the index of the tty
1083 * This routine returns a tty driver structure, given a device number
1084 * and also passes back the index number.
1086 * Locking: caller must hold tty_mutex
1089 static struct tty_driver
*get_tty_driver(dev_t device
, int *index
)
1091 struct tty_driver
*p
;
1093 list_for_each_entry(p
, &tty_drivers
, tty_drivers
) {
1094 dev_t base
= MKDEV(p
->major
, p
->minor_start
);
1095 if (device
< base
|| device
>= base
+ p
->num
)
1097 *index
= device
- base
;
1104 * tty_check_change - check for POSIX terminal changes
1105 * @tty: tty to check
1107 * If we try to write to, or set the state of, a terminal and we're
1108 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1109 * ignored, go ahead and perform the operation. (POSIX 7.2)
1114 int tty_check_change(struct tty_struct
* tty
)
1116 if (current
->signal
->tty
!= tty
)
1119 printk(KERN_WARNING
"tty_check_change: tty->pgrp == NULL!\n");
1122 if (task_pgrp(current
) == tty
->pgrp
)
1124 if (is_ignored(SIGTTOU
))
1126 if (is_current_pgrp_orphaned())
1128 (void) kill_pgrp(task_pgrp(current
), SIGTTOU
, 1);
1129 return -ERESTARTSYS
;
1132 EXPORT_SYMBOL(tty_check_change
);
1134 static ssize_t
hung_up_tty_read(struct file
* file
, char __user
* buf
,
1135 size_t count
, loff_t
*ppos
)
1140 static ssize_t
hung_up_tty_write(struct file
* file
, const char __user
* buf
,
1141 size_t count
, loff_t
*ppos
)
1146 /* No kernel lock held - none needed ;) */
1147 static unsigned int hung_up_tty_poll(struct file
* filp
, poll_table
* wait
)
1149 return POLLIN
| POLLOUT
| POLLERR
| POLLHUP
| POLLRDNORM
| POLLWRNORM
;
1152 static long hung_up_tty_ioctl(struct file
* file
,
1153 unsigned int cmd
, unsigned long arg
)
1155 return cmd
== TIOCSPGRP
? -ENOTTY
: -EIO
;
1158 static const struct file_operations tty_fops
= {
1159 .llseek
= no_llseek
,
1164 .compat_ioctl
= tty_compat_ioctl
,
1166 .release
= tty_release
,
1167 .fasync
= tty_fasync
,
1170 #ifdef CONFIG_UNIX98_PTYS
1171 static const struct file_operations ptmx_fops
= {
1172 .llseek
= no_llseek
,
1177 .compat_ioctl
= tty_compat_ioctl
,
1179 .release
= tty_release
,
1180 .fasync
= tty_fasync
,
1184 static const struct file_operations console_fops
= {
1185 .llseek
= no_llseek
,
1187 .write
= redirected_tty_write
,
1190 .compat_ioctl
= tty_compat_ioctl
,
1192 .release
= tty_release
,
1193 .fasync
= tty_fasync
,
1196 static const struct file_operations hung_up_tty_fops
= {
1197 .llseek
= no_llseek
,
1198 .read
= hung_up_tty_read
,
1199 .write
= hung_up_tty_write
,
1200 .poll
= hung_up_tty_poll
,
1201 .unlocked_ioctl
= hung_up_tty_ioctl
,
1202 .compat_ioctl
= hung_up_tty_ioctl
,
1203 .release
= tty_release
,
1206 static DEFINE_SPINLOCK(redirect_lock
);
1207 static struct file
*redirect
;
1210 * tty_wakeup - request more data
1213 * Internal and external helper for wakeups of tty. This function
1214 * informs the line discipline if present that the driver is ready
1215 * to receive more output data.
1218 void tty_wakeup(struct tty_struct
*tty
)
1220 struct tty_ldisc
*ld
;
1222 if (test_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
)) {
1223 ld
= tty_ldisc_ref(tty
);
1225 if(ld
->write_wakeup
)
1226 ld
->write_wakeup(tty
);
1227 tty_ldisc_deref(ld
);
1230 wake_up_interruptible(&tty
->write_wait
);
1233 EXPORT_SYMBOL_GPL(tty_wakeup
);
1236 * tty_ldisc_flush - flush line discipline queue
1239 * Flush the line discipline queue (if any) for this tty. If there
1240 * is no line discipline active this is a no-op.
1243 void tty_ldisc_flush(struct tty_struct
*tty
)
1245 struct tty_ldisc
*ld
= tty_ldisc_ref(tty
);
1247 if(ld
->flush_buffer
)
1248 ld
->flush_buffer(tty
);
1249 tty_ldisc_deref(ld
);
1253 EXPORT_SYMBOL_GPL(tty_ldisc_flush
);
1256 * tty_reset_termios - reset terminal state
1257 * @tty: tty to reset
1259 * Restore a terminal to the driver default state
1262 static void tty_reset_termios(struct tty_struct
*tty
)
1264 mutex_lock(&tty
->termios_mutex
);
1265 *tty
->termios
= tty
->driver
->init_termios
;
1266 tty
->termios
->c_ispeed
= tty_termios_input_baud_rate(tty
->termios
);
1267 tty
->termios
->c_ospeed
= tty_termios_baud_rate(tty
->termios
);
1268 mutex_unlock(&tty
->termios_mutex
);
1272 * do_tty_hangup - actual handler for hangup events
1275 * This can be called by the "eventd" kernel thread. That is process
1276 * synchronous but doesn't hold any locks, so we need to make sure we
1277 * have the appropriate locks for what we're doing.
1279 * The hangup event clears any pending redirections onto the hung up
1280 * device. It ensures future writes will error and it does the needed
1281 * line discipline hangup and signal delivery. The tty object itself
1286 * redirect lock for undoing redirection
1287 * file list lock for manipulating list of ttys
1288 * tty_ldisc_lock from called functions
1289 * termios_mutex resetting termios data
1290 * tasklist_lock to walk task list for hangup event
1291 * ->siglock to protect ->signal/->sighand
1293 static void do_tty_hangup(struct work_struct
*work
)
1295 struct tty_struct
*tty
=
1296 container_of(work
, struct tty_struct
, hangup_work
);
1297 struct file
* cons_filp
= NULL
;
1298 struct file
*filp
, *f
= NULL
;
1299 struct task_struct
*p
;
1300 struct tty_ldisc
*ld
;
1301 int closecount
= 0, n
;
1306 /* inuse_filps is protected by the single kernel lock */
1309 spin_lock(&redirect_lock
);
1310 if (redirect
&& redirect
->private_data
== tty
) {
1314 spin_unlock(&redirect_lock
);
1316 check_tty_count(tty
, "do_tty_hangup");
1318 /* This breaks for file handles being sent over AF_UNIX sockets ? */
1319 list_for_each_entry(filp
, &tty
->tty_files
, f_u
.fu_list
) {
1320 if (filp
->f_op
->write
== redirected_tty_write
)
1322 if (filp
->f_op
->write
!= tty_write
)
1325 tty_fasync(-1, filp
, 0); /* can't block */
1326 filp
->f_op
= &hung_up_tty_fops
;
1330 /* FIXME! What are the locking issues here? This may me overdoing things..
1331 * this question is especially important now that we've removed the irqlock. */
1333 ld
= tty_ldisc_ref(tty
);
1334 if(ld
!= NULL
) /* We may have no line discipline at this point */
1336 if (ld
->flush_buffer
)
1337 ld
->flush_buffer(tty
);
1338 if (tty
->driver
->flush_buffer
)
1339 tty
->driver
->flush_buffer(tty
);
1340 if ((test_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
)) &&
1342 ld
->write_wakeup(tty
);
1347 /* FIXME: Once we trust the LDISC code better we can wait here for
1348 ldisc completion and fix the driver call race */
1350 wake_up_interruptible(&tty
->write_wait
);
1351 wake_up_interruptible(&tty
->read_wait
);
1354 * Shutdown the current line discipline, and reset it to
1357 if (tty
->driver
->flags
& TTY_DRIVER_RESET_TERMIOS
)
1358 tty_reset_termios(tty
);
1360 /* Defer ldisc switch */
1361 /* tty_deferred_ldisc_switch(N_TTY);
1363 This should get done automatically when the port closes and
1364 tty_release is called */
1366 read_lock(&tasklist_lock
);
1368 do_each_pid_task(tty
->session
, PIDTYPE_SID
, p
) {
1369 spin_lock_irq(&p
->sighand
->siglock
);
1370 if (p
->signal
->tty
== tty
)
1371 p
->signal
->tty
= NULL
;
1372 if (!p
->signal
->leader
) {
1373 spin_unlock_irq(&p
->sighand
->siglock
);
1376 __group_send_sig_info(SIGHUP
, SEND_SIG_PRIV
, p
);
1377 __group_send_sig_info(SIGCONT
, SEND_SIG_PRIV
, p
);
1378 put_pid(p
->signal
->tty_old_pgrp
); /* A noop */
1380 p
->signal
->tty_old_pgrp
= get_pid(tty
->pgrp
);
1381 spin_unlock_irq(&p
->sighand
->siglock
);
1382 } while_each_pid_task(tty
->session
, PIDTYPE_SID
, p
);
1384 read_unlock(&tasklist_lock
);
1387 put_pid(tty
->session
);
1389 tty
->session
= NULL
;
1391 tty
->ctrl_status
= 0;
1393 * If one of the devices matches a console pointer, we
1394 * cannot just call hangup() because that will cause
1395 * tty->count and state->count to go out of sync.
1396 * So we just call close() the right number of times.
1399 if (tty
->driver
->close
)
1400 for (n
= 0; n
< closecount
; n
++)
1401 tty
->driver
->close(tty
, cons_filp
);
1402 } else if (tty
->driver
->hangup
)
1403 (tty
->driver
->hangup
)(tty
);
1405 /* We don't want to have driver/ldisc interactions beyond
1406 the ones we did here. The driver layer expects no
1407 calls after ->hangup() from the ldisc side. However we
1408 can't yet guarantee all that */
1410 set_bit(TTY_HUPPED
, &tty
->flags
);
1412 tty_ldisc_enable(tty
);
1413 tty_ldisc_deref(ld
);
1421 * tty_hangup - trigger a hangup event
1422 * @tty: tty to hangup
1424 * A carrier loss (virtual or otherwise) has occurred on this like
1425 * schedule a hangup sequence to run after this event.
1428 void tty_hangup(struct tty_struct
* tty
)
1430 #ifdef TTY_DEBUG_HANGUP
1433 printk(KERN_DEBUG
"%s hangup...\n", tty_name(tty
, buf
));
1435 schedule_work(&tty
->hangup_work
);
1438 EXPORT_SYMBOL(tty_hangup
);
1441 * tty_vhangup - process vhangup
1442 * @tty: tty to hangup
1444 * The user has asked via system call for the terminal to be hung up.
1445 * We do this synchronously so that when the syscall returns the process
1446 * is complete. That guarantee is neccessary for security reasons.
1449 void tty_vhangup(struct tty_struct
* tty
)
1451 #ifdef TTY_DEBUG_HANGUP
1454 printk(KERN_DEBUG
"%s vhangup...\n", tty_name(tty
, buf
));
1456 do_tty_hangup(&tty
->hangup_work
);
1458 EXPORT_SYMBOL(tty_vhangup
);
1461 * tty_hung_up_p - was tty hung up
1462 * @filp: file pointer of tty
1464 * Return true if the tty has been subject to a vhangup or a carrier
1468 int tty_hung_up_p(struct file
* filp
)
1470 return (filp
->f_op
== &hung_up_tty_fops
);
1473 EXPORT_SYMBOL(tty_hung_up_p
);
1475 static void session_clear_tty(struct pid
*session
)
1477 struct task_struct
*p
;
1478 do_each_pid_task(session
, PIDTYPE_SID
, p
) {
1480 } while_each_pid_task(session
, PIDTYPE_SID
, p
);
1484 * disassociate_ctty - disconnect controlling tty
1485 * @on_exit: true if exiting so need to "hang up" the session
1487 * This function is typically called only by the session leader, when
1488 * it wants to disassociate itself from its controlling tty.
1490 * It performs the following functions:
1491 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1492 * (2) Clears the tty from being controlling the session
1493 * (3) Clears the controlling tty for all processes in the
1496 * The argument on_exit is set to 1 if called when a process is
1497 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1500 * BKL is taken for hysterical raisins
1501 * tty_mutex is taken to protect tty
1502 * ->siglock is taken to protect ->signal/->sighand
1503 * tasklist_lock is taken to walk process list for sessions
1504 * ->siglock is taken to protect ->signal/->sighand
1507 void disassociate_ctty(int on_exit
)
1509 struct tty_struct
*tty
;
1510 struct pid
*tty_pgrp
= NULL
;
1514 mutex_lock(&tty_mutex
);
1515 tty
= get_current_tty();
1517 tty_pgrp
= get_pid(tty
->pgrp
);
1518 mutex_unlock(&tty_mutex
);
1519 /* XXX: here we race, there is nothing protecting tty */
1520 if (on_exit
&& tty
->driver
->type
!= TTY_DRIVER_TYPE_PTY
)
1522 } else if (on_exit
) {
1523 struct pid
*old_pgrp
;
1524 spin_lock_irq(¤t
->sighand
->siglock
);
1525 old_pgrp
= current
->signal
->tty_old_pgrp
;
1526 current
->signal
->tty_old_pgrp
= NULL
;
1527 spin_unlock_irq(¤t
->sighand
->siglock
);
1529 kill_pgrp(old_pgrp
, SIGHUP
, on_exit
);
1530 kill_pgrp(old_pgrp
, SIGCONT
, on_exit
);
1533 mutex_unlock(&tty_mutex
);
1538 kill_pgrp(tty_pgrp
, SIGHUP
, on_exit
);
1540 kill_pgrp(tty_pgrp
, SIGCONT
, on_exit
);
1544 spin_lock_irq(¤t
->sighand
->siglock
);
1545 put_pid(current
->signal
->tty_old_pgrp
);
1546 current
->signal
->tty_old_pgrp
= NULL
;
1547 spin_unlock_irq(¤t
->sighand
->siglock
);
1549 mutex_lock(&tty_mutex
);
1550 /* It is possible that do_tty_hangup has free'd this tty */
1551 tty
= get_current_tty();
1553 put_pid(tty
->session
);
1555 tty
->session
= NULL
;
1558 #ifdef TTY_DEBUG_HANGUP
1559 printk(KERN_DEBUG
"error attempted to write to tty [0x%p]"
1563 mutex_unlock(&tty_mutex
);
1565 /* Now clear signal->tty under the lock */
1566 read_lock(&tasklist_lock
);
1567 session_clear_tty(task_session(current
));
1568 read_unlock(&tasklist_lock
);
1574 * no_tty - Ensure the current process does not have a controlling tty
1578 struct task_struct
*tsk
= current
;
1579 if (tsk
->signal
->leader
)
1580 disassociate_ctty(0);
1581 proc_clear_tty(tsk
);
1586 * stop_tty - propagate flow control
1589 * Perform flow control to the driver. For PTY/TTY pairs we
1590 * must also propagate the TIOCKPKT status. May be called
1591 * on an already stopped device and will not re-call the driver
1594 * This functionality is used by both the line disciplines for
1595 * halting incoming flow and by the driver. It may therefore be
1596 * called from any context, may be under the tty atomic_write_lock
1600 * Broken. Relies on BKL which is unsafe here.
1603 void stop_tty(struct tty_struct
*tty
)
1608 if (tty
->link
&& tty
->link
->packet
) {
1609 tty
->ctrl_status
&= ~TIOCPKT_START
;
1610 tty
->ctrl_status
|= TIOCPKT_STOP
;
1611 wake_up_interruptible(&tty
->link
->read_wait
);
1613 if (tty
->driver
->stop
)
1614 (tty
->driver
->stop
)(tty
);
1617 EXPORT_SYMBOL(stop_tty
);
1620 * start_tty - propagate flow control
1621 * @tty: tty to start
1623 * Start a tty that has been stopped if at all possible. Perform
1624 * any neccessary wakeups and propagate the TIOCPKT status. If this
1625 * is the tty was previous stopped and is being started then the
1626 * driver start method is invoked and the line discipline woken.
1629 * Broken. Relies on BKL which is unsafe here.
1632 void start_tty(struct tty_struct
*tty
)
1634 if (!tty
->stopped
|| tty
->flow_stopped
)
1637 if (tty
->link
&& tty
->link
->packet
) {
1638 tty
->ctrl_status
&= ~TIOCPKT_STOP
;
1639 tty
->ctrl_status
|= TIOCPKT_START
;
1640 wake_up_interruptible(&tty
->link
->read_wait
);
1642 if (tty
->driver
->start
)
1643 (tty
->driver
->start
)(tty
);
1645 /* If we have a running line discipline it may need kicking */
1649 EXPORT_SYMBOL(start_tty
);
1652 * tty_read - read method for tty device files
1653 * @file: pointer to tty file
1655 * @count: size of user buffer
1658 * Perform the read system call function on this terminal device. Checks
1659 * for hung up devices before calling the line discipline method.
1662 * Locks the line discipline internally while needed
1663 * For historical reasons the line discipline read method is
1664 * invoked under the BKL. This will go away in time so do not rely on it
1665 * in new code. Multiple read calls may be outstanding in parallel.
1668 static ssize_t
tty_read(struct file
* file
, char __user
* buf
, size_t count
,
1672 struct tty_struct
* tty
;
1673 struct inode
*inode
;
1674 struct tty_ldisc
*ld
;
1676 tty
= (struct tty_struct
*)file
->private_data
;
1677 inode
= file
->f_path
.dentry
->d_inode
;
1678 if (tty_paranoia_check(tty
, inode
, "tty_read"))
1680 if (!tty
|| (test_bit(TTY_IO_ERROR
, &tty
->flags
)))
1683 /* We want to wait for the line discipline to sort out in this
1685 ld
= tty_ldisc_ref_wait(tty
);
1688 i
= (ld
->read
)(tty
,file
,buf
,count
);
1691 tty_ldisc_deref(ld
);
1694 inode
->i_atime
= current_fs_time(inode
->i_sb
);
1699 * Split writes up in sane blocksizes to avoid
1700 * denial-of-service type attacks
1702 static inline ssize_t
do_tty_write(
1703 ssize_t (*write
)(struct tty_struct
*, struct file
*, const unsigned char *, size_t),
1704 struct tty_struct
*tty
,
1706 const char __user
*buf
,
1709 ssize_t ret
= 0, written
= 0;
1712 /* FIXME: O_NDELAY ... */
1713 if (mutex_lock_interruptible(&tty
->atomic_write_lock
)) {
1714 return -ERESTARTSYS
;
1718 * We chunk up writes into a temporary buffer. This
1719 * simplifies low-level drivers immensely, since they
1720 * don't have locking issues and user mode accesses.
1722 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1725 * The default chunk-size is 2kB, because the NTTY
1726 * layer has problems with bigger chunks. It will
1727 * claim to be able to handle more characters than
1730 * FIXME: This can probably go away now except that 64K chunks
1731 * are too likely to fail unless switched to vmalloc...
1734 if (test_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
))
1739 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1740 if (tty
->write_cnt
< chunk
) {
1746 buf
= kmalloc(chunk
, GFP_KERNEL
);
1748 mutex_unlock(&tty
->atomic_write_lock
);
1751 kfree(tty
->write_buf
);
1752 tty
->write_cnt
= chunk
;
1753 tty
->write_buf
= buf
;
1756 /* Do the write .. */
1758 size_t size
= count
;
1762 if (copy_from_user(tty
->write_buf
, buf
, size
))
1765 ret
= write(tty
, file
, tty
->write_buf
, size
);
1775 if (signal_pending(current
))
1780 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1781 inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1784 mutex_unlock(&tty
->atomic_write_lock
);
1790 * tty_write - write method for tty device file
1791 * @file: tty file pointer
1792 * @buf: user data to write
1793 * @count: bytes to write
1796 * Write data to a tty device via the line discipline.
1799 * Locks the line discipline as required
1800 * Writes to the tty driver are serialized by the atomic_write_lock
1801 * and are then processed in chunks to the device. The line discipline
1802 * write method will not be involked in parallel for each device
1803 * The line discipline write method is called under the big
1804 * kernel lock for historical reasons. New code should not rely on this.
1807 static ssize_t
tty_write(struct file
* file
, const char __user
* buf
, size_t count
,
1810 struct tty_struct
* tty
;
1811 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1813 struct tty_ldisc
*ld
;
1815 tty
= (struct tty_struct
*)file
->private_data
;
1816 if (tty_paranoia_check(tty
, inode
, "tty_write"))
1818 if (!tty
|| !tty
->driver
->write
|| (test_bit(TTY_IO_ERROR
, &tty
->flags
)))
1821 ld
= tty_ldisc_ref_wait(tty
);
1825 ret
= do_tty_write(ld
->write
, tty
, file
, buf
, count
);
1826 tty_ldisc_deref(ld
);
1830 ssize_t
redirected_tty_write(struct file
* file
, const char __user
* buf
, size_t count
,
1833 struct file
*p
= NULL
;
1835 spin_lock(&redirect_lock
);
1840 spin_unlock(&redirect_lock
);
1844 res
= vfs_write(p
, buf
, count
, &p
->f_pos
);
1849 return tty_write(file
, buf
, count
, ppos
);
1852 static char ptychar
[] = "pqrstuvwxyzabcde";
1855 * pty_line_name - generate name for a pty
1856 * @driver: the tty driver in use
1857 * @index: the minor number
1858 * @p: output buffer of at least 6 bytes
1860 * Generate a name from a driver reference and write it to the output
1865 static void pty_line_name(struct tty_driver
*driver
, int index
, char *p
)
1867 int i
= index
+ driver
->name_base
;
1868 /* ->name is initialized to "ttyp", but "tty" is expected */
1869 sprintf(p
, "%s%c%x",
1870 driver
->subtype
== PTY_TYPE_SLAVE
? "tty" : driver
->name
,
1871 ptychar
[i
>> 4 & 0xf], i
& 0xf);
1875 * pty_line_name - generate name for a tty
1876 * @driver: the tty driver in use
1877 * @index: the minor number
1878 * @p: output buffer of at least 7 bytes
1880 * Generate a name from a driver reference and write it to the output
1885 static void tty_line_name(struct tty_driver
*driver
, int index
, char *p
)
1887 sprintf(p
, "%s%d", driver
->name
, index
+ driver
->name_base
);
1891 * init_dev - initialise a tty device
1892 * @driver: tty driver we are opening a device on
1893 * @idx: device index
1894 * @tty: returned tty structure
1896 * Prepare a tty device. This may not be a "new" clean device but
1897 * could also be an active device. The pty drivers require special
1898 * handling because of this.
1901 * The function is called under the tty_mutex, which
1902 * protects us from the tty struct or driver itself going away.
1904 * On exit the tty device has the line discipline attached and
1905 * a reference count of 1. If a pair was created for pty/tty use
1906 * and the other was a pty master then it too has a reference count of 1.
1908 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1909 * failed open. The new code protects the open with a mutex, so it's
1910 * really quite straightforward. The mutex locking can probably be
1911 * relaxed for the (most common) case of reopening a tty.
1914 static int init_dev(struct tty_driver
*driver
, int idx
,
1915 struct tty_struct
**ret_tty
)
1917 struct tty_struct
*tty
, *o_tty
;
1918 struct ktermios
*tp
, **tp_loc
, *o_tp
, **o_tp_loc
;
1919 struct ktermios
*ltp
, **ltp_loc
, *o_ltp
, **o_ltp_loc
;
1922 /* check whether we're reopening an existing tty */
1923 if (driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) {
1924 tty
= devpts_get_tty(idx
);
1926 * If we don't have a tty here on a slave open, it's because
1927 * the master already started the close process and there's
1928 * no relation between devpts file and tty anymore.
1930 if (!tty
&& driver
->subtype
== PTY_TYPE_SLAVE
) {
1935 * It's safe from now on because init_dev() is called with
1936 * tty_mutex held and release_dev() won't change tty->count
1937 * or tty->flags without having to grab tty_mutex
1939 if (tty
&& driver
->subtype
== PTY_TYPE_MASTER
)
1942 tty
= driver
->ttys
[idx
];
1944 if (tty
) goto fast_track
;
1947 * First time open is complex, especially for PTY devices.
1948 * This code guarantees that either everything succeeds and the
1949 * TTY is ready for operation, or else the table slots are vacated
1950 * and the allocated memory released. (Except that the termios
1951 * and locked termios may be retained.)
1954 if (!try_module_get(driver
->owner
)) {
1963 tty
= alloc_tty_struct();
1966 initialize_tty_struct(tty
);
1967 tty
->driver
= driver
;
1969 tty_line_name(driver
, idx
, tty
->name
);
1971 if (driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) {
1972 tp_loc
= &tty
->termios
;
1973 ltp_loc
= &tty
->termios_locked
;
1975 tp_loc
= &driver
->termios
[idx
];
1976 ltp_loc
= &driver
->termios_locked
[idx
];
1980 tp
= (struct ktermios
*) kmalloc(sizeof(struct ktermios
),
1984 *tp
= driver
->init_termios
;
1988 ltp
= (struct ktermios
*) kmalloc(sizeof(struct ktermios
),
1992 memset(ltp
, 0, sizeof(struct ktermios
));
1995 if (driver
->type
== TTY_DRIVER_TYPE_PTY
) {
1996 o_tty
= alloc_tty_struct();
1999 initialize_tty_struct(o_tty
);
2000 o_tty
->driver
= driver
->other
;
2002 tty_line_name(driver
->other
, idx
, o_tty
->name
);
2004 if (driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) {
2005 o_tp_loc
= &o_tty
->termios
;
2006 o_ltp_loc
= &o_tty
->termios_locked
;
2008 o_tp_loc
= &driver
->other
->termios
[idx
];
2009 o_ltp_loc
= &driver
->other
->termios_locked
[idx
];
2013 o_tp
= (struct ktermios
*)
2014 kmalloc(sizeof(struct ktermios
), GFP_KERNEL
);
2017 *o_tp
= driver
->other
->init_termios
;
2021 o_ltp
= (struct ktermios
*)
2022 kmalloc(sizeof(struct ktermios
), GFP_KERNEL
);
2025 memset(o_ltp
, 0, sizeof(struct ktermios
));
2029 * Everything allocated ... set up the o_tty structure.
2031 if (!(driver
->other
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
2032 driver
->other
->ttys
[idx
] = o_tty
;
2038 o_tty
->termios
= *o_tp_loc
;
2039 o_tty
->termios_locked
= *o_ltp_loc
;
2040 driver
->other
->refcount
++;
2041 if (driver
->subtype
== PTY_TYPE_MASTER
)
2044 /* Establish the links in both directions */
2050 * All structures have been allocated, so now we install them.
2051 * Failures after this point use release_tty to clean up, so
2052 * there's no need to null out the local pointers.
2054 if (!(driver
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
2055 driver
->ttys
[idx
] = tty
;
2062 tty
->termios
= *tp_loc
;
2063 tty
->termios_locked
= *ltp_loc
;
2064 /* Compatibility until drivers always set this */
2065 tty
->termios
->c_ispeed
= tty_termios_input_baud_rate(tty
->termios
);
2066 tty
->termios
->c_ospeed
= tty_termios_baud_rate(tty
->termios
);
2071 * Structures all installed ... call the ldisc open routines.
2072 * If we fail here just call release_tty to clean up. No need
2073 * to decrement the use counts, as release_tty doesn't care.
2076 if (tty
->ldisc
.open
) {
2077 retval
= (tty
->ldisc
.open
)(tty
);
2079 goto release_mem_out
;
2081 if (o_tty
&& o_tty
->ldisc
.open
) {
2082 retval
= (o_tty
->ldisc
.open
)(o_tty
);
2084 if (tty
->ldisc
.close
)
2085 (tty
->ldisc
.close
)(tty
);
2086 goto release_mem_out
;
2088 tty_ldisc_enable(o_tty
);
2090 tty_ldisc_enable(tty
);
2094 * This fast open can be used if the tty is already open.
2095 * No memory is allocated, and the only failures are from
2096 * attempting to open a closing tty or attempting multiple
2097 * opens on a pty master.
2100 if (test_bit(TTY_CLOSING
, &tty
->flags
)) {
2104 if (driver
->type
== TTY_DRIVER_TYPE_PTY
&&
2105 driver
->subtype
== PTY_TYPE_MASTER
) {
2107 * special case for PTY masters: only one open permitted,
2108 * and the slave side open count is incremented as well.
2117 tty
->driver
= driver
; /* N.B. why do this every time?? */
2120 if(!test_bit(TTY_LDISC
, &tty
->flags
))
2121 printk(KERN_ERR
"init_dev but no ldisc\n");
2125 /* All paths come through here to release the mutex */
2129 /* Release locally allocated memory ... nothing placed in slots */
2133 free_tty_struct(o_tty
);
2136 free_tty_struct(tty
);
2139 module_put(driver
->owner
);
2143 /* call the tty release_tty routine to clean out this slot */
2145 if (printk_ratelimit())
2146 printk(KERN_INFO
"init_dev: ldisc open failed, "
2147 "clearing slot %d\n", idx
);
2148 release_tty(tty
, idx
);
2153 * release_one_tty - release tty structure memory
2155 * Releases memory associated with a tty structure, and clears out the
2156 * driver table slots. This function is called when a device is no longer
2157 * in use. It also gets called when setup of a device fails.
2160 * tty_mutex - sometimes only
2161 * takes the file list lock internally when working on the list
2162 * of ttys that the driver keeps.
2163 * FIXME: should we require tty_mutex is held here ??
2165 static void release_one_tty(struct tty_struct
*tty
, int idx
)
2167 int devpts
= tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
;
2168 struct ktermios
*tp
;
2171 tty
->driver
->ttys
[idx
] = NULL
;
2173 if (tty
->driver
->flags
& TTY_DRIVER_RESET_TERMIOS
) {
2176 tty
->driver
->termios
[idx
] = NULL
;
2179 tp
= tty
->termios_locked
;
2181 tty
->driver
->termios_locked
[idx
] = NULL
;
2187 tty
->driver
->refcount
--;
2190 list_del_init(&tty
->tty_files
);
2193 free_tty_struct(tty
);
2197 * release_tty - release tty structure memory
2199 * Release both @tty and a possible linked partner (think pty pair),
2200 * and decrement the refcount of the backing module.
2203 * tty_mutex - sometimes only
2204 * takes the file list lock internally when working on the list
2205 * of ttys that the driver keeps.
2206 * FIXME: should we require tty_mutex is held here ??
2208 static void release_tty(struct tty_struct
*tty
, int idx
)
2210 struct tty_driver
*driver
= tty
->driver
;
2213 release_one_tty(tty
->link
, idx
);
2214 release_one_tty(tty
, idx
);
2215 module_put(driver
->owner
);
2219 * Even releasing the tty structures is a tricky business.. We have
2220 * to be very careful that the structures are all released at the
2221 * same time, as interrupts might otherwise get the wrong pointers.
2223 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2224 * lead to double frees or releasing memory still in use.
2226 static void release_dev(struct file
* filp
)
2228 struct tty_struct
*tty
, *o_tty
;
2229 int pty_master
, tty_closing
, o_tty_closing
, do_sleep
;
2233 unsigned long flags
;
2235 tty
= (struct tty_struct
*)filp
->private_data
;
2236 if (tty_paranoia_check(tty
, filp
->f_path
.dentry
->d_inode
, "release_dev"))
2239 check_tty_count(tty
, "release_dev");
2241 tty_fasync(-1, filp
, 0);
2244 pty_master
= (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
2245 tty
->driver
->subtype
== PTY_TYPE_MASTER
);
2246 devpts
= (tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) != 0;
2249 #ifdef TTY_PARANOIA_CHECK
2250 if (idx
< 0 || idx
>= tty
->driver
->num
) {
2251 printk(KERN_DEBUG
"release_dev: bad idx when trying to "
2252 "free (%s)\n", tty
->name
);
2255 if (!(tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
2256 if (tty
!= tty
->driver
->ttys
[idx
]) {
2257 printk(KERN_DEBUG
"release_dev: driver.table[%d] not tty "
2258 "for (%s)\n", idx
, tty
->name
);
2261 if (tty
->termios
!= tty
->driver
->termios
[idx
]) {
2262 printk(KERN_DEBUG
"release_dev: driver.termios[%d] not termios "
2267 if (tty
->termios_locked
!= tty
->driver
->termios_locked
[idx
]) {
2268 printk(KERN_DEBUG
"release_dev: driver.termios_locked[%d] not "
2269 "termios_locked for (%s)\n",
2276 #ifdef TTY_DEBUG_HANGUP
2277 printk(KERN_DEBUG
"release_dev of %s (tty count=%d)...",
2278 tty_name(tty
, buf
), tty
->count
);
2281 #ifdef TTY_PARANOIA_CHECK
2282 if (tty
->driver
->other
&&
2283 !(tty
->driver
->flags
& TTY_DRIVER_DEVPTS_MEM
)) {
2284 if (o_tty
!= tty
->driver
->other
->ttys
[idx
]) {
2285 printk(KERN_DEBUG
"release_dev: other->table[%d] "
2286 "not o_tty for (%s)\n",
2290 if (o_tty
->termios
!= tty
->driver
->other
->termios
[idx
]) {
2291 printk(KERN_DEBUG
"release_dev: other->termios[%d] "
2292 "not o_termios for (%s)\n",
2296 if (o_tty
->termios_locked
!=
2297 tty
->driver
->other
->termios_locked
[idx
]) {
2298 printk(KERN_DEBUG
"release_dev: other->termios_locked["
2299 "%d] not o_termios_locked for (%s)\n",
2303 if (o_tty
->link
!= tty
) {
2304 printk(KERN_DEBUG
"release_dev: bad pty pointers\n");
2309 if (tty
->driver
->close
)
2310 tty
->driver
->close(tty
, filp
);
2313 * Sanity check: if tty->count is going to zero, there shouldn't be
2314 * any waiters on tty->read_wait or tty->write_wait. We test the
2315 * wait queues and kick everyone out _before_ actually starting to
2316 * close. This ensures that we won't block while releasing the tty
2319 * The test for the o_tty closing is necessary, since the master and
2320 * slave sides may close in any order. If the slave side closes out
2321 * first, its count will be one, since the master side holds an open.
2322 * Thus this test wouldn't be triggered at the time the slave closes,
2325 * Note that it's possible for the tty to be opened again while we're
2326 * flushing out waiters. By recalculating the closing flags before
2327 * each iteration we avoid any problems.
2330 /* Guard against races with tty->count changes elsewhere and
2331 opens on /dev/tty */
2333 mutex_lock(&tty_mutex
);
2334 tty_closing
= tty
->count
<= 1;
2335 o_tty_closing
= o_tty
&&
2336 (o_tty
->count
<= (pty_master
? 1 : 0));
2340 if (waitqueue_active(&tty
->read_wait
)) {
2341 wake_up(&tty
->read_wait
);
2344 if (waitqueue_active(&tty
->write_wait
)) {
2345 wake_up(&tty
->write_wait
);
2349 if (o_tty_closing
) {
2350 if (waitqueue_active(&o_tty
->read_wait
)) {
2351 wake_up(&o_tty
->read_wait
);
2354 if (waitqueue_active(&o_tty
->write_wait
)) {
2355 wake_up(&o_tty
->write_wait
);
2362 printk(KERN_WARNING
"release_dev: %s: read/write wait queue "
2363 "active!\n", tty_name(tty
, buf
));
2364 mutex_unlock(&tty_mutex
);
2369 * The closing flags are now consistent with the open counts on
2370 * both sides, and we've completed the last operation that could
2371 * block, so it's safe to proceed with closing.
2374 if (--o_tty
->count
< 0) {
2375 printk(KERN_WARNING
"release_dev: bad pty slave count "
2377 o_tty
->count
, tty_name(o_tty
, buf
));
2381 if (--tty
->count
< 0) {
2382 printk(KERN_WARNING
"release_dev: bad tty->count (%d) for %s\n",
2383 tty
->count
, tty_name(tty
, buf
));
2388 * We've decremented tty->count, so we need to remove this file
2389 * descriptor off the tty->tty_files list; this serves two
2391 * - check_tty_count sees the correct number of file descriptors
2392 * associated with this tty.
2393 * - do_tty_hangup no longer sees this file descriptor as
2394 * something that needs to be handled for hangups.
2397 filp
->private_data
= NULL
;
2400 * Perform some housekeeping before deciding whether to return.
2402 * Set the TTY_CLOSING flag if this was the last open. In the
2403 * case of a pty we may have to wait around for the other side
2404 * to close, and TTY_CLOSING makes sure we can't be reopened.
2407 set_bit(TTY_CLOSING
, &tty
->flags
);
2409 set_bit(TTY_CLOSING
, &o_tty
->flags
);
2412 * If _either_ side is closing, make sure there aren't any
2413 * processes that still think tty or o_tty is their controlling
2416 if (tty_closing
|| o_tty_closing
) {
2417 read_lock(&tasklist_lock
);
2418 session_clear_tty(tty
->session
);
2420 session_clear_tty(o_tty
->session
);
2421 read_unlock(&tasklist_lock
);
2424 mutex_unlock(&tty_mutex
);
2426 /* check whether both sides are closing ... */
2427 if (!tty_closing
|| (o_tty
&& !o_tty_closing
))
2430 #ifdef TTY_DEBUG_HANGUP
2431 printk(KERN_DEBUG
"freeing tty structure...");
2434 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2435 * kill any delayed work. As this is the final close it does not
2436 * race with the set_ldisc code path.
2438 clear_bit(TTY_LDISC
, &tty
->flags
);
2439 cancel_delayed_work(&tty
->buf
.work
);
2442 * Wait for ->hangup_work and ->buf.work handlers to terminate
2445 flush_scheduled_work();
2448 * Wait for any short term users (we know they are just driver
2449 * side waiters as the file is closing so user count on the file
2452 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
2453 while(tty
->ldisc
.refcount
)
2455 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
2456 wait_event(tty_ldisc_wait
, tty
->ldisc
.refcount
== 0);
2457 spin_lock_irqsave(&tty_ldisc_lock
, flags
);
2459 spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
2461 * Shutdown the current line discipline, and reset it to N_TTY.
2462 * N.B. why reset ldisc when we're releasing the memory??
2464 * FIXME: this MUST get fixed for the new reflocking
2466 if (tty
->ldisc
.close
)
2467 (tty
->ldisc
.close
)(tty
);
2468 tty_ldisc_put(tty
->ldisc
.num
);
2471 * Switch the line discipline back
2473 tty_ldisc_assign(tty
, tty_ldisc_get(N_TTY
));
2474 tty_set_termios_ldisc(tty
,N_TTY
);
2476 /* FIXME: could o_tty be in setldisc here ? */
2477 clear_bit(TTY_LDISC
, &o_tty
->flags
);
2478 if (o_tty
->ldisc
.close
)
2479 (o_tty
->ldisc
.close
)(o_tty
);
2480 tty_ldisc_put(o_tty
->ldisc
.num
);
2481 tty_ldisc_assign(o_tty
, tty_ldisc_get(N_TTY
));
2482 tty_set_termios_ldisc(o_tty
,N_TTY
);
2485 * The release_tty function takes care of the details of clearing
2486 * the slots and preserving the termios structure.
2488 release_tty(tty
, idx
);
2490 #ifdef CONFIG_UNIX98_PTYS
2491 /* Make this pty number available for reallocation */
2493 down(&allocated_ptys_lock
);
2494 idr_remove(&allocated_ptys
, idx
);
2495 up(&allocated_ptys_lock
);
2502 * tty_open - open a tty device
2503 * @inode: inode of device file
2504 * @filp: file pointer to tty
2506 * tty_open and tty_release keep up the tty count that contains the
2507 * number of opens done on a tty. We cannot use the inode-count, as
2508 * different inodes might point to the same tty.
2510 * Open-counting is needed for pty masters, as well as for keeping
2511 * track of serial lines: DTR is dropped when the last close happens.
2512 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2514 * The termios state of a pty is reset on first open so that
2515 * settings don't persist across reuse.
2517 * Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2518 * tty->count should protect the rest.
2519 * ->siglock protects ->signal/->sighand
2522 static int tty_open(struct inode
* inode
, struct file
* filp
)
2524 struct tty_struct
*tty
;
2526 struct tty_driver
*driver
;
2528 dev_t device
= inode
->i_rdev
;
2529 unsigned short saved_flags
= filp
->f_flags
;
2531 nonseekable_open(inode
, filp
);
2534 noctty
= filp
->f_flags
& O_NOCTTY
;
2538 mutex_lock(&tty_mutex
);
2540 if (device
== MKDEV(TTYAUX_MAJOR
,0)) {
2541 tty
= get_current_tty();
2543 mutex_unlock(&tty_mutex
);
2546 driver
= tty
->driver
;
2548 filp
->f_flags
|= O_NONBLOCK
; /* Don't let /dev/tty block */
2553 if (device
== MKDEV(TTY_MAJOR
,0)) {
2554 extern struct tty_driver
*console_driver
;
2555 driver
= console_driver
;
2561 if (device
== MKDEV(TTYAUX_MAJOR
,1)) {
2562 driver
= console_device(&index
);
2564 /* Don't let /dev/console block */
2565 filp
->f_flags
|= O_NONBLOCK
;
2569 mutex_unlock(&tty_mutex
);
2573 driver
= get_tty_driver(device
, &index
);
2575 mutex_unlock(&tty_mutex
);
2579 retval
= init_dev(driver
, index
, &tty
);
2580 mutex_unlock(&tty_mutex
);
2584 filp
->private_data
= tty
;
2585 file_move(filp
, &tty
->tty_files
);
2586 check_tty_count(tty
, "tty_open");
2587 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
2588 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
2590 #ifdef TTY_DEBUG_HANGUP
2591 printk(KERN_DEBUG
"opening %s...", tty
->name
);
2594 if (tty
->driver
->open
)
2595 retval
= tty
->driver
->open(tty
, filp
);
2599 filp
->f_flags
= saved_flags
;
2601 if (!retval
&& test_bit(TTY_EXCLUSIVE
, &tty
->flags
) && !capable(CAP_SYS_ADMIN
))
2605 #ifdef TTY_DEBUG_HANGUP
2606 printk(KERN_DEBUG
"error %d in opening %s...", retval
,
2610 if (retval
!= -ERESTARTSYS
)
2612 if (signal_pending(current
))
2616 * Need to reset f_op in case a hangup happened.
2618 if (filp
->f_op
== &hung_up_tty_fops
)
2619 filp
->f_op
= &tty_fops
;
2623 mutex_lock(&tty_mutex
);
2624 spin_lock_irq(¤t
->sighand
->siglock
);
2626 current
->signal
->leader
&&
2627 !current
->signal
->tty
&&
2628 tty
->session
== NULL
)
2629 __proc_set_tty(current
, tty
);
2630 spin_unlock_irq(¤t
->sighand
->siglock
);
2631 mutex_unlock(&tty_mutex
);
2635 #ifdef CONFIG_UNIX98_PTYS
2637 * ptmx_open - open a unix 98 pty master
2638 * @inode: inode of device file
2639 * @filp: file pointer to tty
2641 * Allocate a unix98 pty master device from the ptmx driver.
2643 * Locking: tty_mutex protects theinit_dev work. tty->count should
2645 * allocated_ptys_lock handles the list of free pty numbers
2648 static int ptmx_open(struct inode
* inode
, struct file
* filp
)
2650 struct tty_struct
*tty
;
2655 nonseekable_open(inode
, filp
);
2657 /* find a device that is not in use. */
2658 down(&allocated_ptys_lock
);
2659 if (!idr_pre_get(&allocated_ptys
, GFP_KERNEL
)) {
2660 up(&allocated_ptys_lock
);
2663 idr_ret
= idr_get_new(&allocated_ptys
, NULL
, &index
);
2665 up(&allocated_ptys_lock
);
2666 if (idr_ret
== -EAGAIN
)
2670 if (index
>= pty_limit
) {
2671 idr_remove(&allocated_ptys
, index
);
2672 up(&allocated_ptys_lock
);
2675 up(&allocated_ptys_lock
);
2677 mutex_lock(&tty_mutex
);
2678 retval
= init_dev(ptm_driver
, index
, &tty
);
2679 mutex_unlock(&tty_mutex
);
2684 set_bit(TTY_PTY_LOCK
, &tty
->flags
); /* LOCK THE SLAVE */
2685 filp
->private_data
= tty
;
2686 file_move(filp
, &tty
->tty_files
);
2689 if (devpts_pty_new(tty
->link
))
2692 check_tty_count(tty
, "tty_open");
2693 retval
= ptm_driver
->open(tty
, filp
);
2700 down(&allocated_ptys_lock
);
2701 idr_remove(&allocated_ptys
, index
);
2702 up(&allocated_ptys_lock
);
2708 * tty_release - vfs callback for close
2709 * @inode: inode of tty
2710 * @filp: file pointer for handle to tty
2712 * Called the last time each file handle is closed that references
2713 * this tty. There may however be several such references.
2716 * Takes bkl. See release_dev
2719 static int tty_release(struct inode
* inode
, struct file
* filp
)
2728 * tty_poll - check tty status
2729 * @filp: file being polled
2730 * @wait: poll wait structures to update
2732 * Call the line discipline polling method to obtain the poll
2733 * status of the device.
2735 * Locking: locks called line discipline but ldisc poll method
2736 * may be re-entered freely by other callers.
2739 static unsigned int tty_poll(struct file
* filp
, poll_table
* wait
)
2741 struct tty_struct
* tty
;
2742 struct tty_ldisc
*ld
;
2745 tty
= (struct tty_struct
*)filp
->private_data
;
2746 if (tty_paranoia_check(tty
, filp
->f_path
.dentry
->d_inode
, "tty_poll"))
2749 ld
= tty_ldisc_ref_wait(tty
);
2751 ret
= (ld
->poll
)(tty
, filp
, wait
);
2752 tty_ldisc_deref(ld
);
2756 static int tty_fasync(int fd
, struct file
* filp
, int on
)
2758 struct tty_struct
* tty
;
2761 tty
= (struct tty_struct
*)filp
->private_data
;
2762 if (tty_paranoia_check(tty
, filp
->f_path
.dentry
->d_inode
, "tty_fasync"))
2765 retval
= fasync_helper(fd
, filp
, on
, &tty
->fasync
);
2772 if (!waitqueue_active(&tty
->read_wait
))
2773 tty
->minimum_to_wake
= 1;
2776 type
= PIDTYPE_PGID
;
2778 pid
= task_pid(current
);
2781 retval
= __f_setown(filp
, pid
, type
, 0);
2785 if (!tty
->fasync
&& !waitqueue_active(&tty
->read_wait
))
2786 tty
->minimum_to_wake
= N_TTY_BUF_SIZE
;
2792 * tiocsti - fake input character
2793 * @tty: tty to fake input into
2794 * @p: pointer to character
2796 * Fake input to a tty device. Does the neccessary locking and
2799 * FIXME: does not honour flow control ??
2802 * Called functions take tty_ldisc_lock
2803 * current->signal->tty check is safe without locks
2805 * FIXME: may race normal receive processing
2808 static int tiocsti(struct tty_struct
*tty
, char __user
*p
)
2811 struct tty_ldisc
*ld
;
2813 if ((current
->signal
->tty
!= tty
) && !capable(CAP_SYS_ADMIN
))
2815 if (get_user(ch
, p
))
2817 ld
= tty_ldisc_ref_wait(tty
);
2818 ld
->receive_buf(tty
, &ch
, &mbz
, 1);
2819 tty_ldisc_deref(ld
);
2824 * tiocgwinsz - implement window query ioctl
2826 * @arg: user buffer for result
2828 * Copies the kernel idea of the window size into the user buffer.
2830 * Locking: tty->termios_mutex is taken to ensure the winsize data
2834 static int tiocgwinsz(struct tty_struct
*tty
, struct winsize __user
* arg
)
2838 mutex_lock(&tty
->termios_mutex
);
2839 err
= copy_to_user(arg
, &tty
->winsize
, sizeof(*arg
));
2840 mutex_unlock(&tty
->termios_mutex
);
2842 return err
? -EFAULT
: 0;
2846 * tiocswinsz - implement window size set ioctl
2848 * @arg: user buffer for result
2850 * Copies the user idea of the window size to the kernel. Traditionally
2851 * this is just advisory information but for the Linux console it
2852 * actually has driver level meaning and triggers a VC resize.
2855 * Called function use the console_sem is used to ensure we do
2856 * not try and resize the console twice at once.
2857 * The tty->termios_mutex is used to ensure we don't double
2858 * resize and get confused. Lock order - tty->termios_mutex before
2862 static int tiocswinsz(struct tty_struct
*tty
, struct tty_struct
*real_tty
,
2863 struct winsize __user
* arg
)
2865 struct winsize tmp_ws
;
2867 if (copy_from_user(&tmp_ws
, arg
, sizeof(*arg
)))
2870 mutex_lock(&tty
->termios_mutex
);
2871 if (!memcmp(&tmp_ws
, &tty
->winsize
, sizeof(*arg
)))
2875 if (tty
->driver
->type
== TTY_DRIVER_TYPE_CONSOLE
) {
2876 if (vc_lock_resize(tty
->driver_data
, tmp_ws
.ws_col
,
2878 mutex_unlock(&tty
->termios_mutex
);
2884 kill_pgrp(tty
->pgrp
, SIGWINCH
, 1);
2885 if ((real_tty
->pgrp
!= tty
->pgrp
) && real_tty
->pgrp
)
2886 kill_pgrp(real_tty
->pgrp
, SIGWINCH
, 1);
2887 tty
->winsize
= tmp_ws
;
2888 real_tty
->winsize
= tmp_ws
;
2890 mutex_unlock(&tty
->termios_mutex
);
2895 * tioccons - allow admin to move logical console
2896 * @file: the file to become console
2898 * Allow the adminstrator to move the redirected console device
2900 * Locking: uses redirect_lock to guard the redirect information
2903 static int tioccons(struct file
*file
)
2905 if (!capable(CAP_SYS_ADMIN
))
2907 if (file
->f_op
->write
== redirected_tty_write
) {
2909 spin_lock(&redirect_lock
);
2912 spin_unlock(&redirect_lock
);
2917 spin_lock(&redirect_lock
);
2919 spin_unlock(&redirect_lock
);
2924 spin_unlock(&redirect_lock
);
2929 * fionbio - non blocking ioctl
2930 * @file: file to set blocking value
2931 * @p: user parameter
2933 * Historical tty interfaces had a blocking control ioctl before
2934 * the generic functionality existed. This piece of history is preserved
2935 * in the expected tty API of posix OS's.
2937 * Locking: none, the open fle handle ensures it won't go away.
2940 static int fionbio(struct file
*file
, int __user
*p
)
2944 if (get_user(nonblock
, p
))
2948 file
->f_flags
|= O_NONBLOCK
;
2950 file
->f_flags
&= ~O_NONBLOCK
;
2955 * tiocsctty - set controlling tty
2956 * @tty: tty structure
2957 * @arg: user argument
2959 * This ioctl is used to manage job control. It permits a session
2960 * leader to set this tty as the controlling tty for the session.
2963 * Takes tty_mutex() to protect tty instance
2964 * Takes tasklist_lock internally to walk sessions
2965 * Takes ->siglock() when updating signal->tty
2968 static int tiocsctty(struct tty_struct
*tty
, int arg
)
2971 if (current
->signal
->leader
&& (task_session(current
) == tty
->session
))
2974 mutex_lock(&tty_mutex
);
2976 * The process must be a session leader and
2977 * not have a controlling tty already.
2979 if (!current
->signal
->leader
|| current
->signal
->tty
) {
2986 * This tty is already the controlling
2987 * tty for another session group!
2989 if ((arg
== 1) && capable(CAP_SYS_ADMIN
)) {
2993 read_lock(&tasklist_lock
);
2994 session_clear_tty(tty
->session
);
2995 read_unlock(&tasklist_lock
);
3001 proc_set_tty(current
, tty
);
3003 mutex_unlock(&tty_mutex
);
3008 * tiocgpgrp - get process group
3009 * @tty: tty passed by user
3010 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3013 * Obtain the process group of the tty. If there is no process group
3016 * Locking: none. Reference to current->signal->tty is safe.
3019 static int tiocgpgrp(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
3022 * (tty == real_tty) is a cheap way of
3023 * testing if the tty is NOT a master pty.
3025 if (tty
== real_tty
&& current
->signal
->tty
!= real_tty
)
3027 return put_user(pid_nr(real_tty
->pgrp
), p
);
3031 * tiocspgrp - attempt to set process group
3032 * @tty: tty passed by user
3033 * @real_tty: tty side device matching tty passed by user
3036 * Set the process group of the tty to the session passed. Only
3037 * permitted where the tty session is our session.
3042 static int tiocspgrp(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
3046 int retval
= tty_check_change(real_tty
);
3052 if (!current
->signal
->tty
||
3053 (current
->signal
->tty
!= real_tty
) ||
3054 (real_tty
->session
!= task_session(current
)))
3056 if (get_user(pgrp_nr
, p
))
3061 pgrp
= find_pid(pgrp_nr
);
3066 if (session_of_pgrp(pgrp
) != task_session(current
))
3069 put_pid(real_tty
->pgrp
);
3070 real_tty
->pgrp
= get_pid(pgrp
);
3077 * tiocgsid - get session id
3078 * @tty: tty passed by user
3079 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3080 * @p: pointer to returned session id
3082 * Obtain the session id of the tty. If there is no session
3085 * Locking: none. Reference to current->signal->tty is safe.
3088 static int tiocgsid(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
3091 * (tty == real_tty) is a cheap way of
3092 * testing if the tty is NOT a master pty.
3094 if (tty
== real_tty
&& current
->signal
->tty
!= real_tty
)
3096 if (!real_tty
->session
)
3098 return put_user(pid_nr(real_tty
->session
), p
);
3102 * tiocsetd - set line discipline
3104 * @p: pointer to user data
3106 * Set the line discipline according to user request.
3108 * Locking: see tty_set_ldisc, this function is just a helper
3111 static int tiocsetd(struct tty_struct
*tty
, int __user
*p
)
3115 if (get_user(ldisc
, p
))
3117 return tty_set_ldisc(tty
, ldisc
);
3121 * send_break - performed time break
3122 * @tty: device to break on
3123 * @duration: timeout in mS
3125 * Perform a timed break on hardware that lacks its own driver level
3126 * timed break functionality.
3129 * atomic_write_lock serializes
3133 static int send_break(struct tty_struct
*tty
, unsigned int duration
)
3135 if (mutex_lock_interruptible(&tty
->atomic_write_lock
))
3137 tty
->driver
->break_ctl(tty
, -1);
3138 if (!signal_pending(current
)) {
3139 msleep_interruptible(duration
);
3141 tty
->driver
->break_ctl(tty
, 0);
3142 mutex_unlock(&tty
->atomic_write_lock
);
3143 if (signal_pending(current
))
3149 * tiocmget - get modem status
3151 * @file: user file pointer
3152 * @p: pointer to result
3154 * Obtain the modem status bits from the tty driver if the feature
3155 * is supported. Return -EINVAL if it is not available.
3157 * Locking: none (up to the driver)
3160 static int tty_tiocmget(struct tty_struct
*tty
, struct file
*file
, int __user
*p
)
3162 int retval
= -EINVAL
;
3164 if (tty
->driver
->tiocmget
) {
3165 retval
= tty
->driver
->tiocmget(tty
, file
);
3168 retval
= put_user(retval
, p
);
3174 * tiocmset - set modem status
3176 * @file: user file pointer
3177 * @cmd: command - clear bits, set bits or set all
3178 * @p: pointer to desired bits
3180 * Set the modem status bits from the tty driver if the feature
3181 * is supported. Return -EINVAL if it is not available.
3183 * Locking: none (up to the driver)
3186 static int tty_tiocmset(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
,
3189 int retval
= -EINVAL
;
3191 if (tty
->driver
->tiocmset
) {
3192 unsigned int set
, clear
, val
;
3194 retval
= get_user(val
, p
);
3212 set
&= TIOCM_DTR
|TIOCM_RTS
|TIOCM_OUT1
|TIOCM_OUT2
|TIOCM_LOOP
;
3213 clear
&= TIOCM_DTR
|TIOCM_RTS
|TIOCM_OUT1
|TIOCM_OUT2
|TIOCM_LOOP
;
3215 retval
= tty
->driver
->tiocmset(tty
, file
, set
, clear
);
3221 * Split this up, as gcc can choke on it otherwise..
3223 int tty_ioctl(struct inode
* inode
, struct file
* file
,
3224 unsigned int cmd
, unsigned long arg
)
3226 struct tty_struct
*tty
, *real_tty
;
3227 void __user
*p
= (void __user
*)arg
;
3229 struct tty_ldisc
*ld
;
3231 tty
= (struct tty_struct
*)file
->private_data
;
3232 if (tty_paranoia_check(tty
, inode
, "tty_ioctl"))
3235 /* CHECKME: is this safe as one end closes ? */
3238 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
3239 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
3240 real_tty
= tty
->link
;
3243 * Break handling by driver
3245 if (!tty
->driver
->break_ctl
) {
3249 if (tty
->driver
->ioctl
)
3250 return tty
->driver
->ioctl(tty
, file
, cmd
, arg
);
3253 /* These two ioctl's always return success; even if */
3254 /* the driver doesn't support them. */
3257 if (!tty
->driver
->ioctl
)
3259 retval
= tty
->driver
->ioctl(tty
, file
, cmd
, arg
);
3260 if (retval
== -ENOIOCTLCMD
)
3267 * Factor out some common prep work
3275 retval
= tty_check_change(tty
);
3278 if (cmd
!= TIOCCBRK
) {
3279 tty_wait_until_sent(tty
, 0);
3280 if (signal_pending(current
))
3288 return tiocsti(tty
, p
);
3290 return tiocgwinsz(tty
, p
);
3292 return tiocswinsz(tty
, real_tty
, p
);
3294 return real_tty
!=tty
? -EINVAL
: tioccons(file
);
3296 return fionbio(file
, p
);
3298 set_bit(TTY_EXCLUSIVE
, &tty
->flags
);
3301 clear_bit(TTY_EXCLUSIVE
, &tty
->flags
);
3304 if (current
->signal
->tty
!= tty
)
3309 return tiocsctty(tty
, arg
);
3311 return tiocgpgrp(tty
, real_tty
, p
);
3313 return tiocspgrp(tty
, real_tty
, p
);
3315 return tiocgsid(tty
, real_tty
, p
);
3317 /* FIXME: check this is ok */
3318 return put_user(tty
->ldisc
.num
, (int __user
*)p
);
3320 return tiocsetd(tty
, p
);
3323 return tioclinux(tty
, arg
);
3328 case TIOCSBRK
: /* Turn break on, unconditionally */
3329 tty
->driver
->break_ctl(tty
, -1);
3332 case TIOCCBRK
: /* Turn break off, unconditionally */
3333 tty
->driver
->break_ctl(tty
, 0);
3335 case TCSBRK
: /* SVID version: non-zero arg --> no break */
3336 /* non-zero arg means wait for all output data
3337 * to be sent (performed above) but don't send break.
3338 * This is used by the tcdrain() termios function.
3341 return send_break(tty
, 250);
3343 case TCSBRKP
: /* support for POSIX tcsendbreak() */
3344 return send_break(tty
, arg
? arg
*100 : 250);
3347 return tty_tiocmget(tty
, file
, p
);
3352 return tty_tiocmset(tty
, file
, cmd
, p
);
3354 if (tty
->driver
->ioctl
) {
3355 retval
= (tty
->driver
->ioctl
)(tty
, file
, cmd
, arg
);
3356 if (retval
!= -ENOIOCTLCMD
)
3359 ld
= tty_ldisc_ref_wait(tty
);
3362 retval
= ld
->ioctl(tty
, file
, cmd
, arg
);
3363 if (retval
== -ENOIOCTLCMD
)
3366 tty_ldisc_deref(ld
);
3370 #ifdef CONFIG_COMPAT
3371 static long tty_compat_ioctl(struct file
* file
, unsigned int cmd
,
3374 struct inode
*inode
= file
->f_dentry
->d_inode
;
3375 struct tty_struct
*tty
= file
->private_data
;
3376 struct tty_ldisc
*ld
;
3377 int retval
= -ENOIOCTLCMD
;
3379 if (tty_paranoia_check(tty
, inode
, "tty_ioctl"))
3382 if (tty
->driver
->compat_ioctl
) {
3383 retval
= (tty
->driver
->compat_ioctl
)(tty
, file
, cmd
, arg
);
3384 if (retval
!= -ENOIOCTLCMD
)
3388 ld
= tty_ldisc_ref_wait(tty
);
3389 if (ld
->compat_ioctl
)
3390 retval
= ld
->compat_ioctl(tty
, file
, cmd
, arg
);
3391 tty_ldisc_deref(ld
);
3398 * This implements the "Secure Attention Key" --- the idea is to
3399 * prevent trojan horses by killing all processes associated with this
3400 * tty when the user hits the "Secure Attention Key". Required for
3401 * super-paranoid applications --- see the Orange Book for more details.
3403 * This code could be nicer; ideally it should send a HUP, wait a few
3404 * seconds, then send a INT, and then a KILL signal. But you then
3405 * have to coordinate with the init process, since all processes associated
3406 * with the current tty must be dead before the new getty is allowed
3409 * Now, if it would be correct ;-/ The current code has a nasty hole -
3410 * it doesn't catch files in flight. We may send the descriptor to ourselves
3411 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3413 * Nasty bug: do_SAK is being called in interrupt context. This can
3414 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3416 void __do_SAK(struct tty_struct
*tty
)
3421 struct task_struct
*g
, *p
;
3422 struct pid
*session
;
3425 struct fdtable
*fdt
;
3429 session
= tty
->session
;
3431 tty_ldisc_flush(tty
);
3433 if (tty
->driver
->flush_buffer
)
3434 tty
->driver
->flush_buffer(tty
);
3436 read_lock(&tasklist_lock
);
3437 /* Kill the entire session */
3438 do_each_pid_task(session
, PIDTYPE_SID
, p
) {
3439 printk(KERN_NOTICE
"SAK: killed process %d"
3440 " (%s): process_session(p)==tty->session\n",
3442 send_sig(SIGKILL
, p
, 1);
3443 } while_each_pid_task(session
, PIDTYPE_SID
, p
);
3444 /* Now kill any processes that happen to have the
3447 do_each_thread(g
, p
) {
3448 if (p
->signal
->tty
== tty
) {
3449 printk(KERN_NOTICE
"SAK: killed process %d"
3450 " (%s): process_session(p)==tty->session\n",
3452 send_sig(SIGKILL
, p
, 1);
3458 * We don't take a ref to the file, so we must
3459 * hold ->file_lock instead.
3461 spin_lock(&p
->files
->file_lock
);
3462 fdt
= files_fdtable(p
->files
);
3463 for (i
=0; i
< fdt
->max_fds
; i
++) {
3464 filp
= fcheck_files(p
->files
, i
);
3467 if (filp
->f_op
->read
== tty_read
&&
3468 filp
->private_data
== tty
) {
3469 printk(KERN_NOTICE
"SAK: killed process %d"
3470 " (%s): fd#%d opened to the tty\n",
3471 p
->pid
, p
->comm
, i
);
3472 force_sig(SIGKILL
, p
);
3476 spin_unlock(&p
->files
->file_lock
);
3479 } while_each_thread(g
, p
);
3480 read_unlock(&tasklist_lock
);
3484 static void do_SAK_work(struct work_struct
*work
)
3486 struct tty_struct
*tty
=
3487 container_of(work
, struct tty_struct
, SAK_work
);
3492 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3493 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3494 * the values which we write to it will be identical to the values which it
3495 * already has. --akpm
3497 void do_SAK(struct tty_struct
*tty
)
3501 schedule_work(&tty
->SAK_work
);
3504 EXPORT_SYMBOL(do_SAK
);
3508 * @work: tty structure passed from work queue.
3510 * This routine is called out of the software interrupt to flush data
3511 * from the buffer chain to the line discipline.
3513 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3514 * while invoking the line discipline receive_buf method. The
3515 * receive_buf method is single threaded for each tty instance.
3518 static void flush_to_ldisc(struct work_struct
*work
)
3520 struct tty_struct
*tty
=
3521 container_of(work
, struct tty_struct
, buf
.work
.work
);
3522 unsigned long flags
;
3523 struct tty_ldisc
*disc
;
3524 struct tty_buffer
*tbuf
, *head
;
3526 unsigned char *flag_buf
;
3528 disc
= tty_ldisc_ref(tty
);
3529 if (disc
== NULL
) /* !TTY_LDISC */
3532 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
3533 head
= tty
->buf
.head
;
3535 tty
->buf
.head
= NULL
;
3537 int count
= head
->commit
- head
->read
;
3539 if (head
->next
== NULL
)
3543 tty_buffer_free(tty
, tbuf
);
3546 if (!tty
->receive_room
) {
3547 schedule_delayed_work(&tty
->buf
.work
, 1);
3550 if (count
> tty
->receive_room
)
3551 count
= tty
->receive_room
;
3552 char_buf
= head
->char_buf_ptr
+ head
->read
;
3553 flag_buf
= head
->flag_buf_ptr
+ head
->read
;
3554 head
->read
+= count
;
3555 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
3556 disc
->receive_buf(tty
, char_buf
, flag_buf
, count
);
3557 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
3559 tty
->buf
.head
= head
;
3561 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
3563 tty_ldisc_deref(disc
);
3567 * tty_flip_buffer_push - terminal
3570 * Queue a push of the terminal flip buffers to the line discipline. This
3571 * function must not be called from IRQ context if tty->low_latency is set.
3573 * In the event of the queue being busy for flipping the work will be
3574 * held off and retried later.
3576 * Locking: tty buffer lock. Driver locks in low latency mode.
3579 void tty_flip_buffer_push(struct tty_struct
*tty
)
3581 unsigned long flags
;
3582 spin_lock_irqsave(&tty
->buf
.lock
, flags
);
3583 if (tty
->buf
.tail
!= NULL
)
3584 tty
->buf
.tail
->commit
= tty
->buf
.tail
->used
;
3585 spin_unlock_irqrestore(&tty
->buf
.lock
, flags
);
3587 if (tty
->low_latency
)
3588 flush_to_ldisc(&tty
->buf
.work
.work
);
3590 schedule_delayed_work(&tty
->buf
.work
, 1);
3593 EXPORT_SYMBOL(tty_flip_buffer_push
);
3597 * initialize_tty_struct
3598 * @tty: tty to initialize
3600 * This subroutine initializes a tty structure that has been newly
3603 * Locking: none - tty in question must not be exposed at this point
3606 static void initialize_tty_struct(struct tty_struct
*tty
)
3608 memset(tty
, 0, sizeof(struct tty_struct
));
3609 tty
->magic
= TTY_MAGIC
;
3610 tty_ldisc_assign(tty
, tty_ldisc_get(N_TTY
));
3611 tty
->session
= NULL
;
3613 tty
->overrun_time
= jiffies
;
3614 tty
->buf
.head
= tty
->buf
.tail
= NULL
;
3615 tty_buffer_init(tty
);
3616 INIT_DELAYED_WORK(&tty
->buf
.work
, flush_to_ldisc
);
3617 init_MUTEX(&tty
->buf
.pty_sem
);
3618 mutex_init(&tty
->termios_mutex
);
3619 init_waitqueue_head(&tty
->write_wait
);
3620 init_waitqueue_head(&tty
->read_wait
);
3621 INIT_WORK(&tty
->hangup_work
, do_tty_hangup
);
3622 mutex_init(&tty
->atomic_read_lock
);
3623 mutex_init(&tty
->atomic_write_lock
);
3624 spin_lock_init(&tty
->read_lock
);
3625 INIT_LIST_HEAD(&tty
->tty_files
);
3626 INIT_WORK(&tty
->SAK_work
, do_SAK_work
);
3630 * The default put_char routine if the driver did not define one.
3633 static void tty_default_put_char(struct tty_struct
*tty
, unsigned char ch
)
3635 tty
->driver
->write(tty
, &ch
, 1);
3638 static struct class *tty_class
;
3641 * tty_register_device - register a tty device
3642 * @driver: the tty driver that describes the tty device
3643 * @index: the index in the tty driver for this tty device
3644 * @device: a struct device that is associated with this tty device.
3645 * This field is optional, if there is no known struct device
3646 * for this tty device it can be set to NULL safely.
3648 * Returns a pointer to the struct device for this tty device
3649 * (or ERR_PTR(-EFOO) on error).
3651 * This call is required to be made to register an individual tty device
3652 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3653 * that bit is not set, this function should not be called by a tty
3659 struct device
*tty_register_device(struct tty_driver
*driver
, unsigned index
,
3660 struct device
*device
)
3663 dev_t dev
= MKDEV(driver
->major
, driver
->minor_start
) + index
;
3665 if (index
>= driver
->num
) {
3666 printk(KERN_ERR
"Attempt to register invalid tty line number "
3668 return ERR_PTR(-EINVAL
);
3671 if (driver
->type
== TTY_DRIVER_TYPE_PTY
)
3672 pty_line_name(driver
, index
, name
);
3674 tty_line_name(driver
, index
, name
);
3676 return device_create(tty_class
, device
, dev
, name
);
3680 * tty_unregister_device - unregister a tty device
3681 * @driver: the tty driver that describes the tty device
3682 * @index: the index in the tty driver for this tty device
3684 * If a tty device is registered with a call to tty_register_device() then
3685 * this function must be called when the tty device is gone.
3690 void tty_unregister_device(struct tty_driver
*driver
, unsigned index
)
3692 device_destroy(tty_class
, MKDEV(driver
->major
, driver
->minor_start
) + index
);
3695 EXPORT_SYMBOL(tty_register_device
);
3696 EXPORT_SYMBOL(tty_unregister_device
);
3698 struct tty_driver
*alloc_tty_driver(int lines
)
3700 struct tty_driver
*driver
;
3702 driver
= kmalloc(sizeof(struct tty_driver
), GFP_KERNEL
);
3704 memset(driver
, 0, sizeof(struct tty_driver
));
3705 driver
->magic
= TTY_DRIVER_MAGIC
;
3706 driver
->num
= lines
;
3707 /* later we'll move allocation of tables here */
3712 void put_tty_driver(struct tty_driver
*driver
)
3717 void tty_set_operations(struct tty_driver
*driver
,
3718 const struct tty_operations
*op
)
3720 driver
->open
= op
->open
;
3721 driver
->close
= op
->close
;
3722 driver
->write
= op
->write
;
3723 driver
->put_char
= op
->put_char
;
3724 driver
->flush_chars
= op
->flush_chars
;
3725 driver
->write_room
= op
->write_room
;
3726 driver
->chars_in_buffer
= op
->chars_in_buffer
;
3727 driver
->ioctl
= op
->ioctl
;
3728 driver
->compat_ioctl
= op
->compat_ioctl
;
3729 driver
->set_termios
= op
->set_termios
;
3730 driver
->throttle
= op
->throttle
;
3731 driver
->unthrottle
= op
->unthrottle
;
3732 driver
->stop
= op
->stop
;
3733 driver
->start
= op
->start
;
3734 driver
->hangup
= op
->hangup
;
3735 driver
->break_ctl
= op
->break_ctl
;
3736 driver
->flush_buffer
= op
->flush_buffer
;
3737 driver
->set_ldisc
= op
->set_ldisc
;
3738 driver
->wait_until_sent
= op
->wait_until_sent
;
3739 driver
->send_xchar
= op
->send_xchar
;
3740 driver
->read_proc
= op
->read_proc
;
3741 driver
->write_proc
= op
->write_proc
;
3742 driver
->tiocmget
= op
->tiocmget
;
3743 driver
->tiocmset
= op
->tiocmset
;
3747 EXPORT_SYMBOL(alloc_tty_driver
);
3748 EXPORT_SYMBOL(put_tty_driver
);
3749 EXPORT_SYMBOL(tty_set_operations
);
3752 * Called by a tty driver to register itself.
3754 int tty_register_driver(struct tty_driver
*driver
)
3761 if (driver
->flags
& TTY_DRIVER_INSTALLED
)
3764 if (!(driver
->flags
& TTY_DRIVER_DEVPTS_MEM
) && driver
->num
) {
3765 p
= kzalloc(driver
->num
* 3 * sizeof(void *), GFP_KERNEL
);
3770 if (!driver
->major
) {
3771 error
= alloc_chrdev_region(&dev
, driver
->minor_start
, driver
->num
,
3774 driver
->major
= MAJOR(dev
);
3775 driver
->minor_start
= MINOR(dev
);
3778 dev
= MKDEV(driver
->major
, driver
->minor_start
);
3779 error
= register_chrdev_region(dev
, driver
->num
, driver
->name
);
3787 driver
->ttys
= (struct tty_struct
**)p
;
3788 driver
->termios
= (struct ktermios
**)(p
+ driver
->num
);
3789 driver
->termios_locked
= (struct ktermios
**)(p
+ driver
->num
* 2);
3791 driver
->ttys
= NULL
;
3792 driver
->termios
= NULL
;
3793 driver
->termios_locked
= NULL
;
3796 cdev_init(&driver
->cdev
, &tty_fops
);
3797 driver
->cdev
.owner
= driver
->owner
;
3798 error
= cdev_add(&driver
->cdev
, dev
, driver
->num
);
3800 unregister_chrdev_region(dev
, driver
->num
);
3801 driver
->ttys
= NULL
;
3802 driver
->termios
= driver
->termios_locked
= NULL
;
3807 if (!driver
->put_char
)
3808 driver
->put_char
= tty_default_put_char
;
3810 mutex_lock(&tty_mutex
);
3811 list_add(&driver
->tty_drivers
, &tty_drivers
);
3812 mutex_unlock(&tty_mutex
);
3814 if ( !(driver
->flags
& TTY_DRIVER_DYNAMIC_DEV
) ) {
3815 for(i
= 0; i
< driver
->num
; i
++)
3816 tty_register_device(driver
, i
, NULL
);
3818 proc_tty_register_driver(driver
);
3822 EXPORT_SYMBOL(tty_register_driver
);
3825 * Called by a tty driver to unregister itself.
3827 int tty_unregister_driver(struct tty_driver
*driver
)
3830 struct ktermios
*tp
;
3833 if (driver
->refcount
)
3836 unregister_chrdev_region(MKDEV(driver
->major
, driver
->minor_start
),
3838 mutex_lock(&tty_mutex
);
3839 list_del(&driver
->tty_drivers
);
3840 mutex_unlock(&tty_mutex
);
3843 * Free the termios and termios_locked structures because
3844 * we don't want to get memory leaks when modular tty
3845 * drivers are removed from the kernel.
3847 for (i
= 0; i
< driver
->num
; i
++) {
3848 tp
= driver
->termios
[i
];
3850 driver
->termios
[i
] = NULL
;
3853 tp
= driver
->termios_locked
[i
];
3855 driver
->termios_locked
[i
] = NULL
;
3858 if (!(driver
->flags
& TTY_DRIVER_DYNAMIC_DEV
))
3859 tty_unregister_device(driver
, i
);
3862 proc_tty_unregister_driver(driver
);
3863 driver
->ttys
= NULL
;
3864 driver
->termios
= driver
->termios_locked
= NULL
;
3866 cdev_del(&driver
->cdev
);
3869 EXPORT_SYMBOL(tty_unregister_driver
);
3871 dev_t
tty_devnum(struct tty_struct
*tty
)
3873 return MKDEV(tty
->driver
->major
, tty
->driver
->minor_start
) + tty
->index
;
3875 EXPORT_SYMBOL(tty_devnum
);
3877 void proc_clear_tty(struct task_struct
*p
)
3879 spin_lock_irq(&p
->sighand
->siglock
);
3880 p
->signal
->tty
= NULL
;
3881 spin_unlock_irq(&p
->sighand
->siglock
);
3884 static void __proc_set_tty(struct task_struct
*tsk
, struct tty_struct
*tty
)
3887 /* We should not have a session or pgrp to here but.... */
3888 put_pid(tty
->session
);
3890 tty
->session
= get_pid(task_session(tsk
));
3891 tty
->pgrp
= get_pid(task_pgrp(tsk
));
3893 put_pid(tsk
->signal
->tty_old_pgrp
);
3894 tsk
->signal
->tty
= tty
;
3895 tsk
->signal
->tty_old_pgrp
= NULL
;
3898 static void proc_set_tty(struct task_struct
*tsk
, struct tty_struct
*tty
)
3900 spin_lock_irq(&tsk
->sighand
->siglock
);
3901 __proc_set_tty(tsk
, tty
);
3902 spin_unlock_irq(&tsk
->sighand
->siglock
);
3905 struct tty_struct
*get_current_tty(void)
3907 struct tty_struct
*tty
;
3908 WARN_ON_ONCE(!mutex_is_locked(&tty_mutex
));
3909 tty
= current
->signal
->tty
;
3911 * session->tty can be changed/cleared from under us, make sure we
3912 * issue the load. The obtained pointer, when not NULL, is valid as
3913 * long as we hold tty_mutex.
3918 EXPORT_SYMBOL_GPL(get_current_tty
);
3921 * Initialize the console device. This is called *early*, so
3922 * we can't necessarily depend on lots of kernel help here.
3923 * Just do some early initializations, and do the complex setup
3926 void __init
console_init(void)
3930 /* Setup the default TTY line discipline. */
3931 (void) tty_register_ldisc(N_TTY
, &tty_ldisc_N_TTY
);
3934 * set up the console device so that later boot sequences can
3935 * inform about problems etc..
3937 call
= __con_initcall_start
;
3938 while (call
< __con_initcall_end
) {
3945 extern int vty_init(void);
3948 static int __init
tty_class_init(void)
3950 tty_class
= class_create(THIS_MODULE
, "tty");
3951 if (IS_ERR(tty_class
))
3952 return PTR_ERR(tty_class
);
3956 postcore_initcall(tty_class_init
);
3958 /* 3/2004 jmc: why do these devices exist? */
3960 static struct cdev tty_cdev
, console_cdev
;
3961 #ifdef CONFIG_UNIX98_PTYS
3962 static struct cdev ptmx_cdev
;
3965 static struct cdev vc0_cdev
;
3969 * Ok, now we can initialize the rest of the tty devices and can count
3970 * on memory allocations, interrupts etc..
3972 static int __init
tty_init(void)
3974 cdev_init(&tty_cdev
, &tty_fops
);
3975 if (cdev_add(&tty_cdev
, MKDEV(TTYAUX_MAJOR
, 0), 1) ||
3976 register_chrdev_region(MKDEV(TTYAUX_MAJOR
, 0), 1, "/dev/tty") < 0)
3977 panic("Couldn't register /dev/tty driver\n");
3978 device_create(tty_class
, NULL
, MKDEV(TTYAUX_MAJOR
, 0), "tty");
3980 cdev_init(&console_cdev
, &console_fops
);
3981 if (cdev_add(&console_cdev
, MKDEV(TTYAUX_MAJOR
, 1), 1) ||
3982 register_chrdev_region(MKDEV(TTYAUX_MAJOR
, 1), 1, "/dev/console") < 0)
3983 panic("Couldn't register /dev/console driver\n");
3984 device_create(tty_class
, NULL
, MKDEV(TTYAUX_MAJOR
, 1), "console");
3986 #ifdef CONFIG_UNIX98_PTYS
3987 cdev_init(&ptmx_cdev
, &ptmx_fops
);
3988 if (cdev_add(&ptmx_cdev
, MKDEV(TTYAUX_MAJOR
, 2), 1) ||
3989 register_chrdev_region(MKDEV(TTYAUX_MAJOR
, 2), 1, "/dev/ptmx") < 0)
3990 panic("Couldn't register /dev/ptmx driver\n");
3991 device_create(tty_class
, NULL
, MKDEV(TTYAUX_MAJOR
, 2), "ptmx");
3995 cdev_init(&vc0_cdev
, &console_fops
);
3996 if (cdev_add(&vc0_cdev
, MKDEV(TTY_MAJOR
, 0), 1) ||
3997 register_chrdev_region(MKDEV(TTY_MAJOR
, 0), 1, "/dev/vc/0") < 0)
3998 panic("Couldn't register /dev/tty0 driver\n");
3999 device_create(tty_class
, NULL
, MKDEV(TTY_MAJOR
, 0), "tty0");
4005 module_init(tty_init
);