]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/char/tty_io.c
[PATCH] tty: ->signal->tty locking
[mirror_ubuntu-bionic-kernel.git] / drivers / char / tty_io.c
CommitLineData
1da177e4
LT
1/*
2 * linux/drivers/char/tty_io.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
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.
10 *
11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12 *
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.
18 *
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
23 *
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).
27 *
28 * NOTE: pay no attention to the line discipline code (yet); its
29 * interface is still subject to change in this version...
30 * -- TYT, 1/31/92
31 *
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.
35 *
36 * Rewrote canonical mode and added more termios flags.
37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38 *
39 * Reorganized FASYNC support so mouse code can share it.
40 * -- ctm@ardi.com, 9Sep95
41 *
42 * New TIOCLINUX variants added.
43 * -- mj@k332.feld.cvut.cz, 19-Nov-95
44 *
45 * Restrict vt switching via ioctl()
46 * -- grif@cs.ucr.edu, 5-Dec-95
47 *
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
51 *
52 * Rewrote init_dev and release_dev to eliminate races.
53 * -- Bill Hawes <whawes@star.net>, June 97
54 *
55 * Added devfs support.
56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
57 *
58 * Added support for a Unix98-style ptmx device.
59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
60 *
61 * Reduced memory usage for older ARM systems
62 * -- Russell King <rmk@arm.linux.org.uk>
63 *
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
66 */
67
1da177e4
LT
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>
83#include <linux/kd.h>
84#include <linux/mm.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>
b20f3ae5 96#include <linux/delay.h>
1da177e4
LT
97
98#include <asm/uaccess.h>
99#include <asm/system.h>
100
101#include <linux/kbd_kern.h>
102#include <linux/vt_kern.h>
103#include <linux/selection.h>
1da177e4
LT
104
105#include <linux/kmod.h>
106
107#undef TTY_DEBUG_HANGUP
108
109#define TTY_PARANOIA_CHECK 1
110#define CHECK_TTY_COUNT 1
111
112struct termios tty_std_termios = { /* for the benefit of tty drivers */
113 .c_iflag = ICRNL | IXON,
114 .c_oflag = OPOST | ONLCR,
115 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
116 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
117 ECHOCTL | ECHOKE | IEXTEN,
118 .c_cc = INIT_C_CC
119};
120
121EXPORT_SYMBOL(tty_std_termios);
122
123/* This list gets poked at by procfs and various bits of boot up code. This
124 could do with some rationalisation such as pulling the tty proc function
125 into this file */
126
127LIST_HEAD(tty_drivers); /* linked list of tty drivers */
128
24ec839c 129/* Mutex to protect creating and releasing a tty. This is shared with
1da177e4 130 vt.c for deeply disgusting hack reasons */
70522e12 131DEFINE_MUTEX(tty_mutex);
de2a84f2 132EXPORT_SYMBOL(tty_mutex);
1da177e4
LT
133
134#ifdef CONFIG_UNIX98_PTYS
135extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
136extern int pty_limit; /* Config limit on Unix98 ptys */
137static DEFINE_IDR(allocated_ptys);
138static DECLARE_MUTEX(allocated_ptys_lock);
139static int ptmx_open(struct inode *, struct file *);
140#endif
141
142extern void disable_early_printk(void);
143
144static void initialize_tty_struct(struct tty_struct *tty);
145
146static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149static unsigned int tty_poll(struct file *, poll_table *);
150static int tty_open(struct inode *, struct file *);
151static int tty_release(struct inode *, struct file *);
152int tty_ioctl(struct inode * inode, struct file * file,
153 unsigned int cmd, unsigned long arg);
154static int tty_fasync(int fd, struct file * filp, int on);
1da177e4
LT
155static void release_mem(struct tty_struct *tty, int idx);
156
af9b897e
AC
157/**
158 * alloc_tty_struct - allocate a tty object
159 *
160 * Return a new empty tty structure. The data fields have not
161 * been initialized in any way but has been zeroed
162 *
163 * Locking: none
af9b897e 164 */
1da177e4
LT
165
166static struct tty_struct *alloc_tty_struct(void)
167{
1266b1e1 168 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
1da177e4
LT
169}
170
33f0f88f
AC
171static void tty_buffer_free_all(struct tty_struct *);
172
af9b897e
AC
173/**
174 * free_tty_struct - free a disused tty
175 * @tty: tty struct to free
176 *
177 * Free the write buffers, tty queue and tty memory itself.
178 *
179 * Locking: none. Must be called after tty is definitely unused
180 */
181
1da177e4
LT
182static inline void free_tty_struct(struct tty_struct *tty)
183{
184 kfree(tty->write_buf);
33f0f88f 185 tty_buffer_free_all(tty);
1da177e4
LT
186 kfree(tty);
187}
188
189#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
190
af9b897e
AC
191/**
192 * tty_name - return tty naming
193 * @tty: tty structure
194 * @buf: buffer for output
195 *
196 * Convert a tty structure into a name. The name reflects the kernel
197 * naming policy and if udev is in use may not reflect user space
198 *
199 * Locking: none
200 */
201
1da177e4
LT
202char *tty_name(struct tty_struct *tty, char *buf)
203{
204 if (!tty) /* Hmm. NULL pointer. That's fun. */
205 strcpy(buf, "NULL tty");
206 else
207 strcpy(buf, tty->name);
208 return buf;
209}
210
211EXPORT_SYMBOL(tty_name);
212
d769a669 213int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
1da177e4
LT
214 const char *routine)
215{
216#ifdef TTY_PARANOIA_CHECK
217 if (!tty) {
218 printk(KERN_WARNING
219 "null TTY for (%d:%d) in %s\n",
220 imajor(inode), iminor(inode), routine);
221 return 1;
222 }
223 if (tty->magic != TTY_MAGIC) {
224 printk(KERN_WARNING
225 "bad magic number for tty struct (%d:%d) in %s\n",
226 imajor(inode), iminor(inode), routine);
227 return 1;
228 }
229#endif
230 return 0;
231}
232
233static int check_tty_count(struct tty_struct *tty, const char *routine)
234{
235#ifdef CHECK_TTY_COUNT
236 struct list_head *p;
237 int count = 0;
238
239 file_list_lock();
240 list_for_each(p, &tty->tty_files) {
241 count++;
242 }
243 file_list_unlock();
244 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
245 tty->driver->subtype == PTY_TYPE_SLAVE &&
246 tty->link && tty->link->count)
247 count++;
248 if (tty->count != count) {
249 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
250 "!= #fd's(%d) in %s\n",
251 tty->name, tty->count, count, routine);
252 return count;
24ec839c 253 }
1da177e4
LT
254#endif
255 return 0;
256}
257
33f0f88f
AC
258/*
259 * Tty buffer allocation management
260 */
261
af9b897e
AC
262/**
263 * tty_buffer_free_all - free buffers used by a tty
264 * @tty: tty to free from
265 *
266 * Remove all the buffers pending on a tty whether queued with data
267 * or in the free ring. Must be called when the tty is no longer in use
268 *
269 * Locking: none
270 */
271
33f0f88f
AC
272static void tty_buffer_free_all(struct tty_struct *tty)
273{
274 struct tty_buffer *thead;
275 while((thead = tty->buf.head) != NULL) {
276 tty->buf.head = thead->next;
277 kfree(thead);
278 }
279 while((thead = tty->buf.free) != NULL) {
280 tty->buf.free = thead->next;
281 kfree(thead);
282 }
283 tty->buf.tail = NULL;
01da5fd8 284 tty->buf.memory_used = 0;
33f0f88f
AC
285}
286
01da5fd8
AC
287/**
288 * tty_buffer_init - prepare a tty buffer structure
289 * @tty: tty to initialise
290 *
291 * Set up the initial state of the buffer management for a tty device.
292 * Must be called before the other tty buffer functions are used.
293 *
294 * Locking: none
295 */
296
33f0f88f
AC
297static void tty_buffer_init(struct tty_struct *tty)
298{
808249ce 299 spin_lock_init(&tty->buf.lock);
33f0f88f
AC
300 tty->buf.head = NULL;
301 tty->buf.tail = NULL;
302 tty->buf.free = NULL;
01da5fd8 303 tty->buf.memory_used = 0;
33f0f88f
AC
304}
305
01da5fd8
AC
306/**
307 * tty_buffer_alloc - allocate a tty buffer
308 * @tty: tty device
309 * @size: desired size (characters)
310 *
311 * Allocate a new tty buffer to hold the desired number of characters.
312 * Return NULL if out of memory or the allocation would exceed the
313 * per device queue
314 *
315 * Locking: Caller must hold tty->buf.lock
316 */
317
318static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
33f0f88f 319{
01da5fd8
AC
320 struct tty_buffer *p;
321
322 if (tty->buf.memory_used + size > 65536)
323 return NULL;
324 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
33f0f88f
AC
325 if(p == NULL)
326 return NULL;
327 p->used = 0;
328 p->size = size;
329 p->next = NULL;
8977d929
PF
330 p->commit = 0;
331 p->read = 0;
33f0f88f
AC
332 p->char_buf_ptr = (char *)(p->data);
333 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
01da5fd8 334 tty->buf.memory_used += size;
33f0f88f
AC
335 return p;
336}
337
01da5fd8
AC
338/**
339 * tty_buffer_free - free a tty buffer
340 * @tty: tty owning the buffer
341 * @b: the buffer to free
342 *
343 * Free a tty buffer, or add it to the free list according to our
344 * internal strategy
345 *
346 * Locking: Caller must hold tty->buf.lock
347 */
33f0f88f
AC
348
349static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
350{
351 /* Dumb strategy for now - should keep some stats */
01da5fd8
AC
352 tty->buf.memory_used -= b->size;
353 WARN_ON(tty->buf.memory_used < 0);
354
33f0f88f
AC
355 if(b->size >= 512)
356 kfree(b);
357 else {
358 b->next = tty->buf.free;
359 tty->buf.free = b;
360 }
361}
362
01da5fd8
AC
363/**
364 * tty_buffer_find - find a free tty buffer
365 * @tty: tty owning the buffer
366 * @size: characters wanted
367 *
368 * Locate an existing suitable tty buffer or if we are lacking one then
369 * allocate a new one. We round our buffers off in 256 character chunks
370 * to get better allocation behaviour.
371 *
372 * Locking: Caller must hold tty->buf.lock
373 */
374
33f0f88f
AC
375static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
376{
377 struct tty_buffer **tbh = &tty->buf.free;
378 while((*tbh) != NULL) {
379 struct tty_buffer *t = *tbh;
380 if(t->size >= size) {
381 *tbh = t->next;
382 t->next = NULL;
383 t->used = 0;
8977d929
PF
384 t->commit = 0;
385 t->read = 0;
01da5fd8 386 tty->buf.memory_used += t->size;
33f0f88f
AC
387 return t;
388 }
389 tbh = &((*tbh)->next);
390 }
391 /* Round the buffer size out */
392 size = (size + 0xFF) & ~ 0xFF;
01da5fd8 393 return tty_buffer_alloc(tty, size);
33f0f88f
AC
394 /* Should possibly check if this fails for the largest buffer we
395 have queued and recycle that ? */
396}
397
01da5fd8
AC
398/**
399 * tty_buffer_request_room - grow tty buffer if needed
400 * @tty: tty structure
401 * @size: size desired
402 *
403 * Make at least size bytes of linear space available for the tty
404 * buffer. If we fail return the size we managed to find.
405 *
406 * Locking: Takes tty->buf.lock
407 */
33f0f88f
AC
408int tty_buffer_request_room(struct tty_struct *tty, size_t size)
409{
808249ce
PF
410 struct tty_buffer *b, *n;
411 int left;
412 unsigned long flags;
413
414 spin_lock_irqsave(&tty->buf.lock, flags);
33f0f88f
AC
415
416 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
417 remove this conditional if its worth it. This would be invisible
418 to the callers */
33b37a33 419 if ((b = tty->buf.tail) != NULL)
33f0f88f 420 left = b->size - b->used;
33b37a33 421 else
808249ce
PF
422 left = 0;
423
424 if (left < size) {
425 /* This is the slow path - looking for new buffers to use */
426 if ((n = tty_buffer_find(tty, size)) != NULL) {
427 if (b != NULL) {
428 b->next = n;
8977d929 429 b->commit = b->used;
808249ce
PF
430 } else
431 tty->buf.head = n;
432 tty->buf.tail = n;
808249ce
PF
433 } else
434 size = left;
435 }
436
437 spin_unlock_irqrestore(&tty->buf.lock, flags);
33f0f88f
AC
438 return size;
439}
33f0f88f
AC
440EXPORT_SYMBOL_GPL(tty_buffer_request_room);
441
af9b897e
AC
442/**
443 * tty_insert_flip_string - Add characters to the tty buffer
444 * @tty: tty structure
445 * @chars: characters
446 * @size: size
447 *
448 * Queue a series of bytes to the tty buffering. All the characters
449 * passed are marked as without error. Returns the number added.
450 *
451 * Locking: Called functions may take tty->buf.lock
452 */
453
e1a25090
AM
454int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
455 size_t size)
33f0f88f
AC
456{
457 int copied = 0;
458 do {
459 int space = tty_buffer_request_room(tty, size - copied);
460 struct tty_buffer *tb = tty->buf.tail;
461 /* If there is no space then tb may be NULL */
462 if(unlikely(space == 0))
463 break;
464 memcpy(tb->char_buf_ptr + tb->used, chars, space);
465 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
466 tb->used += space;
467 copied += space;
468 chars += space;
527063ba
AD
469 /* There is a small chance that we need to split the data over
470 several buffers. If this is the case we must loop */
471 } while (unlikely(size > copied));
33f0f88f
AC
472 return copied;
473}
ee37df78 474EXPORT_SYMBOL(tty_insert_flip_string);
33f0f88f 475
af9b897e
AC
476/**
477 * tty_insert_flip_string_flags - Add characters to the tty buffer
478 * @tty: tty structure
479 * @chars: characters
480 * @flags: flag bytes
481 * @size: size
482 *
483 * Queue a series of bytes to the tty buffering. For each character
484 * the flags array indicates the status of the character. Returns the
485 * number added.
486 *
487 * Locking: Called functions may take tty->buf.lock
488 */
489
e1a25090
AM
490int tty_insert_flip_string_flags(struct tty_struct *tty,
491 const unsigned char *chars, const char *flags, size_t size)
33f0f88f
AC
492{
493 int copied = 0;
494 do {
495 int space = tty_buffer_request_room(tty, size - copied);
496 struct tty_buffer *tb = tty->buf.tail;
497 /* If there is no space then tb may be NULL */
498 if(unlikely(space == 0))
499 break;
500 memcpy(tb->char_buf_ptr + tb->used, chars, space);
501 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
502 tb->used += space;
503 copied += space;
504 chars += space;
505 flags += space;
527063ba
AD
506 /* There is a small chance that we need to split the data over
507 several buffers. If this is the case we must loop */
508 } while (unlikely(size > copied));
33f0f88f
AC
509 return copied;
510}
ff4547f4 511EXPORT_SYMBOL(tty_insert_flip_string_flags);
33f0f88f 512
af9b897e
AC
513/**
514 * tty_schedule_flip - push characters to ldisc
515 * @tty: tty to push from
516 *
517 * Takes any pending buffers and transfers their ownership to the
518 * ldisc side of the queue. It then schedules those characters for
519 * processing by the line discipline.
520 *
521 * Locking: Takes tty->buf.lock
522 */
523
e1a25090
AM
524void tty_schedule_flip(struct tty_struct *tty)
525{
526 unsigned long flags;
527 spin_lock_irqsave(&tty->buf.lock, flags);
33b37a33 528 if (tty->buf.tail != NULL)
e1a25090 529 tty->buf.tail->commit = tty->buf.tail->used;
e1a25090
AM
530 spin_unlock_irqrestore(&tty->buf.lock, flags);
531 schedule_delayed_work(&tty->buf.work, 1);
532}
533EXPORT_SYMBOL(tty_schedule_flip);
33f0f88f 534
af9b897e
AC
535/**
536 * tty_prepare_flip_string - make room for characters
537 * @tty: tty
538 * @chars: return pointer for character write area
539 * @size: desired size
540 *
33f0f88f
AC
541 * Prepare a block of space in the buffer for data. Returns the length
542 * available and buffer pointer to the space which is now allocated and
543 * accounted for as ready for normal characters. This is used for drivers
544 * that need their own block copy routines into the buffer. There is no
545 * guarantee the buffer is a DMA target!
af9b897e
AC
546 *
547 * Locking: May call functions taking tty->buf.lock
33f0f88f
AC
548 */
549
550int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
551{
552 int space = tty_buffer_request_room(tty, size);
808249ce
PF
553 if (likely(space)) {
554 struct tty_buffer *tb = tty->buf.tail;
555 *chars = tb->char_buf_ptr + tb->used;
556 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
557 tb->used += space;
558 }
33f0f88f
AC
559 return space;
560}
561
562EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
563
af9b897e
AC
564/**
565 * tty_prepare_flip_string_flags - make room for characters
566 * @tty: tty
567 * @chars: return pointer for character write area
568 * @flags: return pointer for status flag write area
569 * @size: desired size
570 *
33f0f88f
AC
571 * Prepare a block of space in the buffer for data. Returns the length
572 * available and buffer pointer to the space which is now allocated and
573 * accounted for as ready for characters. This is used for drivers
574 * that need their own block copy routines into the buffer. There is no
575 * guarantee the buffer is a DMA target!
af9b897e
AC
576 *
577 * Locking: May call functions taking tty->buf.lock
33f0f88f
AC
578 */
579
580int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
581{
582 int space = tty_buffer_request_room(tty, size);
808249ce
PF
583 if (likely(space)) {
584 struct tty_buffer *tb = tty->buf.tail;
585 *chars = tb->char_buf_ptr + tb->used;
586 *flags = tb->flag_buf_ptr + tb->used;
587 tb->used += space;
588 }
33f0f88f
AC
589 return space;
590}
591
592EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
593
594
595
af9b897e
AC
596/**
597 * tty_set_termios_ldisc - set ldisc field
598 * @tty: tty structure
599 * @num: line discipline number
600 *
1da177e4
LT
601 * This is probably overkill for real world processors but
602 * they are not on hot paths so a little discipline won't do
603 * any harm.
af9b897e 604 *
24ec839c 605 * Locking: takes termios_mutex
1da177e4
LT
606 */
607
608static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
609{
5785c95b 610 mutex_lock(&tty->termios_mutex);
1da177e4 611 tty->termios->c_line = num;
5785c95b 612 mutex_unlock(&tty->termios_mutex);
1da177e4
LT
613}
614
615/*
616 * This guards the refcounted line discipline lists. The lock
617 * must be taken with irqs off because there are hangup path
618 * callers who will do ldisc lookups and cannot sleep.
619 */
620
621static DEFINE_SPINLOCK(tty_ldisc_lock);
622static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
bfb07599 623static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
1da177e4 624
af9b897e
AC
625/**
626 * tty_register_ldisc - install a line discipline
627 * @disc: ldisc number
628 * @new_ldisc: pointer to the ldisc object
629 *
630 * Installs a new line discipline into the kernel. The discipline
631 * is set up as unreferenced and then made available to the kernel
632 * from this point onwards.
633 *
634 * Locking:
635 * takes tty_ldisc_lock to guard against ldisc races
636 */
637
1da177e4
LT
638int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
639{
640 unsigned long flags;
641 int ret = 0;
642
643 if (disc < N_TTY || disc >= NR_LDISCS)
644 return -EINVAL;
645
646 spin_lock_irqsave(&tty_ldisc_lock, flags);
bfb07599
AD
647 tty_ldiscs[disc] = *new_ldisc;
648 tty_ldiscs[disc].num = disc;
649 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
650 tty_ldiscs[disc].refcount = 0;
1da177e4
LT
651 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
652
653 return ret;
654}
1da177e4
LT
655EXPORT_SYMBOL(tty_register_ldisc);
656
af9b897e
AC
657/**
658 * tty_unregister_ldisc - unload a line discipline
659 * @disc: ldisc number
660 * @new_ldisc: pointer to the ldisc object
661 *
662 * Remove a line discipline from the kernel providing it is not
663 * currently in use.
664 *
665 * Locking:
666 * takes tty_ldisc_lock to guard against ldisc races
667 */
668
bfb07599
AD
669int tty_unregister_ldisc(int disc)
670{
671 unsigned long flags;
672 int ret = 0;
673
674 if (disc < N_TTY || disc >= NR_LDISCS)
675 return -EINVAL;
676
677 spin_lock_irqsave(&tty_ldisc_lock, flags);
678 if (tty_ldiscs[disc].refcount)
679 ret = -EBUSY;
680 else
681 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
682 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
683
684 return ret;
685}
686EXPORT_SYMBOL(tty_unregister_ldisc);
687
af9b897e
AC
688/**
689 * tty_ldisc_get - take a reference to an ldisc
690 * @disc: ldisc number
691 *
692 * Takes a reference to a line discipline. Deals with refcounts and
693 * module locking counts. Returns NULL if the discipline is not available.
694 * Returns a pointer to the discipline and bumps the ref count if it is
695 * available
696 *
697 * Locking:
698 * takes tty_ldisc_lock to guard against ldisc races
699 */
700
1da177e4
LT
701struct tty_ldisc *tty_ldisc_get(int disc)
702{
703 unsigned long flags;
704 struct tty_ldisc *ld;
705
706 if (disc < N_TTY || disc >= NR_LDISCS)
707 return NULL;
708
709 spin_lock_irqsave(&tty_ldisc_lock, flags);
710
711 ld = &tty_ldiscs[disc];
712 /* Check the entry is defined */
713 if(ld->flags & LDISC_FLAG_DEFINED)
714 {
715 /* If the module is being unloaded we can't use it */
716 if (!try_module_get(ld->owner))
717 ld = NULL;
718 else /* lock it */
719 ld->refcount++;
720 }
721 else
722 ld = NULL;
723 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
724 return ld;
725}
726
727EXPORT_SYMBOL_GPL(tty_ldisc_get);
728
af9b897e
AC
729/**
730 * tty_ldisc_put - drop ldisc reference
731 * @disc: ldisc number
732 *
733 * Drop a reference to a line discipline. Manage refcounts and
734 * module usage counts
735 *
736 * Locking:
737 * takes tty_ldisc_lock to guard against ldisc races
738 */
739
1da177e4
LT
740void tty_ldisc_put(int disc)
741{
742 struct tty_ldisc *ld;
743 unsigned long flags;
744
56ee4827 745 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
1da177e4
LT
746
747 spin_lock_irqsave(&tty_ldisc_lock, flags);
748 ld = &tty_ldiscs[disc];
56ee4827
ES
749 BUG_ON(ld->refcount == 0);
750 ld->refcount--;
1da177e4
LT
751 module_put(ld->owner);
752 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
753}
754
755EXPORT_SYMBOL_GPL(tty_ldisc_put);
756
af9b897e
AC
757/**
758 * tty_ldisc_assign - set ldisc on a tty
759 * @tty: tty to assign
760 * @ld: line discipline
761 *
762 * Install an instance of a line discipline into a tty structure. The
763 * ldisc must have a reference count above zero to ensure it remains/
764 * The tty instance refcount starts at zero.
765 *
766 * Locking:
767 * Caller must hold references
768 */
769
1da177e4
LT
770static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
771{
772 tty->ldisc = *ld;
773 tty->ldisc.refcount = 0;
774}
775
776/**
777 * tty_ldisc_try - internal helper
778 * @tty: the tty
779 *
780 * Make a single attempt to grab and bump the refcount on
781 * the tty ldisc. Return 0 on failure or 1 on success. This is
782 * used to implement both the waiting and non waiting versions
783 * of tty_ldisc_ref
af9b897e
AC
784 *
785 * Locking: takes tty_ldisc_lock
1da177e4
LT
786 */
787
788static int tty_ldisc_try(struct tty_struct *tty)
789{
790 unsigned long flags;
791 struct tty_ldisc *ld;
792 int ret = 0;
793
794 spin_lock_irqsave(&tty_ldisc_lock, flags);
795 ld = &tty->ldisc;
796 if(test_bit(TTY_LDISC, &tty->flags))
797 {
798 ld->refcount++;
799 ret = 1;
800 }
801 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
802 return ret;
803}
804
805/**
806 * tty_ldisc_ref_wait - wait for the tty ldisc
807 * @tty: tty device
808 *
809 * Dereference the line discipline for the terminal and take a
810 * reference to it. If the line discipline is in flux then
811 * wait patiently until it changes.
812 *
813 * Note: Must not be called from an IRQ/timer context. The caller
814 * must also be careful not to hold other locks that will deadlock
815 * against a discipline change, such as an existing ldisc reference
816 * (which we check for)
af9b897e
AC
817 *
818 * Locking: call functions take tty_ldisc_lock
1da177e4
LT
819 */
820
821struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
822{
823 /* wait_event is a macro */
824 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
825 if(tty->ldisc.refcount == 0)
826 printk(KERN_ERR "tty_ldisc_ref_wait\n");
827 return &tty->ldisc;
828}
829
830EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
831
832/**
833 * tty_ldisc_ref - get the tty ldisc
834 * @tty: tty device
835 *
836 * Dereference the line discipline for the terminal and take a
837 * reference to it. If the line discipline is in flux then
838 * return NULL. Can be called from IRQ and timer functions.
af9b897e
AC
839 *
840 * Locking: called functions take tty_ldisc_lock
1da177e4
LT
841 */
842
843struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
844{
845 if(tty_ldisc_try(tty))
846 return &tty->ldisc;
847 return NULL;
848}
849
850EXPORT_SYMBOL_GPL(tty_ldisc_ref);
851
852/**
853 * tty_ldisc_deref - free a tty ldisc reference
854 * @ld: reference to free up
855 *
856 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
857 * be called in IRQ context.
af9b897e
AC
858 *
859 * Locking: takes tty_ldisc_lock
1da177e4
LT
860 */
861
862void tty_ldisc_deref(struct tty_ldisc *ld)
863{
864 unsigned long flags;
865
56ee4827 866 BUG_ON(ld == NULL);
1da177e4
LT
867
868 spin_lock_irqsave(&tty_ldisc_lock, flags);
869 if(ld->refcount == 0)
870 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
871 else
872 ld->refcount--;
873 if(ld->refcount == 0)
874 wake_up(&tty_ldisc_wait);
875 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
876}
877
878EXPORT_SYMBOL_GPL(tty_ldisc_deref);
879
880/**
881 * tty_ldisc_enable - allow ldisc use
882 * @tty: terminal to activate ldisc on
883 *
884 * Set the TTY_LDISC flag when the line discipline can be called
885 * again. Do neccessary wakeups for existing sleepers.
886 *
887 * Note: nobody should set this bit except via this function. Clearing
888 * directly is allowed.
889 */
890
891static void tty_ldisc_enable(struct tty_struct *tty)
892{
893 set_bit(TTY_LDISC, &tty->flags);
894 wake_up(&tty_ldisc_wait);
895}
896
897/**
898 * tty_set_ldisc - set line discipline
899 * @tty: the terminal to set
900 * @ldisc: the line discipline
901 *
902 * Set the discipline of a tty line. Must be called from a process
903 * context.
af9b897e
AC
904 *
905 * Locking: takes tty_ldisc_lock.
24ec839c 906 * called functions take termios_mutex
1da177e4
LT
907 */
908
909static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
910{
ff55fe20
JB
911 int retval = 0;
912 struct tty_ldisc o_ldisc;
1da177e4
LT
913 char buf[64];
914 int work;
915 unsigned long flags;
916 struct tty_ldisc *ld;
ff55fe20 917 struct tty_struct *o_tty;
1da177e4
LT
918
919 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
920 return -EINVAL;
921
922restart:
923
1da177e4
LT
924 ld = tty_ldisc_get(ldisc);
925 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
926 /* Cyrus Durgin <cider@speakeasy.org> */
927 if (ld == NULL) {
928 request_module("tty-ldisc-%d", ldisc);
929 ld = tty_ldisc_get(ldisc);
930 }
931 if (ld == NULL)
932 return -EINVAL;
933
33f0f88f
AC
934 /*
935 * No more input please, we are switching. The new ldisc
936 * will update this value in the ldisc open function
937 */
938
939 tty->receive_room = 0;
940
941 /*
942 * Problem: What do we do if this blocks ?
943 */
944
1da177e4
LT
945 tty_wait_until_sent(tty, 0);
946
ff55fe20
JB
947 if (tty->ldisc.num == ldisc) {
948 tty_ldisc_put(ldisc);
949 return 0;
950 }
951
952 o_ldisc = tty->ldisc;
953 o_tty = tty->link;
954
1da177e4
LT
955 /*
956 * Make sure we don't change while someone holds a
957 * reference to the line discipline. The TTY_LDISC bit
958 * prevents anyone taking a reference once it is clear.
959 * We need the lock to avoid racing reference takers.
960 */
ff55fe20 961
1da177e4 962 spin_lock_irqsave(&tty_ldisc_lock, flags);
ff55fe20
JB
963 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
964 if(tty->ldisc.refcount) {
965 /* Free the new ldisc we grabbed. Must drop the lock
966 first. */
967 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
968 tty_ldisc_put(ldisc);
969 /*
970 * There are several reasons we may be busy, including
971 * random momentary I/O traffic. We must therefore
972 * retry. We could distinguish between blocking ops
973 * and retries if we made tty_ldisc_wait() smarter. That
974 * is up for discussion.
975 */
976 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
977 return -ERESTARTSYS;
978 goto restart;
979 }
980 if(o_tty && o_tty->ldisc.refcount) {
981 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
982 tty_ldisc_put(ldisc);
983 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
984 return -ERESTARTSYS;
985 goto restart;
986 }
987 }
988
989 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
990
991 if (!test_bit(TTY_LDISC, &tty->flags)) {
1da177e4
LT
992 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
993 tty_ldisc_put(ldisc);
ff55fe20
JB
994 ld = tty_ldisc_ref_wait(tty);
995 tty_ldisc_deref(ld);
1da177e4
LT
996 goto restart;
997 }
ff55fe20
JB
998
999 clear_bit(TTY_LDISC, &tty->flags);
817d6d3b 1000 if (o_tty)
ff55fe20 1001 clear_bit(TTY_LDISC, &o_tty->flags);
1da177e4 1002 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
ff55fe20 1003
1da177e4
LT
1004 /*
1005 * From this point on we know nobody has an ldisc
1006 * usage reference, nor can they obtain one until
1007 * we say so later on.
1008 */
ff55fe20 1009
33f0f88f 1010 work = cancel_delayed_work(&tty->buf.work);
1da177e4 1011 /*
33f0f88f 1012 * Wait for ->hangup_work and ->buf.work handlers to terminate
1da177e4
LT
1013 */
1014
1015 flush_scheduled_work();
1016 /* Shutdown the current discipline. */
1017 if (tty->ldisc.close)
1018 (tty->ldisc.close)(tty);
1019
1020 /* Now set up the new line discipline. */
1021 tty_ldisc_assign(tty, ld);
1022 tty_set_termios_ldisc(tty, ldisc);
1023 if (tty->ldisc.open)
1024 retval = (tty->ldisc.open)(tty);
1025 if (retval < 0) {
1026 tty_ldisc_put(ldisc);
1027 /* There is an outstanding reference here so this is safe */
1028 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1029 tty_set_termios_ldisc(tty, tty->ldisc.num);
1030 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1031 tty_ldisc_put(o_ldisc.num);
1032 /* This driver is always present */
1033 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1034 tty_set_termios_ldisc(tty, N_TTY);
1035 if (tty->ldisc.open) {
1036 int r = tty->ldisc.open(tty);
1037
1038 if (r < 0)
1039 panic("Couldn't open N_TTY ldisc for "
1040 "%s --- error %d.",
1041 tty_name(tty, buf), r);
1042 }
1043 }
1044 }
1045 /* At this point we hold a reference to the new ldisc and a
1046 a reference to the old ldisc. If we ended up flipping back
1047 to the existing ldisc we have two references to it */
1048
1049 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1050 tty->driver->set_ldisc(tty);
1051
1052 tty_ldisc_put(o_ldisc.num);
1053
1054 /*
1055 * Allow ldisc referencing to occur as soon as the driver
1056 * ldisc callback completes.
1057 */
1058
1059 tty_ldisc_enable(tty);
ff55fe20
JB
1060 if (o_tty)
1061 tty_ldisc_enable(o_tty);
1da177e4
LT
1062
1063 /* Restart it in case no characters kick it off. Safe if
1064 already running */
ff55fe20 1065 if (work)
33f0f88f 1066 schedule_delayed_work(&tty->buf.work, 1);
1da177e4
LT
1067 return retval;
1068}
1069
af9b897e
AC
1070/**
1071 * get_tty_driver - find device of a tty
1072 * @dev_t: device identifier
1073 * @index: returns the index of the tty
1074 *
1075 * This routine returns a tty driver structure, given a device number
1076 * and also passes back the index number.
1077 *
1078 * Locking: caller must hold tty_mutex
1da177e4 1079 */
af9b897e 1080
1da177e4
LT
1081static struct tty_driver *get_tty_driver(dev_t device, int *index)
1082{
1083 struct tty_driver *p;
1084
1085 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1086 dev_t base = MKDEV(p->major, p->minor_start);
1087 if (device < base || device >= base + p->num)
1088 continue;
1089 *index = device - base;
1090 return p;
1091 }
1092 return NULL;
1093}
1094
af9b897e
AC
1095/**
1096 * tty_check_change - check for POSIX terminal changes
1097 * @tty: tty to check
1098 *
1099 * If we try to write to, or set the state of, a terminal and we're
1100 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1101 * ignored, go ahead and perform the operation. (POSIX 7.2)
1102 *
1103 * Locking: none
1da177e4 1104 */
af9b897e 1105
1da177e4
LT
1106int tty_check_change(struct tty_struct * tty)
1107{
1108 if (current->signal->tty != tty)
1109 return 0;
1110 if (tty->pgrp <= 0) {
1111 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1112 return 0;
1113 }
1114 if (process_group(current) == tty->pgrp)
1115 return 0;
1116 if (is_ignored(SIGTTOU))
1117 return 0;
1118 if (is_orphaned_pgrp(process_group(current)))
1119 return -EIO;
1120 (void) kill_pg(process_group(current), SIGTTOU, 1);
1121 return -ERESTARTSYS;
1122}
1123
1124EXPORT_SYMBOL(tty_check_change);
1125
1126static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1127 size_t count, loff_t *ppos)
1128{
1129 return 0;
1130}
1131
1132static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1133 size_t count, loff_t *ppos)
1134{
1135 return -EIO;
1136}
1137
1138/* No kernel lock held - none needed ;) */
1139static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1140{
1141 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1142}
1143
1144static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1145 unsigned int cmd, unsigned long arg)
1146{
1147 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1148}
1149
62322d25 1150static const struct file_operations tty_fops = {
1da177e4
LT
1151 .llseek = no_llseek,
1152 .read = tty_read,
1153 .write = tty_write,
1154 .poll = tty_poll,
1155 .ioctl = tty_ioctl,
1156 .open = tty_open,
1157 .release = tty_release,
1158 .fasync = tty_fasync,
1159};
1160
1161#ifdef CONFIG_UNIX98_PTYS
62322d25 1162static const struct file_operations ptmx_fops = {
1da177e4
LT
1163 .llseek = no_llseek,
1164 .read = tty_read,
1165 .write = tty_write,
1166 .poll = tty_poll,
1167 .ioctl = tty_ioctl,
1168 .open = ptmx_open,
1169 .release = tty_release,
1170 .fasync = tty_fasync,
1171};
1172#endif
1173
62322d25 1174static const struct file_operations console_fops = {
1da177e4
LT
1175 .llseek = no_llseek,
1176 .read = tty_read,
1177 .write = redirected_tty_write,
1178 .poll = tty_poll,
1179 .ioctl = tty_ioctl,
1180 .open = tty_open,
1181 .release = tty_release,
1182 .fasync = tty_fasync,
1183};
1184
62322d25 1185static const struct file_operations hung_up_tty_fops = {
1da177e4
LT
1186 .llseek = no_llseek,
1187 .read = hung_up_tty_read,
1188 .write = hung_up_tty_write,
1189 .poll = hung_up_tty_poll,
1190 .ioctl = hung_up_tty_ioctl,
1191 .release = tty_release,
1192};
1193
1194static DEFINE_SPINLOCK(redirect_lock);
1195static struct file *redirect;
1196
1197/**
1198 * tty_wakeup - request more data
1199 * @tty: terminal
1200 *
1201 * Internal and external helper for wakeups of tty. This function
1202 * informs the line discipline if present that the driver is ready
1203 * to receive more output data.
1204 */
1205
1206void tty_wakeup(struct tty_struct *tty)
1207{
1208 struct tty_ldisc *ld;
1209
1210 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1211 ld = tty_ldisc_ref(tty);
1212 if(ld) {
1213 if(ld->write_wakeup)
1214 ld->write_wakeup(tty);
1215 tty_ldisc_deref(ld);
1216 }
1217 }
1218 wake_up_interruptible(&tty->write_wait);
1219}
1220
1221EXPORT_SYMBOL_GPL(tty_wakeup);
1222
1223/**
1224 * tty_ldisc_flush - flush line discipline queue
1225 * @tty: tty
1226 *
1227 * Flush the line discipline queue (if any) for this tty. If there
1228 * is no line discipline active this is a no-op.
1229 */
1230
1231void tty_ldisc_flush(struct tty_struct *tty)
1232{
1233 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1234 if(ld) {
1235 if(ld->flush_buffer)
1236 ld->flush_buffer(tty);
1237 tty_ldisc_deref(ld);
1238 }
1239}
1240
1241EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1242
af9b897e
AC
1243/**
1244 * do_tty_hangup - actual handler for hangup events
65f27f38 1245 * @work: tty device
af9b897e
AC
1246 *
1247 * This can be called by the "eventd" kernel thread. That is process
1248 * synchronous but doesn't hold any locks, so we need to make sure we
1249 * have the appropriate locks for what we're doing.
1250 *
1251 * The hangup event clears any pending redirections onto the hung up
1252 * device. It ensures future writes will error and it does the needed
1253 * line discipline hangup and signal delivery. The tty object itself
1254 * remains intact.
1255 *
1256 * Locking:
1257 * BKL
24ec839c
PZ
1258 * redirect lock for undoing redirection
1259 * file list lock for manipulating list of ttys
1260 * tty_ldisc_lock from called functions
1261 * termios_mutex resetting termios data
1262 * tasklist_lock to walk task list for hangup event
1263 * ->siglock to protect ->signal/->sighand
1da177e4 1264 */
65f27f38 1265static void do_tty_hangup(struct work_struct *work)
1da177e4 1266{
65f27f38
DH
1267 struct tty_struct *tty =
1268 container_of(work, struct tty_struct, hangup_work);
1da177e4
LT
1269 struct file * cons_filp = NULL;
1270 struct file *filp, *f = NULL;
1271 struct task_struct *p;
1272 struct tty_ldisc *ld;
1273 int closecount = 0, n;
1274
1275 if (!tty)
1276 return;
1277
1278 /* inuse_filps is protected by the single kernel lock */
1279 lock_kernel();
1280
1281 spin_lock(&redirect_lock);
1282 if (redirect && redirect->private_data == tty) {
1283 f = redirect;
1284 redirect = NULL;
1285 }
1286 spin_unlock(&redirect_lock);
1287
1288 check_tty_count(tty, "do_tty_hangup");
1289 file_list_lock();
1290 /* This breaks for file handles being sent over AF_UNIX sockets ? */
2f512016 1291 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1da177e4
LT
1292 if (filp->f_op->write == redirected_tty_write)
1293 cons_filp = filp;
1294 if (filp->f_op->write != tty_write)
1295 continue;
1296 closecount++;
1297 tty_fasync(-1, filp, 0); /* can't block */
1298 filp->f_op = &hung_up_tty_fops;
1299 }
1300 file_list_unlock();
1301
1302 /* FIXME! What are the locking issues here? This may me overdoing things..
1303 * this question is especially important now that we've removed the irqlock. */
1304
1305 ld = tty_ldisc_ref(tty);
1306 if(ld != NULL) /* We may have no line discipline at this point */
1307 {
1308 if (ld->flush_buffer)
1309 ld->flush_buffer(tty);
1310 if (tty->driver->flush_buffer)
1311 tty->driver->flush_buffer(tty);
1312 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1313 ld->write_wakeup)
1314 ld->write_wakeup(tty);
1315 if (ld->hangup)
1316 ld->hangup(tty);
1317 }
1318
1319 /* FIXME: Once we trust the LDISC code better we can wait here for
1320 ldisc completion and fix the driver call race */
1321
1322 wake_up_interruptible(&tty->write_wait);
1323 wake_up_interruptible(&tty->read_wait);
1324
1325 /*
1326 * Shutdown the current line discipline, and reset it to
1327 * N_TTY.
1328 */
1329 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1330 {
5785c95b 1331 mutex_lock(&tty->termios_mutex);
1da177e4 1332 *tty->termios = tty->driver->init_termios;
5785c95b 1333 mutex_unlock(&tty->termios_mutex);
1da177e4
LT
1334 }
1335
1336 /* Defer ldisc switch */
1337 /* tty_deferred_ldisc_switch(N_TTY);
1338
1339 This should get done automatically when the port closes and
1340 tty_release is called */
1341
1342 read_lock(&tasklist_lock);
1343 if (tty->session > 0) {
1344 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
24ec839c 1345 spin_lock_irq(&p->sighand->siglock);
1da177e4
LT
1346 if (p->signal->tty == tty)
1347 p->signal->tty = NULL;
24ec839c
PZ
1348 if (!p->signal->leader) {
1349 spin_unlock_irq(&p->sighand->siglock);
1da177e4 1350 continue;
24ec839c
PZ
1351 }
1352 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1353 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1da177e4
LT
1354 if (tty->pgrp > 0)
1355 p->signal->tty_old_pgrp = tty->pgrp;
24ec839c 1356 spin_unlock_irq(&p->sighand->siglock);
1da177e4
LT
1357 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1358 }
1359 read_unlock(&tasklist_lock);
1360
1361 tty->flags = 0;
1362 tty->session = 0;
1363 tty->pgrp = -1;
1364 tty->ctrl_status = 0;
1365 /*
1366 * If one of the devices matches a console pointer, we
1367 * cannot just call hangup() because that will cause
1368 * tty->count and state->count to go out of sync.
1369 * So we just call close() the right number of times.
1370 */
1371 if (cons_filp) {
1372 if (tty->driver->close)
1373 for (n = 0; n < closecount; n++)
1374 tty->driver->close(tty, cons_filp);
1375 } else if (tty->driver->hangup)
1376 (tty->driver->hangup)(tty);
1377
1378 /* We don't want to have driver/ldisc interactions beyond
1379 the ones we did here. The driver layer expects no
1380 calls after ->hangup() from the ldisc side. However we
1381 can't yet guarantee all that */
1382
1383 set_bit(TTY_HUPPED, &tty->flags);
1384 if (ld) {
1385 tty_ldisc_enable(tty);
1386 tty_ldisc_deref(ld);
1387 }
1388 unlock_kernel();
1389 if (f)
1390 fput(f);
1391}
1392
af9b897e
AC
1393/**
1394 * tty_hangup - trigger a hangup event
1395 * @tty: tty to hangup
1396 *
1397 * A carrier loss (virtual or otherwise) has occurred on this like
1398 * schedule a hangup sequence to run after this event.
1399 */
1400
1da177e4
LT
1401void tty_hangup(struct tty_struct * tty)
1402{
1403#ifdef TTY_DEBUG_HANGUP
1404 char buf[64];
1405
1406 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1407#endif
1408 schedule_work(&tty->hangup_work);
1409}
1410
1411EXPORT_SYMBOL(tty_hangup);
1412
af9b897e
AC
1413/**
1414 * tty_vhangup - process vhangup
1415 * @tty: tty to hangup
1416 *
1417 * The user has asked via system call for the terminal to be hung up.
1418 * We do this synchronously so that when the syscall returns the process
1419 * is complete. That guarantee is neccessary for security reasons.
1420 */
1421
1da177e4
LT
1422void tty_vhangup(struct tty_struct * tty)
1423{
1424#ifdef TTY_DEBUG_HANGUP
1425 char buf[64];
1426
1427 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1428#endif
65f27f38 1429 do_tty_hangup(&tty->hangup_work);
1da177e4
LT
1430}
1431EXPORT_SYMBOL(tty_vhangup);
1432
af9b897e
AC
1433/**
1434 * tty_hung_up_p - was tty hung up
1435 * @filp: file pointer of tty
1436 *
1437 * Return true if the tty has been subject to a vhangup or a carrier
1438 * loss
1439 */
1440
1da177e4
LT
1441int tty_hung_up_p(struct file * filp)
1442{
1443 return (filp->f_op == &hung_up_tty_fops);
1444}
1445
1446EXPORT_SYMBOL(tty_hung_up_p);
1447
24ec839c
PZ
1448static void session_clear_tty(pid_t session)
1449{
1450 struct task_struct *p;
1451 do_each_task_pid(session, PIDTYPE_SID, p) {
1452 proc_clear_tty(p);
1453 } while_each_task_pid(session, PIDTYPE_SID, p);
1454}
1455
af9b897e
AC
1456/**
1457 * disassociate_ctty - disconnect controlling tty
1458 * @on_exit: true if exiting so need to "hang up" the session
1da177e4 1459 *
af9b897e
AC
1460 * This function is typically called only by the session leader, when
1461 * it wants to disassociate itself from its controlling tty.
1462 *
1463 * It performs the following functions:
1da177e4
LT
1464 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1465 * (2) Clears the tty from being controlling the session
1466 * (3) Clears the controlling tty for all processes in the
1467 * session group.
1468 *
af9b897e
AC
1469 * The argument on_exit is set to 1 if called when a process is
1470 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1471 *
24ec839c 1472 * Locking:
af9b897e 1473 * BKL is taken for hysterical raisins
24ec839c
PZ
1474 * tty_mutex is taken to protect tty
1475 * ->siglock is taken to protect ->signal/->sighand
1476 * tasklist_lock is taken to walk process list for sessions
1477 * ->siglock is taken to protect ->signal/->sighand
1da177e4 1478 */
af9b897e 1479
1da177e4
LT
1480void disassociate_ctty(int on_exit)
1481{
1482 struct tty_struct *tty;
1da177e4 1483 int tty_pgrp = -1;
24ec839c 1484 int session;
1da177e4
LT
1485
1486 lock_kernel();
1487
70522e12 1488 mutex_lock(&tty_mutex);
24ec839c 1489 tty = get_current_tty();
1da177e4
LT
1490 if (tty) {
1491 tty_pgrp = tty->pgrp;
70522e12 1492 mutex_unlock(&tty_mutex);
24ec839c 1493 /* XXX: here we race, there is nothing protecting tty */
1da177e4
LT
1494 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1495 tty_vhangup(tty);
1496 } else {
24ec839c
PZ
1497 pid_t old_pgrp = current->signal->tty_old_pgrp;
1498 if (old_pgrp) {
1499 kill_pg(old_pgrp, SIGHUP, on_exit);
1500 kill_pg(old_pgrp, SIGCONT, on_exit);
1da177e4 1501 }
70522e12 1502 mutex_unlock(&tty_mutex);
1da177e4
LT
1503 unlock_kernel();
1504 return;
1505 }
1506 if (tty_pgrp > 0) {
1507 kill_pg(tty_pgrp, SIGHUP, on_exit);
1508 if (!on_exit)
1509 kill_pg(tty_pgrp, SIGCONT, on_exit);
1510 }
1511
24ec839c 1512 spin_lock_irq(&current->sighand->siglock);
1da177e4 1513 current->signal->tty_old_pgrp = 0;
24ec839c
PZ
1514 session = current->signal->session;
1515 spin_unlock_irq(&current->sighand->siglock);
1516
1517 mutex_lock(&tty_mutex);
1518 /* It is possible that do_tty_hangup has free'd this tty */
1519 tty = get_current_tty();
1520 if (tty) {
1521 tty->session = 0;
1522 tty->pgrp = 0;
1523 } else {
1524#ifdef TTY_DEBUG_HANGUP
1525 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
1526 " = NULL", tty);
1527#endif
1528 }
1529 mutex_unlock(&tty_mutex);
1da177e4
LT
1530
1531 /* Now clear signal->tty under the lock */
1532 read_lock(&tasklist_lock);
24ec839c 1533 session_clear_tty(session);
1da177e4 1534 read_unlock(&tasklist_lock);
1da177e4
LT
1535 unlock_kernel();
1536}
1537
af9b897e
AC
1538
1539/**
1540 * stop_tty - propogate flow control
1541 * @tty: tty to stop
1542 *
1543 * Perform flow control to the driver. For PTY/TTY pairs we
1544 * must also propogate the TIOCKPKT status. May be called
1545 * on an already stopped device and will not re-call the driver
1546 * method.
1547 *
1548 * This functionality is used by both the line disciplines for
1549 * halting incoming flow and by the driver. It may therefore be
1550 * called from any context, may be under the tty atomic_write_lock
1551 * but not always.
1552 *
1553 * Locking:
1554 * Broken. Relies on BKL which is unsafe here.
1555 */
1556
1da177e4
LT
1557void stop_tty(struct tty_struct *tty)
1558{
1559 if (tty->stopped)
1560 return;
1561 tty->stopped = 1;
1562 if (tty->link && tty->link->packet) {
1563 tty->ctrl_status &= ~TIOCPKT_START;
1564 tty->ctrl_status |= TIOCPKT_STOP;
1565 wake_up_interruptible(&tty->link->read_wait);
1566 }
1567 if (tty->driver->stop)
1568 (tty->driver->stop)(tty);
1569}
1570
1571EXPORT_SYMBOL(stop_tty);
1572
af9b897e
AC
1573/**
1574 * start_tty - propogate flow control
1575 * @tty: tty to start
1576 *
1577 * Start a tty that has been stopped if at all possible. Perform
1578 * any neccessary wakeups and propogate the TIOCPKT status. If this
1579 * is the tty was previous stopped and is being started then the
1580 * driver start method is invoked and the line discipline woken.
1581 *
1582 * Locking:
1583 * Broken. Relies on BKL which is unsafe here.
1584 */
1585
1da177e4
LT
1586void start_tty(struct tty_struct *tty)
1587{
1588 if (!tty->stopped || tty->flow_stopped)
1589 return;
1590 tty->stopped = 0;
1591 if (tty->link && tty->link->packet) {
1592 tty->ctrl_status &= ~TIOCPKT_STOP;
1593 tty->ctrl_status |= TIOCPKT_START;
1594 wake_up_interruptible(&tty->link->read_wait);
1595 }
1596 if (tty->driver->start)
1597 (tty->driver->start)(tty);
1598
1599 /* If we have a running line discipline it may need kicking */
1600 tty_wakeup(tty);
1601 wake_up_interruptible(&tty->write_wait);
1602}
1603
1604EXPORT_SYMBOL(start_tty);
1605
af9b897e
AC
1606/**
1607 * tty_read - read method for tty device files
1608 * @file: pointer to tty file
1609 * @buf: user buffer
1610 * @count: size of user buffer
1611 * @ppos: unused
1612 *
1613 * Perform the read system call function on this terminal device. Checks
1614 * for hung up devices before calling the line discipline method.
1615 *
1616 * Locking:
1617 * Locks the line discipline internally while needed
1618 * For historical reasons the line discipline read method is
1619 * invoked under the BKL. This will go away in time so do not rely on it
1620 * in new code. Multiple read calls may be outstanding in parallel.
1621 */
1622
1da177e4
LT
1623static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1624 loff_t *ppos)
1625{
1626 int i;
1627 struct tty_struct * tty;
1628 struct inode *inode;
1629 struct tty_ldisc *ld;
1630
1631 tty = (struct tty_struct *)file->private_data;
1632 inode = file->f_dentry->d_inode;
1633 if (tty_paranoia_check(tty, inode, "tty_read"))
1634 return -EIO;
1635 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1636 return -EIO;
1637
1638 /* We want to wait for the line discipline to sort out in this
1639 situation */
1640 ld = tty_ldisc_ref_wait(tty);
1641 lock_kernel();
1642 if (ld->read)
1643 i = (ld->read)(tty,file,buf,count);
1644 else
1645 i = -EIO;
1646 tty_ldisc_deref(ld);
1647 unlock_kernel();
1648 if (i > 0)
1649 inode->i_atime = current_fs_time(inode->i_sb);
1650 return i;
1651}
1652
1653/*
1654 * Split writes up in sane blocksizes to avoid
1655 * denial-of-service type attacks
1656 */
1657static inline ssize_t do_tty_write(
1658 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1659 struct tty_struct *tty,
1660 struct file *file,
1661 const char __user *buf,
1662 size_t count)
1663{
1664 ssize_t ret = 0, written = 0;
1665 unsigned int chunk;
1666
af9b897e 1667 /* FIXME: O_NDELAY ... */
70522e12 1668 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1da177e4
LT
1669 return -ERESTARTSYS;
1670 }
1671
1672 /*
1673 * We chunk up writes into a temporary buffer. This
1674 * simplifies low-level drivers immensely, since they
1675 * don't have locking issues and user mode accesses.
1676 *
1677 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1678 * big chunk-size..
1679 *
1680 * The default chunk-size is 2kB, because the NTTY
1681 * layer has problems with bigger chunks. It will
1682 * claim to be able to handle more characters than
1683 * it actually does.
af9b897e
AC
1684 *
1685 * FIXME: This can probably go away now except that 64K chunks
1686 * are too likely to fail unless switched to vmalloc...
1da177e4
LT
1687 */
1688 chunk = 2048;
1689 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1690 chunk = 65536;
1691 if (count < chunk)
1692 chunk = count;
1693
70522e12 1694 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1da177e4
LT
1695 if (tty->write_cnt < chunk) {
1696 unsigned char *buf;
1697
1698 if (chunk < 1024)
1699 chunk = 1024;
1700
1701 buf = kmalloc(chunk, GFP_KERNEL);
1702 if (!buf) {
70522e12 1703 mutex_unlock(&tty->atomic_write_lock);
1da177e4
LT
1704 return -ENOMEM;
1705 }
1706 kfree(tty->write_buf);
1707 tty->write_cnt = chunk;
1708 tty->write_buf = buf;
1709 }
1710
1711 /* Do the write .. */
1712 for (;;) {
1713 size_t size = count;
1714 if (size > chunk)
1715 size = chunk;
1716 ret = -EFAULT;
1717 if (copy_from_user(tty->write_buf, buf, size))
1718 break;
1719 lock_kernel();
1720 ret = write(tty, file, tty->write_buf, size);
1721 unlock_kernel();
1722 if (ret <= 0)
1723 break;
1724 written += ret;
1725 buf += ret;
1726 count -= ret;
1727 if (!count)
1728 break;
1729 ret = -ERESTARTSYS;
1730 if (signal_pending(current))
1731 break;
1732 cond_resched();
1733 }
1734 if (written) {
1735 struct inode *inode = file->f_dentry->d_inode;
1736 inode->i_mtime = current_fs_time(inode->i_sb);
1737 ret = written;
1738 }
70522e12 1739 mutex_unlock(&tty->atomic_write_lock);
1da177e4
LT
1740 return ret;
1741}
1742
1743
af9b897e
AC
1744/**
1745 * tty_write - write method for tty device file
1746 * @file: tty file pointer
1747 * @buf: user data to write
1748 * @count: bytes to write
1749 * @ppos: unused
1750 *
1751 * Write data to a tty device via the line discipline.
1752 *
1753 * Locking:
1754 * Locks the line discipline as required
1755 * Writes to the tty driver are serialized by the atomic_write_lock
1756 * and are then processed in chunks to the device. The line discipline
1757 * write method will not be involked in parallel for each device
1758 * The line discipline write method is called under the big
1759 * kernel lock for historical reasons. New code should not rely on this.
1760 */
1761
1da177e4
LT
1762static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1763 loff_t *ppos)
1764{
1765 struct tty_struct * tty;
1766 struct inode *inode = file->f_dentry->d_inode;
1767 ssize_t ret;
1768 struct tty_ldisc *ld;
1769
1770 tty = (struct tty_struct *)file->private_data;
1771 if (tty_paranoia_check(tty, inode, "tty_write"))
1772 return -EIO;
1773 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1774 return -EIO;
1775
1776 ld = tty_ldisc_ref_wait(tty);
1777 if (!ld->write)
1778 ret = -EIO;
1779 else
1780 ret = do_tty_write(ld->write, tty, file, buf, count);
1781 tty_ldisc_deref(ld);
1782 return ret;
1783}
1784
1785ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1786 loff_t *ppos)
1787{
1788 struct file *p = NULL;
1789
1790 spin_lock(&redirect_lock);
1791 if (redirect) {
1792 get_file(redirect);
1793 p = redirect;
1794 }
1795 spin_unlock(&redirect_lock);
1796
1797 if (p) {
1798 ssize_t res;
1799 res = vfs_write(p, buf, count, &p->f_pos);
1800 fput(p);
1801 return res;
1802 }
1803
1804 return tty_write(file, buf, count, ppos);
1805}
1806
1807static char ptychar[] = "pqrstuvwxyzabcde";
1808
af9b897e
AC
1809/**
1810 * pty_line_name - generate name for a pty
1811 * @driver: the tty driver in use
1812 * @index: the minor number
1813 * @p: output buffer of at least 6 bytes
1814 *
1815 * Generate a name from a driver reference and write it to the output
1816 * buffer.
1817 *
1818 * Locking: None
1819 */
1820static void pty_line_name(struct tty_driver *driver, int index, char *p)
1da177e4
LT
1821{
1822 int i = index + driver->name_base;
1823 /* ->name is initialized to "ttyp", but "tty" is expected */
1824 sprintf(p, "%s%c%x",
1825 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1826 ptychar[i >> 4 & 0xf], i & 0xf);
1827}
1828
af9b897e
AC
1829/**
1830 * pty_line_name - generate name for a tty
1831 * @driver: the tty driver in use
1832 * @index: the minor number
1833 * @p: output buffer of at least 7 bytes
1834 *
1835 * Generate a name from a driver reference and write it to the output
1836 * buffer.
1837 *
1838 * Locking: None
1839 */
1840static void tty_line_name(struct tty_driver *driver, int index, char *p)
1da177e4
LT
1841{
1842 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1843}
1844
af9b897e
AC
1845/**
1846 * init_dev - initialise a tty device
1847 * @driver: tty driver we are opening a device on
1848 * @idx: device index
1849 * @tty: returned tty structure
1850 *
1851 * Prepare a tty device. This may not be a "new" clean device but
1852 * could also be an active device. The pty drivers require special
1853 * handling because of this.
1854 *
1855 * Locking:
1856 * The function is called under the tty_mutex, which
1857 * protects us from the tty struct or driver itself going away.
1858 *
1859 * On exit the tty device has the line discipline attached and
1860 * a reference count of 1. If a pair was created for pty/tty use
1861 * and the other was a pty master then it too has a reference count of 1.
1862 *
1da177e4 1863 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
70522e12
IM
1864 * failed open. The new code protects the open with a mutex, so it's
1865 * really quite straightforward. The mutex locking can probably be
1da177e4
LT
1866 * relaxed for the (most common) case of reopening a tty.
1867 */
af9b897e 1868
1da177e4
LT
1869static int init_dev(struct tty_driver *driver, int idx,
1870 struct tty_struct **ret_tty)
1871{
1872 struct tty_struct *tty, *o_tty;
1873 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1874 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
af9b897e 1875 int retval = 0;
1da177e4
LT
1876
1877 /* check whether we're reopening an existing tty */
1878 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1879 tty = devpts_get_tty(idx);
1880 if (tty && driver->subtype == PTY_TYPE_MASTER)
1881 tty = tty->link;
1882 } else {
1883 tty = driver->ttys[idx];
1884 }
1885 if (tty) goto fast_track;
1886
1887 /*
1888 * First time open is complex, especially for PTY devices.
1889 * This code guarantees that either everything succeeds and the
1890 * TTY is ready for operation, or else the table slots are vacated
1891 * and the allocated memory released. (Except that the termios
1892 * and locked termios may be retained.)
1893 */
1894
1895 if (!try_module_get(driver->owner)) {
1896 retval = -ENODEV;
1897 goto end_init;
1898 }
1899
1900 o_tty = NULL;
1901 tp = o_tp = NULL;
1902 ltp = o_ltp = NULL;
1903
1904 tty = alloc_tty_struct();
1905 if(!tty)
1906 goto fail_no_mem;
1907 initialize_tty_struct(tty);
1908 tty->driver = driver;
1909 tty->index = idx;
1910 tty_line_name(driver, idx, tty->name);
1911
1912 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1913 tp_loc = &tty->termios;
1914 ltp_loc = &tty->termios_locked;
1915 } else {
1916 tp_loc = &driver->termios[idx];
1917 ltp_loc = &driver->termios_locked[idx];
1918 }
1919
1920 if (!*tp_loc) {
1921 tp = (struct termios *) kmalloc(sizeof(struct termios),
1922 GFP_KERNEL);
1923 if (!tp)
1924 goto free_mem_out;
1925 *tp = driver->init_termios;
1926 }
1927
1928 if (!*ltp_loc) {
1929 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1930 GFP_KERNEL);
1931 if (!ltp)
1932 goto free_mem_out;
1933 memset(ltp, 0, sizeof(struct termios));
1934 }
1935
1936 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1937 o_tty = alloc_tty_struct();
1938 if (!o_tty)
1939 goto free_mem_out;
1940 initialize_tty_struct(o_tty);
1941 o_tty->driver = driver->other;
1942 o_tty->index = idx;
1943 tty_line_name(driver->other, idx, o_tty->name);
1944
1945 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1946 o_tp_loc = &o_tty->termios;
1947 o_ltp_loc = &o_tty->termios_locked;
1948 } else {
1949 o_tp_loc = &driver->other->termios[idx];
1950 o_ltp_loc = &driver->other->termios_locked[idx];
1951 }
1952
1953 if (!*o_tp_loc) {
1954 o_tp = (struct termios *)
1955 kmalloc(sizeof(struct termios), GFP_KERNEL);
1956 if (!o_tp)
1957 goto free_mem_out;
1958 *o_tp = driver->other->init_termios;
1959 }
1960
1961 if (!*o_ltp_loc) {
1962 o_ltp = (struct termios *)
1963 kmalloc(sizeof(struct termios), GFP_KERNEL);
1964 if (!o_ltp)
1965 goto free_mem_out;
1966 memset(o_ltp, 0, sizeof(struct termios));
1967 }
1968
1969 /*
1970 * Everything allocated ... set up the o_tty structure.
1971 */
1972 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1973 driver->other->ttys[idx] = o_tty;
1974 }
1975 if (!*o_tp_loc)
1976 *o_tp_loc = o_tp;
1977 if (!*o_ltp_loc)
1978 *o_ltp_loc = o_ltp;
1979 o_tty->termios = *o_tp_loc;
1980 o_tty->termios_locked = *o_ltp_loc;
1981 driver->other->refcount++;
1982 if (driver->subtype == PTY_TYPE_MASTER)
1983 o_tty->count++;
1984
1985 /* Establish the links in both directions */
1986 tty->link = o_tty;
1987 o_tty->link = tty;
1988 }
1989
1990 /*
1991 * All structures have been allocated, so now we install them.
1992 * Failures after this point use release_mem to clean up, so
1993 * there's no need to null out the local pointers.
1994 */
1995 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1996 driver->ttys[idx] = tty;
1997 }
1998
1999 if (!*tp_loc)
2000 *tp_loc = tp;
2001 if (!*ltp_loc)
2002 *ltp_loc = ltp;
2003 tty->termios = *tp_loc;
2004 tty->termios_locked = *ltp_loc;
2005 driver->refcount++;
2006 tty->count++;
2007
2008 /*
2009 * Structures all installed ... call the ldisc open routines.
2010 * If we fail here just call release_mem to clean up. No need
2011 * to decrement the use counts, as release_mem doesn't care.
2012 */
2013
2014 if (tty->ldisc.open) {
2015 retval = (tty->ldisc.open)(tty);
2016 if (retval)
2017 goto release_mem_out;
2018 }
2019 if (o_tty && o_tty->ldisc.open) {
2020 retval = (o_tty->ldisc.open)(o_tty);
2021 if (retval) {
2022 if (tty->ldisc.close)
2023 (tty->ldisc.close)(tty);
2024 goto release_mem_out;
2025 }
2026 tty_ldisc_enable(o_tty);
2027 }
2028 tty_ldisc_enable(tty);
2029 goto success;
2030
2031 /*
2032 * This fast open can be used if the tty is already open.
2033 * No memory is allocated, and the only failures are from
2034 * attempting to open a closing tty or attempting multiple
2035 * opens on a pty master.
2036 */
2037fast_track:
2038 if (test_bit(TTY_CLOSING, &tty->flags)) {
2039 retval = -EIO;
2040 goto end_init;
2041 }
2042 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2043 driver->subtype == PTY_TYPE_MASTER) {
2044 /*
2045 * special case for PTY masters: only one open permitted,
2046 * and the slave side open count is incremented as well.
2047 */
2048 if (tty->count) {
2049 retval = -EIO;
2050 goto end_init;
2051 }
2052 tty->link->count++;
2053 }
2054 tty->count++;
2055 tty->driver = driver; /* N.B. why do this every time?? */
2056
2057 /* FIXME */
2058 if(!test_bit(TTY_LDISC, &tty->flags))
2059 printk(KERN_ERR "init_dev but no ldisc\n");
2060success:
2061 *ret_tty = tty;
2062
70522e12 2063 /* All paths come through here to release the mutex */
1da177e4
LT
2064end_init:
2065 return retval;
2066
2067 /* Release locally allocated memory ... nothing placed in slots */
2068free_mem_out:
735d5661 2069 kfree(o_tp);
1da177e4
LT
2070 if (o_tty)
2071 free_tty_struct(o_tty);
735d5661
JJ
2072 kfree(ltp);
2073 kfree(tp);
1da177e4
LT
2074 free_tty_struct(tty);
2075
2076fail_no_mem:
2077 module_put(driver->owner);
2078 retval = -ENOMEM;
2079 goto end_init;
2080
2081 /* call the tty release_mem routine to clean out this slot */
2082release_mem_out:
4050914f
AM
2083 if (printk_ratelimit())
2084 printk(KERN_INFO "init_dev: ldisc open failed, "
2085 "clearing slot %d\n", idx);
1da177e4
LT
2086 release_mem(tty, idx);
2087 goto end_init;
2088}
2089
af9b897e
AC
2090/**
2091 * release_mem - release tty structure memory
2092 *
2093 * Releases memory associated with a tty structure, and clears out the
2094 * driver table slots. This function is called when a device is no longer
2095 * in use. It also gets called when setup of a device fails.
2096 *
2097 * Locking:
2098 * tty_mutex - sometimes only
2099 * takes the file list lock internally when working on the list
2100 * of ttys that the driver keeps.
2101 * FIXME: should we require tty_mutex is held here ??
1da177e4 2102 */
af9b897e 2103
1da177e4
LT
2104static void release_mem(struct tty_struct *tty, int idx)
2105{
2106 struct tty_struct *o_tty;
2107 struct termios *tp;
2108 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2109
2110 if ((o_tty = tty->link) != NULL) {
2111 if (!devpts)
2112 o_tty->driver->ttys[idx] = NULL;
2113 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2114 tp = o_tty->termios;
2115 if (!devpts)
2116 o_tty->driver->termios[idx] = NULL;
2117 kfree(tp);
2118
2119 tp = o_tty->termios_locked;
2120 if (!devpts)
2121 o_tty->driver->termios_locked[idx] = NULL;
2122 kfree(tp);
2123 }
2124 o_tty->magic = 0;
2125 o_tty->driver->refcount--;
2126 file_list_lock();
2127 list_del_init(&o_tty->tty_files);
2128 file_list_unlock();
2129 free_tty_struct(o_tty);
2130 }
2131
2132 if (!devpts)
2133 tty->driver->ttys[idx] = NULL;
2134 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2135 tp = tty->termios;
2136 if (!devpts)
2137 tty->driver->termios[idx] = NULL;
2138 kfree(tp);
2139
2140 tp = tty->termios_locked;
2141 if (!devpts)
2142 tty->driver->termios_locked[idx] = NULL;
2143 kfree(tp);
2144 }
2145
2146 tty->magic = 0;
2147 tty->driver->refcount--;
2148 file_list_lock();
2149 list_del_init(&tty->tty_files);
2150 file_list_unlock();
2151 module_put(tty->driver->owner);
2152 free_tty_struct(tty);
2153}
2154
2155/*
2156 * Even releasing the tty structures is a tricky business.. We have
2157 * to be very careful that the structures are all released at the
2158 * same time, as interrupts might otherwise get the wrong pointers.
2159 *
2160 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2161 * lead to double frees or releasing memory still in use.
2162 */
2163static void release_dev(struct file * filp)
2164{
2165 struct tty_struct *tty, *o_tty;
2166 int pty_master, tty_closing, o_tty_closing, do_sleep;
14a6283e 2167 int devpts;
1da177e4
LT
2168 int idx;
2169 char buf[64];
2170 unsigned long flags;
2171
2172 tty = (struct tty_struct *)filp->private_data;
2173 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2174 return;
2175
2176 check_tty_count(tty, "release_dev");
2177
2178 tty_fasync(-1, filp, 0);
2179
2180 idx = tty->index;
2181 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2182 tty->driver->subtype == PTY_TYPE_MASTER);
2183 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1da177e4
LT
2184 o_tty = tty->link;
2185
2186#ifdef TTY_PARANOIA_CHECK
2187 if (idx < 0 || idx >= tty->driver->num) {
2188 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2189 "free (%s)\n", tty->name);
2190 return;
2191 }
2192 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2193 if (tty != tty->driver->ttys[idx]) {
2194 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2195 "for (%s)\n", idx, tty->name);
2196 return;
2197 }
2198 if (tty->termios != tty->driver->termios[idx]) {
2199 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2200 "for (%s)\n",
2201 idx, tty->name);
2202 return;
2203 }
2204 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2205 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2206 "termios_locked for (%s)\n",
2207 idx, tty->name);
2208 return;
2209 }
2210 }
2211#endif
2212
2213#ifdef TTY_DEBUG_HANGUP
2214 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2215 tty_name(tty, buf), tty->count);
2216#endif
2217
2218#ifdef TTY_PARANOIA_CHECK
2219 if (tty->driver->other &&
2220 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2221 if (o_tty != tty->driver->other->ttys[idx]) {
2222 printk(KERN_DEBUG "release_dev: other->table[%d] "
2223 "not o_tty for (%s)\n",
2224 idx, tty->name);
2225 return;
2226 }
2227 if (o_tty->termios != tty->driver->other->termios[idx]) {
2228 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2229 "not o_termios for (%s)\n",
2230 idx, tty->name);
2231 return;
2232 }
2233 if (o_tty->termios_locked !=
2234 tty->driver->other->termios_locked[idx]) {
2235 printk(KERN_DEBUG "release_dev: other->termios_locked["
2236 "%d] not o_termios_locked for (%s)\n",
2237 idx, tty->name);
2238 return;
2239 }
2240 if (o_tty->link != tty) {
2241 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2242 return;
2243 }
2244 }
2245#endif
2246 if (tty->driver->close)
2247 tty->driver->close(tty, filp);
2248
2249 /*
2250 * Sanity check: if tty->count is going to zero, there shouldn't be
2251 * any waiters on tty->read_wait or tty->write_wait. We test the
2252 * wait queues and kick everyone out _before_ actually starting to
2253 * close. This ensures that we won't block while releasing the tty
2254 * structure.
2255 *
2256 * The test for the o_tty closing is necessary, since the master and
2257 * slave sides may close in any order. If the slave side closes out
2258 * first, its count will be one, since the master side holds an open.
2259 * Thus this test wouldn't be triggered at the time the slave closes,
2260 * so we do it now.
2261 *
2262 * Note that it's possible for the tty to be opened again while we're
2263 * flushing out waiters. By recalculating the closing flags before
2264 * each iteration we avoid any problems.
2265 */
2266 while (1) {
2267 /* Guard against races with tty->count changes elsewhere and
2268 opens on /dev/tty */
2269
70522e12 2270 mutex_lock(&tty_mutex);
1da177e4
LT
2271 tty_closing = tty->count <= 1;
2272 o_tty_closing = o_tty &&
2273 (o_tty->count <= (pty_master ? 1 : 0));
1da177e4
LT
2274 do_sleep = 0;
2275
2276 if (tty_closing) {
2277 if (waitqueue_active(&tty->read_wait)) {
2278 wake_up(&tty->read_wait);
2279 do_sleep++;
2280 }
2281 if (waitqueue_active(&tty->write_wait)) {
2282 wake_up(&tty->write_wait);
2283 do_sleep++;
2284 }
2285 }
2286 if (o_tty_closing) {
2287 if (waitqueue_active(&o_tty->read_wait)) {
2288 wake_up(&o_tty->read_wait);
2289 do_sleep++;
2290 }
2291 if (waitqueue_active(&o_tty->write_wait)) {
2292 wake_up(&o_tty->write_wait);
2293 do_sleep++;
2294 }
2295 }
2296 if (!do_sleep)
2297 break;
2298
2299 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2300 "active!\n", tty_name(tty, buf));
70522e12 2301 mutex_unlock(&tty_mutex);
1da177e4
LT
2302 schedule();
2303 }
2304
2305 /*
2306 * The closing flags are now consistent with the open counts on
2307 * both sides, and we've completed the last operation that could
2308 * block, so it's safe to proceed with closing.
2309 */
1da177e4
LT
2310 if (pty_master) {
2311 if (--o_tty->count < 0) {
2312 printk(KERN_WARNING "release_dev: bad pty slave count "
2313 "(%d) for %s\n",
2314 o_tty->count, tty_name(o_tty, buf));
2315 o_tty->count = 0;
2316 }
2317 }
2318 if (--tty->count < 0) {
2319 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2320 tty->count, tty_name(tty, buf));
2321 tty->count = 0;
2322 }
1da177e4
LT
2323
2324 /*
2325 * We've decremented tty->count, so we need to remove this file
2326 * descriptor off the tty->tty_files list; this serves two
2327 * purposes:
2328 * - check_tty_count sees the correct number of file descriptors
2329 * associated with this tty.
2330 * - do_tty_hangup no longer sees this file descriptor as
2331 * something that needs to be handled for hangups.
2332 */
2333 file_kill(filp);
2334 filp->private_data = NULL;
2335
2336 /*
2337 * Perform some housekeeping before deciding whether to return.
2338 *
2339 * Set the TTY_CLOSING flag if this was the last open. In the
2340 * case of a pty we may have to wait around for the other side
2341 * to close, and TTY_CLOSING makes sure we can't be reopened.
2342 */
2343 if(tty_closing)
2344 set_bit(TTY_CLOSING, &tty->flags);
2345 if(o_tty_closing)
2346 set_bit(TTY_CLOSING, &o_tty->flags);
2347
2348 /*
2349 * If _either_ side is closing, make sure there aren't any
2350 * processes that still think tty or o_tty is their controlling
2351 * tty.
2352 */
2353 if (tty_closing || o_tty_closing) {
1da177e4 2354 read_lock(&tasklist_lock);
24ec839c 2355 session_clear_tty(tty->session);
1da177e4 2356 if (o_tty)
24ec839c 2357 session_clear_tty(o_tty->session);
1da177e4
LT
2358 read_unlock(&tasklist_lock);
2359 }
2360
70522e12 2361 mutex_unlock(&tty_mutex);
da965822 2362
1da177e4
LT
2363 /* check whether both sides are closing ... */
2364 if (!tty_closing || (o_tty && !o_tty_closing))
2365 return;
2366
2367#ifdef TTY_DEBUG_HANGUP
2368 printk(KERN_DEBUG "freeing tty structure...");
2369#endif
2370 /*
2371 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2372 * kill any delayed work. As this is the final close it does not
2373 * race with the set_ldisc code path.
2374 */
2375 clear_bit(TTY_LDISC, &tty->flags);
33f0f88f 2376 cancel_delayed_work(&tty->buf.work);
1da177e4
LT
2377
2378 /*
33f0f88f 2379 * Wait for ->hangup_work and ->buf.work handlers to terminate
1da177e4
LT
2380 */
2381
2382 flush_scheduled_work();
2383
2384 /*
2385 * Wait for any short term users (we know they are just driver
2386 * side waiters as the file is closing so user count on the file
2387 * side is zero.
2388 */
2389 spin_lock_irqsave(&tty_ldisc_lock, flags);
2390 while(tty->ldisc.refcount)
2391 {
2392 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2393 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2394 spin_lock_irqsave(&tty_ldisc_lock, flags);
2395 }
2396 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2397 /*
2398 * Shutdown the current line discipline, and reset it to N_TTY.
2399 * N.B. why reset ldisc when we're releasing the memory??
2400 *
2401 * FIXME: this MUST get fixed for the new reflocking
2402 */
2403 if (tty->ldisc.close)
2404 (tty->ldisc.close)(tty);
2405 tty_ldisc_put(tty->ldisc.num);
2406
2407 /*
2408 * Switch the line discipline back
2409 */
2410 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2411 tty_set_termios_ldisc(tty,N_TTY);
2412 if (o_tty) {
2413 /* FIXME: could o_tty be in setldisc here ? */
2414 clear_bit(TTY_LDISC, &o_tty->flags);
2415 if (o_tty->ldisc.close)
2416 (o_tty->ldisc.close)(o_tty);
2417 tty_ldisc_put(o_tty->ldisc.num);
2418 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2419 tty_set_termios_ldisc(o_tty,N_TTY);
2420 }
2421 /*
2422 * The release_mem function takes care of the details of clearing
2423 * the slots and preserving the termios structure.
2424 */
2425 release_mem(tty, idx);
2426
2427#ifdef CONFIG_UNIX98_PTYS
2428 /* Make this pty number available for reallocation */
2429 if (devpts) {
2430 down(&allocated_ptys_lock);
2431 idr_remove(&allocated_ptys, idx);
2432 up(&allocated_ptys_lock);
2433 }
2434#endif
2435
2436}
2437
af9b897e
AC
2438/**
2439 * tty_open - open a tty device
2440 * @inode: inode of device file
2441 * @filp: file pointer to tty
1da177e4 2442 *
af9b897e
AC
2443 * tty_open and tty_release keep up the tty count that contains the
2444 * number of opens done on a tty. We cannot use the inode-count, as
2445 * different inodes might point to the same tty.
1da177e4 2446 *
af9b897e
AC
2447 * Open-counting is needed for pty masters, as well as for keeping
2448 * track of serial lines: DTR is dropped when the last close happens.
2449 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2450 *
2451 * The termios state of a pty is reset on first open so that
2452 * settings don't persist across reuse.
2453 *
24ec839c
PZ
2454 * Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2455 * tty->count should protect the rest.
2456 * ->siglock protects ->signal/->sighand
1da177e4 2457 */
af9b897e 2458
1da177e4
LT
2459static int tty_open(struct inode * inode, struct file * filp)
2460{
2461 struct tty_struct *tty;
2462 int noctty, retval;
2463 struct tty_driver *driver;
2464 int index;
2465 dev_t device = inode->i_rdev;
2466 unsigned short saved_flags = filp->f_flags;
2467
2468 nonseekable_open(inode, filp);
2469
2470retry_open:
2471 noctty = filp->f_flags & O_NOCTTY;
2472 index = -1;
2473 retval = 0;
2474
70522e12 2475 mutex_lock(&tty_mutex);
1da177e4
LT
2476
2477 if (device == MKDEV(TTYAUX_MAJOR,0)) {
24ec839c
PZ
2478 tty = get_current_tty();
2479 if (!tty) {
70522e12 2480 mutex_unlock(&tty_mutex);
1da177e4
LT
2481 return -ENXIO;
2482 }
24ec839c
PZ
2483 driver = tty->driver;
2484 index = tty->index;
1da177e4
LT
2485 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2486 /* noctty = 1; */
2487 goto got_driver;
2488 }
2489#ifdef CONFIG_VT
2490 if (device == MKDEV(TTY_MAJOR,0)) {
2491 extern struct tty_driver *console_driver;
2492 driver = console_driver;
2493 index = fg_console;
2494 noctty = 1;
2495 goto got_driver;
2496 }
2497#endif
2498 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2499 driver = console_device(&index);
2500 if (driver) {
2501 /* Don't let /dev/console block */
2502 filp->f_flags |= O_NONBLOCK;
2503 noctty = 1;
2504 goto got_driver;
2505 }
70522e12 2506 mutex_unlock(&tty_mutex);
1da177e4
LT
2507 return -ENODEV;
2508 }
2509
2510 driver = get_tty_driver(device, &index);
2511 if (!driver) {
70522e12 2512 mutex_unlock(&tty_mutex);
1da177e4
LT
2513 return -ENODEV;
2514 }
2515got_driver:
2516 retval = init_dev(driver, index, &tty);
70522e12 2517 mutex_unlock(&tty_mutex);
1da177e4
LT
2518 if (retval)
2519 return retval;
2520
2521 filp->private_data = tty;
2522 file_move(filp, &tty->tty_files);
2523 check_tty_count(tty, "tty_open");
2524 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2525 tty->driver->subtype == PTY_TYPE_MASTER)
2526 noctty = 1;
2527#ifdef TTY_DEBUG_HANGUP
2528 printk(KERN_DEBUG "opening %s...", tty->name);
2529#endif
2530 if (!retval) {
2531 if (tty->driver->open)
2532 retval = tty->driver->open(tty, filp);
2533 else
2534 retval = -ENODEV;
2535 }
2536 filp->f_flags = saved_flags;
2537
2538 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2539 retval = -EBUSY;
2540
2541 if (retval) {
2542#ifdef TTY_DEBUG_HANGUP
2543 printk(KERN_DEBUG "error %d in opening %s...", retval,
2544 tty->name);
2545#endif
2546 release_dev(filp);
2547 if (retval != -ERESTARTSYS)
2548 return retval;
2549 if (signal_pending(current))
2550 return retval;
2551 schedule();
2552 /*
2553 * Need to reset f_op in case a hangup happened.
2554 */
2555 if (filp->f_op == &hung_up_tty_fops)
2556 filp->f_op = &tty_fops;
2557 goto retry_open;
2558 }
24ec839c
PZ
2559
2560 mutex_lock(&tty_mutex);
2561 spin_lock_irq(&current->sighand->siglock);
1da177e4
LT
2562 if (!noctty &&
2563 current->signal->leader &&
2564 !current->signal->tty &&
24ec839c
PZ
2565 tty->session == 0)
2566 __proc_set_tty(current, tty);
2567 spin_unlock_irq(&current->sighand->siglock);
2568 mutex_unlock(&tty_mutex);
1da177e4
LT
2569 return 0;
2570}
2571
2572#ifdef CONFIG_UNIX98_PTYS
af9b897e
AC
2573/**
2574 * ptmx_open - open a unix 98 pty master
2575 * @inode: inode of device file
2576 * @filp: file pointer to tty
2577 *
2578 * Allocate a unix98 pty master device from the ptmx driver.
2579 *
2580 * Locking: tty_mutex protects theinit_dev work. tty->count should
2581 protect the rest.
2582 * allocated_ptys_lock handles the list of free pty numbers
2583 */
2584
1da177e4
LT
2585static int ptmx_open(struct inode * inode, struct file * filp)
2586{
2587 struct tty_struct *tty;
2588 int retval;
2589 int index;
2590 int idr_ret;
2591
2592 nonseekable_open(inode, filp);
2593
2594 /* find a device that is not in use. */
2595 down(&allocated_ptys_lock);
2596 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2597 up(&allocated_ptys_lock);
2598 return -ENOMEM;
2599 }
2600 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2601 if (idr_ret < 0) {
2602 up(&allocated_ptys_lock);
2603 if (idr_ret == -EAGAIN)
2604 return -ENOMEM;
2605 return -EIO;
2606 }
2607 if (index >= pty_limit) {
2608 idr_remove(&allocated_ptys, index);
2609 up(&allocated_ptys_lock);
2610 return -EIO;
2611 }
2612 up(&allocated_ptys_lock);
2613
70522e12 2614 mutex_lock(&tty_mutex);
1da177e4 2615 retval = init_dev(ptm_driver, index, &tty);
70522e12 2616 mutex_unlock(&tty_mutex);
1da177e4
LT
2617
2618 if (retval)
2619 goto out;
2620
2621 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2622 filp->private_data = tty;
2623 file_move(filp, &tty->tty_files);
2624
2625 retval = -ENOMEM;
2626 if (devpts_pty_new(tty->link))
2627 goto out1;
2628
2629 check_tty_count(tty, "tty_open");
2630 retval = ptm_driver->open(tty, filp);
2631 if (!retval)
2632 return 0;
2633out1:
2634 release_dev(filp);
9453a5ad 2635 return retval;
1da177e4
LT
2636out:
2637 down(&allocated_ptys_lock);
2638 idr_remove(&allocated_ptys, index);
2639 up(&allocated_ptys_lock);
2640 return retval;
2641}
2642#endif
2643
af9b897e
AC
2644/**
2645 * tty_release - vfs callback for close
2646 * @inode: inode of tty
2647 * @filp: file pointer for handle to tty
2648 *
2649 * Called the last time each file handle is closed that references
2650 * this tty. There may however be several such references.
2651 *
2652 * Locking:
2653 * Takes bkl. See release_dev
2654 */
2655
1da177e4
LT
2656static int tty_release(struct inode * inode, struct file * filp)
2657{
2658 lock_kernel();
2659 release_dev(filp);
2660 unlock_kernel();
2661 return 0;
2662}
2663
af9b897e
AC
2664/**
2665 * tty_poll - check tty status
2666 * @filp: file being polled
2667 * @wait: poll wait structures to update
2668 *
2669 * Call the line discipline polling method to obtain the poll
2670 * status of the device.
2671 *
2672 * Locking: locks called line discipline but ldisc poll method
2673 * may be re-entered freely by other callers.
2674 */
2675
1da177e4
LT
2676static unsigned int tty_poll(struct file * filp, poll_table * wait)
2677{
2678 struct tty_struct * tty;
2679 struct tty_ldisc *ld;
2680 int ret = 0;
2681
2682 tty = (struct tty_struct *)filp->private_data;
2683 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2684 return 0;
2685
2686 ld = tty_ldisc_ref_wait(tty);
2687 if (ld->poll)
2688 ret = (ld->poll)(tty, filp, wait);
2689 tty_ldisc_deref(ld);
2690 return ret;
2691}
2692
2693static int tty_fasync(int fd, struct file * filp, int on)
2694{
2695 struct tty_struct * tty;
2696 int retval;
2697
2698 tty = (struct tty_struct *)filp->private_data;
2699 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2700 return 0;
2701
2702 retval = fasync_helper(fd, filp, on, &tty->fasync);
2703 if (retval <= 0)
2704 return retval;
2705
2706 if (on) {
2707 if (!waitqueue_active(&tty->read_wait))
2708 tty->minimum_to_wake = 1;
2709 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2710 if (retval)
2711 return retval;
2712 } else {
2713 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2714 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2715 }
2716 return 0;
2717}
2718
af9b897e
AC
2719/**
2720 * tiocsti - fake input character
2721 * @tty: tty to fake input into
2722 * @p: pointer to character
2723 *
2724 * Fake input to a tty device. Does the neccessary locking and
2725 * input management.
2726 *
2727 * FIXME: does not honour flow control ??
2728 *
2729 * Locking:
2730 * Called functions take tty_ldisc_lock
2731 * current->signal->tty check is safe without locks
28298232
AC
2732 *
2733 * FIXME: may race normal receive processing
af9b897e
AC
2734 */
2735
1da177e4
LT
2736static int tiocsti(struct tty_struct *tty, char __user *p)
2737{
2738 char ch, mbz = 0;
2739 struct tty_ldisc *ld;
2740
2741 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2742 return -EPERM;
2743 if (get_user(ch, p))
2744 return -EFAULT;
2745 ld = tty_ldisc_ref_wait(tty);
2746 ld->receive_buf(tty, &ch, &mbz, 1);
2747 tty_ldisc_deref(ld);
2748 return 0;
2749}
2750
af9b897e
AC
2751/**
2752 * tiocgwinsz - implement window query ioctl
2753 * @tty; tty
2754 * @arg: user buffer for result
2755 *
808a0d38 2756 * Copies the kernel idea of the window size into the user buffer.
af9b897e 2757 *
24ec839c 2758 * Locking: tty->termios_mutex is taken to ensure the winsize data
808a0d38 2759 * is consistent.
af9b897e
AC
2760 */
2761
1da177e4
LT
2762static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2763{
808a0d38
AC
2764 int err;
2765
5785c95b 2766 mutex_lock(&tty->termios_mutex);
808a0d38 2767 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
5785c95b 2768 mutex_unlock(&tty->termios_mutex);
808a0d38
AC
2769
2770 return err ? -EFAULT: 0;
1da177e4
LT
2771}
2772
af9b897e
AC
2773/**
2774 * tiocswinsz - implement window size set ioctl
2775 * @tty; tty
2776 * @arg: user buffer for result
2777 *
2778 * Copies the user idea of the window size to the kernel. Traditionally
2779 * this is just advisory information but for the Linux console it
2780 * actually has driver level meaning and triggers a VC resize.
2781 *
2782 * Locking:
ca9bda00
AC
2783 * Called function use the console_sem is used to ensure we do
2784 * not try and resize the console twice at once.
24ec839c
PZ
2785 * The tty->termios_mutex is used to ensure we don't double
2786 * resize and get confused. Lock order - tty->termios_mutex before
ca9bda00 2787 * console sem
af9b897e
AC
2788 */
2789
1da177e4
LT
2790static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2791 struct winsize __user * arg)
2792{
2793 struct winsize tmp_ws;
2794
2795 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2796 return -EFAULT;
ca9bda00 2797
5785c95b 2798 mutex_lock(&tty->termios_mutex);
1da177e4 2799 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
ca9bda00
AC
2800 goto done;
2801
1da177e4
LT
2802#ifdef CONFIG_VT
2803 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
5785c95b
AV
2804 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2805 tmp_ws.ws_row)) {
2806 mutex_unlock(&tty->termios_mutex);
ca9bda00
AC
2807 return -ENXIO;
2808 }
1da177e4
LT
2809 }
2810#endif
2811 if (tty->pgrp > 0)
2812 kill_pg(tty->pgrp, SIGWINCH, 1);
2813 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2814 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2815 tty->winsize = tmp_ws;
2816 real_tty->winsize = tmp_ws;
ca9bda00 2817done:
5785c95b 2818 mutex_unlock(&tty->termios_mutex);
1da177e4
LT
2819 return 0;
2820}
2821
af9b897e
AC
2822/**
2823 * tioccons - allow admin to move logical console
2824 * @file: the file to become console
2825 *
2826 * Allow the adminstrator to move the redirected console device
2827 *
2828 * Locking: uses redirect_lock to guard the redirect information
2829 */
2830
1da177e4
LT
2831static int tioccons(struct file *file)
2832{
2833 if (!capable(CAP_SYS_ADMIN))
2834 return -EPERM;
2835 if (file->f_op->write == redirected_tty_write) {
2836 struct file *f;
2837 spin_lock(&redirect_lock);
2838 f = redirect;
2839 redirect = NULL;
2840 spin_unlock(&redirect_lock);
2841 if (f)
2842 fput(f);
2843 return 0;
2844 }
2845 spin_lock(&redirect_lock);
2846 if (redirect) {
2847 spin_unlock(&redirect_lock);
2848 return -EBUSY;
2849 }
2850 get_file(file);
2851 redirect = file;
2852 spin_unlock(&redirect_lock);
2853 return 0;
2854}
2855
af9b897e
AC
2856/**
2857 * fionbio - non blocking ioctl
2858 * @file: file to set blocking value
2859 * @p: user parameter
2860 *
2861 * Historical tty interfaces had a blocking control ioctl before
2862 * the generic functionality existed. This piece of history is preserved
2863 * in the expected tty API of posix OS's.
2864 *
2865 * Locking: none, the open fle handle ensures it won't go away.
2866 */
1da177e4
LT
2867
2868static int fionbio(struct file *file, int __user *p)
2869{
2870 int nonblock;
2871
2872 if (get_user(nonblock, p))
2873 return -EFAULT;
2874
2875 if (nonblock)
2876 file->f_flags |= O_NONBLOCK;
2877 else
2878 file->f_flags &= ~O_NONBLOCK;
2879 return 0;
2880}
2881
af9b897e
AC
2882/**
2883 * tiocsctty - set controlling tty
2884 * @tty: tty structure
2885 * @arg: user argument
2886 *
2887 * This ioctl is used to manage job control. It permits a session
2888 * leader to set this tty as the controlling tty for the session.
2889 *
2890 * Locking:
28298232 2891 * Takes tty_mutex() to protect tty instance
24ec839c
PZ
2892 * Takes tasklist_lock internally to walk sessions
2893 * Takes ->siglock() when updating signal->tty
af9b897e
AC
2894 */
2895
1da177e4
LT
2896static int tiocsctty(struct tty_struct *tty, int arg)
2897{
24ec839c 2898 int ret = 0;
1da177e4
LT
2899 if (current->signal->leader &&
2900 (current->signal->session == tty->session))
24ec839c
PZ
2901 return ret;
2902
2903 mutex_lock(&tty_mutex);
1da177e4
LT
2904 /*
2905 * The process must be a session leader and
2906 * not have a controlling tty already.
2907 */
24ec839c
PZ
2908 if (!current->signal->leader || current->signal->tty) {
2909 ret = -EPERM;
2910 goto unlock;
2911 }
2912
1da177e4
LT
2913 if (tty->session > 0) {
2914 /*
2915 * This tty is already the controlling
2916 * tty for another session group!
2917 */
2918 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2919 /*
2920 * Steal it away
2921 */
1da177e4 2922 read_lock(&tasklist_lock);
24ec839c 2923 session_clear_tty(tty->session);
1da177e4 2924 read_unlock(&tasklist_lock);
24ec839c
PZ
2925 } else {
2926 ret = -EPERM;
2927 goto unlock;
2928 }
1da177e4 2929 }
24ec839c
PZ
2930 proc_set_tty(current, tty);
2931unlock:
28298232 2932 mutex_unlock(&tty_mutex);
24ec839c 2933 return ret;
1da177e4
LT
2934}
2935
af9b897e
AC
2936/**
2937 * tiocgpgrp - get process group
2938 * @tty: tty passed by user
2939 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2940 * @p: returned pid
2941 *
2942 * Obtain the process group of the tty. If there is no process group
2943 * return an error.
2944 *
24ec839c 2945 * Locking: none. Reference to current->signal->tty is safe.
af9b897e
AC
2946 */
2947
1da177e4
LT
2948static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2949{
2950 /*
2951 * (tty == real_tty) is a cheap way of
2952 * testing if the tty is NOT a master pty.
2953 */
2954 if (tty == real_tty && current->signal->tty != real_tty)
2955 return -ENOTTY;
2956 return put_user(real_tty->pgrp, p);
2957}
2958
af9b897e
AC
2959/**
2960 * tiocspgrp - attempt to set process group
2961 * @tty: tty passed by user
2962 * @real_tty: tty side device matching tty passed by user
2963 * @p: pid pointer
2964 *
2965 * Set the process group of the tty to the session passed. Only
2966 * permitted where the tty session is our session.
2967 *
2968 * Locking: None
af9b897e
AC
2969 */
2970
1da177e4
LT
2971static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2972{
2973 pid_t pgrp;
2974 int retval = tty_check_change(real_tty);
2975
2976 if (retval == -EIO)
2977 return -ENOTTY;
2978 if (retval)
2979 return retval;
2980 if (!current->signal->tty ||
2981 (current->signal->tty != real_tty) ||
2982 (real_tty->session != current->signal->session))
2983 return -ENOTTY;
2984 if (get_user(pgrp, p))
2985 return -EFAULT;
2986 if (pgrp < 0)
2987 return -EINVAL;
2988 if (session_of_pgrp(pgrp) != current->signal->session)
2989 return -EPERM;
2990 real_tty->pgrp = pgrp;
2991 return 0;
2992}
2993
af9b897e
AC
2994/**
2995 * tiocgsid - get session id
2996 * @tty: tty passed by user
2997 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2998 * @p: pointer to returned session id
2999 *
3000 * Obtain the session id of the tty. If there is no session
3001 * return an error.
3002 *
24ec839c 3003 * Locking: none. Reference to current->signal->tty is safe.
af9b897e
AC
3004 */
3005
1da177e4
LT
3006static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3007{
3008 /*
3009 * (tty == real_tty) is a cheap way of
3010 * testing if the tty is NOT a master pty.
3011 */
3012 if (tty == real_tty && current->signal->tty != real_tty)
3013 return -ENOTTY;
3014 if (real_tty->session <= 0)
3015 return -ENOTTY;
3016 return put_user(real_tty->session, p);
3017}
3018
af9b897e
AC
3019/**
3020 * tiocsetd - set line discipline
3021 * @tty: tty device
3022 * @p: pointer to user data
3023 *
3024 * Set the line discipline according to user request.
3025 *
3026 * Locking: see tty_set_ldisc, this function is just a helper
3027 */
3028
1da177e4
LT
3029static int tiocsetd(struct tty_struct *tty, int __user *p)
3030{
3031 int ldisc;
3032
3033 if (get_user(ldisc, p))
3034 return -EFAULT;
3035 return tty_set_ldisc(tty, ldisc);
3036}
3037
af9b897e
AC
3038/**
3039 * send_break - performed time break
3040 * @tty: device to break on
3041 * @duration: timeout in mS
3042 *
3043 * Perform a timed break on hardware that lacks its own driver level
3044 * timed break functionality.
3045 *
3046 * Locking:
28298232 3047 * atomic_write_lock serializes
af9b897e 3048 *
af9b897e
AC
3049 */
3050
b20f3ae5 3051static int send_break(struct tty_struct *tty, unsigned int duration)
1da177e4 3052{
28298232
AC
3053 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3054 return -EINTR;
1da177e4
LT
3055 tty->driver->break_ctl(tty, -1);
3056 if (!signal_pending(current)) {
b20f3ae5 3057 msleep_interruptible(duration);
1da177e4
LT
3058 }
3059 tty->driver->break_ctl(tty, 0);
28298232 3060 mutex_unlock(&tty->atomic_write_lock);
1da177e4
LT
3061 if (signal_pending(current))
3062 return -EINTR;
3063 return 0;
3064}
3065
af9b897e
AC
3066/**
3067 * tiocmget - get modem status
3068 * @tty: tty device
3069 * @file: user file pointer
3070 * @p: pointer to result
3071 *
3072 * Obtain the modem status bits from the tty driver if the feature
3073 * is supported. Return -EINVAL if it is not available.
3074 *
3075 * Locking: none (up to the driver)
3076 */
3077
3078static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
1da177e4
LT
3079{
3080 int retval = -EINVAL;
3081
3082 if (tty->driver->tiocmget) {
3083 retval = tty->driver->tiocmget(tty, file);
3084
3085 if (retval >= 0)
3086 retval = put_user(retval, p);
3087 }
3088 return retval;
3089}
3090
af9b897e
AC
3091/**
3092 * tiocmset - set modem status
3093 * @tty: tty device
3094 * @file: user file pointer
3095 * @cmd: command - clear bits, set bits or set all
3096 * @p: pointer to desired bits
3097 *
3098 * Set the modem status bits from the tty driver if the feature
3099 * is supported. Return -EINVAL if it is not available.
3100 *
3101 * Locking: none (up to the driver)
3102 */
3103
3104static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
1da177e4
LT
3105 unsigned __user *p)
3106{
3107 int retval = -EINVAL;
3108
3109 if (tty->driver->tiocmset) {
3110 unsigned int set, clear, val;
3111
3112 retval = get_user(val, p);
3113 if (retval)
3114 return retval;
3115
3116 set = clear = 0;
3117 switch (cmd) {
3118 case TIOCMBIS:
3119 set = val;
3120 break;
3121 case TIOCMBIC:
3122 clear = val;
3123 break;
3124 case TIOCMSET:
3125 set = val;
3126 clear = ~val;
3127 break;
3128 }
3129
3130 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3131 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3132
3133 retval = tty->driver->tiocmset(tty, file, set, clear);
3134 }
3135 return retval;
3136}
3137
3138/*
3139 * Split this up, as gcc can choke on it otherwise..
3140 */
3141int tty_ioctl(struct inode * inode, struct file * file,
3142 unsigned int cmd, unsigned long arg)
3143{
3144 struct tty_struct *tty, *real_tty;
3145 void __user *p = (void __user *)arg;
3146 int retval;
3147 struct tty_ldisc *ld;
3148
3149 tty = (struct tty_struct *)file->private_data;
3150 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3151 return -EINVAL;
3152
28298232
AC
3153 /* CHECKME: is this safe as one end closes ? */
3154
1da177e4
LT
3155 real_tty = tty;
3156 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3157 tty->driver->subtype == PTY_TYPE_MASTER)
3158 real_tty = tty->link;
3159
3160 /*
3161 * Break handling by driver
3162 */
3163 if (!tty->driver->break_ctl) {
3164 switch(cmd) {
3165 case TIOCSBRK:
3166 case TIOCCBRK:
3167 if (tty->driver->ioctl)
3168 return tty->driver->ioctl(tty, file, cmd, arg);
3169 return -EINVAL;
3170
3171 /* These two ioctl's always return success; even if */
3172 /* the driver doesn't support them. */
3173 case TCSBRK:
3174 case TCSBRKP:
3175 if (!tty->driver->ioctl)
3176 return 0;
3177 retval = tty->driver->ioctl(tty, file, cmd, arg);
3178 if (retval == -ENOIOCTLCMD)
3179 retval = 0;
3180 return retval;
3181 }
3182 }
3183
3184 /*
3185 * Factor out some common prep work
3186 */
3187 switch (cmd) {
3188 case TIOCSETD:
3189 case TIOCSBRK:
3190 case TIOCCBRK:
3191 case TCSBRK:
3192 case TCSBRKP:
3193 retval = tty_check_change(tty);
3194 if (retval)
3195 return retval;
3196 if (cmd != TIOCCBRK) {
3197 tty_wait_until_sent(tty, 0);
3198 if (signal_pending(current))
3199 return -EINTR;
3200 }
3201 break;
3202 }
3203
3204 switch (cmd) {
3205 case TIOCSTI:
3206 return tiocsti(tty, p);
3207 case TIOCGWINSZ:
3208 return tiocgwinsz(tty, p);
3209 case TIOCSWINSZ:
3210 return tiocswinsz(tty, real_tty, p);
3211 case TIOCCONS:
3212 return real_tty!=tty ? -EINVAL : tioccons(file);
3213 case FIONBIO:
3214 return fionbio(file, p);
3215 case TIOCEXCL:
3216 set_bit(TTY_EXCLUSIVE, &tty->flags);
3217 return 0;
3218 case TIOCNXCL:
3219 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3220 return 0;
3221 case TIOCNOTTY:
3222 if (current->signal->tty != tty)
3223 return -ENOTTY;
3224 if (current->signal->leader)
3225 disassociate_ctty(0);
24ec839c 3226 proc_clear_tty(current);
1da177e4
LT
3227 return 0;
3228 case TIOCSCTTY:
3229 return tiocsctty(tty, arg);
3230 case TIOCGPGRP:
3231 return tiocgpgrp(tty, real_tty, p);
3232 case TIOCSPGRP:
3233 return tiocspgrp(tty, real_tty, p);
3234 case TIOCGSID:
3235 return tiocgsid(tty, real_tty, p);
3236 case TIOCGETD:
3237 /* FIXME: check this is ok */
3238 return put_user(tty->ldisc.num, (int __user *)p);
3239 case TIOCSETD:
3240 return tiocsetd(tty, p);
3241#ifdef CONFIG_VT
3242 case TIOCLINUX:
3243 return tioclinux(tty, arg);
3244#endif
3245 /*
3246 * Break handling
3247 */
3248 case TIOCSBRK: /* Turn break on, unconditionally */
3249 tty->driver->break_ctl(tty, -1);
3250 return 0;
3251
3252 case TIOCCBRK: /* Turn break off, unconditionally */
3253 tty->driver->break_ctl(tty, 0);
3254 return 0;
3255 case TCSBRK: /* SVID version: non-zero arg --> no break */
283fef59
PF
3256 /* non-zero arg means wait for all output data
3257 * to be sent (performed above) but don't send break.
3258 * This is used by the tcdrain() termios function.
1da177e4
LT
3259 */
3260 if (!arg)
b20f3ae5 3261 return send_break(tty, 250);
1da177e4
LT
3262 return 0;
3263 case TCSBRKP: /* support for POSIX tcsendbreak() */
b20f3ae5 3264 return send_break(tty, arg ? arg*100 : 250);
1da177e4
LT
3265
3266 case TIOCMGET:
3267 return tty_tiocmget(tty, file, p);
3268
3269 case TIOCMSET:
3270 case TIOCMBIC:
3271 case TIOCMBIS:
3272 return tty_tiocmset(tty, file, cmd, p);
3273 }
3274 if (tty->driver->ioctl) {
3275 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3276 if (retval != -ENOIOCTLCMD)
3277 return retval;
3278 }
3279 ld = tty_ldisc_ref_wait(tty);
3280 retval = -EINVAL;
3281 if (ld->ioctl) {
3282 retval = ld->ioctl(tty, file, cmd, arg);
3283 if (retval == -ENOIOCTLCMD)
3284 retval = -EINVAL;
3285 }
3286 tty_ldisc_deref(ld);
3287 return retval;
3288}
3289
3290
3291/*
3292 * This implements the "Secure Attention Key" --- the idea is to
3293 * prevent trojan horses by killing all processes associated with this
3294 * tty when the user hits the "Secure Attention Key". Required for
3295 * super-paranoid applications --- see the Orange Book for more details.
3296 *
3297 * This code could be nicer; ideally it should send a HUP, wait a few
3298 * seconds, then send a INT, and then a KILL signal. But you then
3299 * have to coordinate with the init process, since all processes associated
3300 * with the current tty must be dead before the new getty is allowed
3301 * to spawn.
3302 *
3303 * Now, if it would be correct ;-/ The current code has a nasty hole -
3304 * it doesn't catch files in flight. We may send the descriptor to ourselves
3305 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3306 *
3307 * Nasty bug: do_SAK is being called in interrupt context. This can
3308 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3309 */
65f27f38 3310static void __do_SAK(struct work_struct *work)
1da177e4 3311{
65f27f38
DH
3312 struct tty_struct *tty =
3313 container_of(work, struct tty_struct, SAK_work);
1da177e4
LT
3314#ifdef TTY_SOFT_SAK
3315 tty_hangup(tty);
3316#else
652486fb 3317 struct task_struct *g, *p;
1da177e4
LT
3318 int session;
3319 int i;
3320 struct file *filp;
3321 struct tty_ldisc *disc;
badf1662 3322 struct fdtable *fdt;
1da177e4
LT
3323
3324 if (!tty)
3325 return;
24ec839c 3326 session = tty->session;
1da177e4
LT
3327
3328 /* We don't want an ldisc switch during this */
3329 disc = tty_ldisc_ref(tty);
3330 if (disc && disc->flush_buffer)
3331 disc->flush_buffer(tty);
3332 tty_ldisc_deref(disc);
3333
3334 if (tty->driver->flush_buffer)
3335 tty->driver->flush_buffer(tty);
3336
3337 read_lock(&tasklist_lock);
652486fb 3338 /* Kill the entire session */
1da177e4 3339 do_each_task_pid(session, PIDTYPE_SID, p) {
652486fb
EB
3340 printk(KERN_NOTICE "SAK: killed process %d"
3341 " (%s): p->signal->session==tty->session\n",
3342 p->pid, p->comm);
3343 send_sig(SIGKILL, p, 1);
3344 } while_each_task_pid(session, PIDTYPE_SID, p);
3345 /* Now kill any processes that happen to have the
3346 * tty open.
3347 */
3348 do_each_thread(g, p) {
3349 if (p->signal->tty == tty) {
1da177e4
LT
3350 printk(KERN_NOTICE "SAK: killed process %d"
3351 " (%s): p->signal->session==tty->session\n",
3352 p->pid, p->comm);
3353 send_sig(SIGKILL, p, 1);
3354 continue;
3355 }
3356 task_lock(p);
3357 if (p->files) {
ca99c1da
DS
3358 /*
3359 * We don't take a ref to the file, so we must
3360 * hold ->file_lock instead.
3361 */
3362 spin_lock(&p->files->file_lock);
badf1662
DS
3363 fdt = files_fdtable(p->files);
3364 for (i=0; i < fdt->max_fds; i++) {
1da177e4
LT
3365 filp = fcheck_files(p->files, i);
3366 if (!filp)
3367 continue;
3368 if (filp->f_op->read == tty_read &&
3369 filp->private_data == tty) {
3370 printk(KERN_NOTICE "SAK: killed process %d"
3371 " (%s): fd#%d opened to the tty\n",
3372 p->pid, p->comm, i);
20ac9437 3373 force_sig(SIGKILL, p);
1da177e4
LT
3374 break;
3375 }
3376 }
ca99c1da 3377 spin_unlock(&p->files->file_lock);
1da177e4
LT
3378 }
3379 task_unlock(p);
652486fb 3380 } while_each_thread(g, p);
1da177e4
LT
3381 read_unlock(&tasklist_lock);
3382#endif
3383}
3384
3385/*
3386 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3387 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3388 * the values which we write to it will be identical to the values which it
3389 * already has. --akpm
3390 */
3391void do_SAK(struct tty_struct *tty)
3392{
3393 if (!tty)
3394 return;
65f27f38 3395 PREPARE_WORK(&tty->SAK_work, __do_SAK);
1da177e4
LT
3396 schedule_work(&tty->SAK_work);
3397}
3398
3399EXPORT_SYMBOL(do_SAK);
3400
af9b897e
AC
3401/**
3402 * flush_to_ldisc
65f27f38 3403 * @work: tty structure passed from work queue.
af9b897e
AC
3404 *
3405 * This routine is called out of the software interrupt to flush data
3406 * from the buffer chain to the line discipline.
3407 *
3408 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3409 * while invoking the line discipline receive_buf method. The
3410 * receive_buf method is single threaded for each tty instance.
1da177e4
LT
3411 */
3412
65f27f38 3413static void flush_to_ldisc(struct work_struct *work)
1da177e4 3414{
65f27f38
DH
3415 struct tty_struct *tty =
3416 container_of(work, struct tty_struct, buf.work.work);
1da177e4
LT
3417 unsigned long flags;
3418 struct tty_ldisc *disc;
2c3bb20f 3419 struct tty_buffer *tbuf, *head;
8977d929
PF
3420 char *char_buf;
3421 unsigned char *flag_buf;
1da177e4
LT
3422
3423 disc = tty_ldisc_ref(tty);
3424 if (disc == NULL) /* !TTY_LDISC */
3425 return;
3426
808249ce 3427 spin_lock_irqsave(&tty->buf.lock, flags);
2c3bb20f
PF
3428 head = tty->buf.head;
3429 if (head != NULL) {
3430 tty->buf.head = NULL;
3431 for (;;) {
3432 int count = head->commit - head->read;
3433 if (!count) {
3434 if (head->next == NULL)
3435 break;
3436 tbuf = head;
3437 head = head->next;
3438 tty_buffer_free(tty, tbuf);
3439 continue;
3440 }
3441 if (!tty->receive_room) {
3442 schedule_delayed_work(&tty->buf.work, 1);
3443 break;
3444 }
3445 if (count > tty->receive_room)
3446 count = tty->receive_room;
3447 char_buf = head->char_buf_ptr + head->read;
3448 flag_buf = head->flag_buf_ptr + head->read;
3449 head->read += count;
8977d929
PF
3450 spin_unlock_irqrestore(&tty->buf.lock, flags);
3451 disc->receive_buf(tty, char_buf, flag_buf, count);
3452 spin_lock_irqsave(&tty->buf.lock, flags);
3453 }
2c3bb20f 3454 tty->buf.head = head;
33f0f88f 3455 }
808249ce 3456 spin_unlock_irqrestore(&tty->buf.lock, flags);
817d6d3b 3457
1da177e4
LT
3458 tty_ldisc_deref(disc);
3459}
3460
3461/*
3462 * Routine which returns the baud rate of the tty
3463 *
3464 * Note that the baud_table needs to be kept in sync with the
3465 * include/asm/termbits.h file.
3466 */
3467static int baud_table[] = {
3468 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3469 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3470#ifdef __sparc__
3471 76800, 153600, 307200, 614400, 921600
3472#else
3473 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3474 2500000, 3000000, 3500000, 4000000
3475#endif
3476};
3477
3478static int n_baud_table = ARRAY_SIZE(baud_table);
3479
3480/**
3481 * tty_termios_baud_rate
3482 * @termios: termios structure
3483 *
3484 * Convert termios baud rate data into a speed. This should be called
3485 * with the termios lock held if this termios is a terminal termios
3486 * structure. May change the termios data.
af9b897e
AC
3487 *
3488 * Locking: none
1da177e4
LT
3489 */
3490
3491int tty_termios_baud_rate(struct termios *termios)
3492{
3493 unsigned int cbaud;
3494
3495 cbaud = termios->c_cflag & CBAUD;
3496
3497 if (cbaud & CBAUDEX) {
3498 cbaud &= ~CBAUDEX;
3499
3500 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3501 termios->c_cflag &= ~CBAUDEX;
3502 else
3503 cbaud += 15;
3504 }
3505 return baud_table[cbaud];
3506}
3507
3508EXPORT_SYMBOL(tty_termios_baud_rate);
3509
3510/**
3511 * tty_get_baud_rate - get tty bit rates
3512 * @tty: tty to query
3513 *
3514 * Returns the baud rate as an integer for this terminal. The
3515 * termios lock must be held by the caller and the terminal bit
3516 * flags may be updated.
af9b897e
AC
3517 *
3518 * Locking: none
1da177e4
LT
3519 */
3520
3521int tty_get_baud_rate(struct tty_struct *tty)
3522{
3523 int baud = tty_termios_baud_rate(tty->termios);
3524
3525 if (baud == 38400 && tty->alt_speed) {
3526 if (!tty->warned) {
3527 printk(KERN_WARNING "Use of setserial/setrocket to "
3528 "set SPD_* flags is deprecated\n");
3529 tty->warned = 1;
3530 }
3531 baud = tty->alt_speed;
3532 }
3533
3534 return baud;
3535}
3536
3537EXPORT_SYMBOL(tty_get_baud_rate);
3538
3539/**
3540 * tty_flip_buffer_push - terminal
3541 * @tty: tty to push
3542 *
3543 * Queue a push of the terminal flip buffers to the line discipline. This
3544 * function must not be called from IRQ context if tty->low_latency is set.
3545 *
3546 * In the event of the queue being busy for flipping the work will be
3547 * held off and retried later.
af9b897e
AC
3548 *
3549 * Locking: tty buffer lock. Driver locks in low latency mode.
1da177e4
LT
3550 */
3551
3552void tty_flip_buffer_push(struct tty_struct *tty)
3553{
808249ce
PF
3554 unsigned long flags;
3555 spin_lock_irqsave(&tty->buf.lock, flags);
33b37a33 3556 if (tty->buf.tail != NULL)
8977d929 3557 tty->buf.tail->commit = tty->buf.tail->used;
808249ce
PF
3558 spin_unlock_irqrestore(&tty->buf.lock, flags);
3559
1da177e4 3560 if (tty->low_latency)
65f27f38 3561 flush_to_ldisc(&tty->buf.work.work);
1da177e4 3562 else
33f0f88f 3563 schedule_delayed_work(&tty->buf.work, 1);
1da177e4
LT
3564}
3565
3566EXPORT_SYMBOL(tty_flip_buffer_push);
3567
33f0f88f 3568
af9b897e
AC
3569/**
3570 * initialize_tty_struct
3571 * @tty: tty to initialize
3572 *
3573 * This subroutine initializes a tty structure that has been newly
3574 * allocated.
3575 *
3576 * Locking: none - tty in question must not be exposed at this point
1da177e4 3577 */
af9b897e 3578
1da177e4
LT
3579static void initialize_tty_struct(struct tty_struct *tty)
3580{
3581 memset(tty, 0, sizeof(struct tty_struct));
3582 tty->magic = TTY_MAGIC;
3583 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3584 tty->pgrp = -1;
3585 tty->overrun_time = jiffies;
33f0f88f
AC
3586 tty->buf.head = tty->buf.tail = NULL;
3587 tty_buffer_init(tty);
65f27f38 3588 INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
33f0f88f 3589 init_MUTEX(&tty->buf.pty_sem);
5785c95b 3590 mutex_init(&tty->termios_mutex);
1da177e4
LT
3591 init_waitqueue_head(&tty->write_wait);
3592 init_waitqueue_head(&tty->read_wait);
65f27f38 3593 INIT_WORK(&tty->hangup_work, do_tty_hangup);
70522e12
IM
3594 mutex_init(&tty->atomic_read_lock);
3595 mutex_init(&tty->atomic_write_lock);
1da177e4
LT
3596 spin_lock_init(&tty->read_lock);
3597 INIT_LIST_HEAD(&tty->tty_files);
65f27f38 3598 INIT_WORK(&tty->SAK_work, NULL);
1da177e4
LT
3599}
3600
3601/*
3602 * The default put_char routine if the driver did not define one.
3603 */
af9b897e 3604
1da177e4
LT
3605static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3606{
3607 tty->driver->write(tty, &ch, 1);
3608}
3609
7fe845d1 3610static struct class *tty_class;
1da177e4
LT
3611
3612/**
af9b897e
AC
3613 * tty_register_device - register a tty device
3614 * @driver: the tty driver that describes the tty device
3615 * @index: the index in the tty driver for this tty device
3616 * @device: a struct device that is associated with this tty device.
3617 * This field is optional, if there is no known struct device
3618 * for this tty device it can be set to NULL safely.
1da177e4 3619 *
01107d34
GKH
3620 * Returns a pointer to the struct device for this tty device
3621 * (or ERR_PTR(-EFOO) on error).
1cdcb6b4 3622 *
af9b897e
AC
3623 * This call is required to be made to register an individual tty device
3624 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3625 * that bit is not set, this function should not be called by a tty
3626 * driver.
3627 *
3628 * Locking: ??
1da177e4 3629 */
af9b897e 3630
01107d34
GKH
3631struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3632 struct device *device)
1da177e4
LT
3633{
3634 char name[64];
3635 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3636
3637 if (index >= driver->num) {
3638 printk(KERN_ERR "Attempt to register invalid tty line number "
3639 " (%d).\n", index);
1cdcb6b4 3640 return ERR_PTR(-EINVAL);
1da177e4
LT
3641 }
3642
1da177e4
LT
3643 if (driver->type == TTY_DRIVER_TYPE_PTY)
3644 pty_line_name(driver, index, name);
3645 else
3646 tty_line_name(driver, index, name);
1cdcb6b4 3647
01107d34 3648 return device_create(tty_class, device, dev, name);
1da177e4
LT
3649}
3650
3651/**
af9b897e
AC
3652 * tty_unregister_device - unregister a tty device
3653 * @driver: the tty driver that describes the tty device
3654 * @index: the index in the tty driver for this tty device
1da177e4 3655 *
af9b897e
AC
3656 * If a tty device is registered with a call to tty_register_device() then
3657 * this function must be called when the tty device is gone.
3658 *
3659 * Locking: ??
1da177e4 3660 */
af9b897e 3661
1da177e4
LT
3662void tty_unregister_device(struct tty_driver *driver, unsigned index)
3663{
01107d34 3664 device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
1da177e4
LT
3665}
3666
3667EXPORT_SYMBOL(tty_register_device);
3668EXPORT_SYMBOL(tty_unregister_device);
3669
3670struct tty_driver *alloc_tty_driver(int lines)
3671{
3672 struct tty_driver *driver;
3673
3674 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3675 if (driver) {
3676 memset(driver, 0, sizeof(struct tty_driver));
3677 driver->magic = TTY_DRIVER_MAGIC;
3678 driver->num = lines;
3679 /* later we'll move allocation of tables here */
3680 }
3681 return driver;
3682}
3683
3684void put_tty_driver(struct tty_driver *driver)
3685{
3686 kfree(driver);
3687}
3688
b68e31d0
JD
3689void tty_set_operations(struct tty_driver *driver,
3690 const struct tty_operations *op)
1da177e4
LT
3691{
3692 driver->open = op->open;
3693 driver->close = op->close;
3694 driver->write = op->write;
3695 driver->put_char = op->put_char;
3696 driver->flush_chars = op->flush_chars;
3697 driver->write_room = op->write_room;
3698 driver->chars_in_buffer = op->chars_in_buffer;
3699 driver->ioctl = op->ioctl;
3700 driver->set_termios = op->set_termios;
3701 driver->throttle = op->throttle;
3702 driver->unthrottle = op->unthrottle;
3703 driver->stop = op->stop;
3704 driver->start = op->start;
3705 driver->hangup = op->hangup;
3706 driver->break_ctl = op->break_ctl;
3707 driver->flush_buffer = op->flush_buffer;
3708 driver->set_ldisc = op->set_ldisc;
3709 driver->wait_until_sent = op->wait_until_sent;
3710 driver->send_xchar = op->send_xchar;
3711 driver->read_proc = op->read_proc;
3712 driver->write_proc = op->write_proc;
3713 driver->tiocmget = op->tiocmget;
3714 driver->tiocmset = op->tiocmset;
3715}
3716
3717
3718EXPORT_SYMBOL(alloc_tty_driver);
3719EXPORT_SYMBOL(put_tty_driver);
3720EXPORT_SYMBOL(tty_set_operations);
3721
3722/*
3723 * Called by a tty driver to register itself.
3724 */
3725int tty_register_driver(struct tty_driver *driver)
3726{
3727 int error;
3728 int i;
3729 dev_t dev;
3730 void **p = NULL;
3731
3732 if (driver->flags & TTY_DRIVER_INSTALLED)
3733 return 0;
3734
3735 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3736 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3737 if (!p)
3738 return -ENOMEM;
3739 memset(p, 0, driver->num * 3 * sizeof(void *));
3740 }
3741
3742 if (!driver->major) {
3743 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3744 (char*)driver->name);
3745 if (!error) {
3746 driver->major = MAJOR(dev);
3747 driver->minor_start = MINOR(dev);
3748 }
3749 } else {
3750 dev = MKDEV(driver->major, driver->minor_start);
3751 error = register_chrdev_region(dev, driver->num,
3752 (char*)driver->name);
3753 }
3754 if (error < 0) {
3755 kfree(p);
3756 return error;
3757 }
3758
3759 if (p) {
3760 driver->ttys = (struct tty_struct **)p;
3761 driver->termios = (struct termios **)(p + driver->num);
3762 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3763 } else {
3764 driver->ttys = NULL;
3765 driver->termios = NULL;
3766 driver->termios_locked = NULL;
3767 }
3768
3769 cdev_init(&driver->cdev, &tty_fops);
3770 driver->cdev.owner = driver->owner;
3771 error = cdev_add(&driver->cdev, dev, driver->num);
3772 if (error) {
1da177e4
LT
3773 unregister_chrdev_region(dev, driver->num);
3774 driver->ttys = NULL;
3775 driver->termios = driver->termios_locked = NULL;
3776 kfree(p);
3777 return error;
3778 }
3779
3780 if (!driver->put_char)
3781 driver->put_char = tty_default_put_char;
3782
3783 list_add(&driver->tty_drivers, &tty_drivers);
3784
331b8319 3785 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
1da177e4
LT
3786 for(i = 0; i < driver->num; i++)
3787 tty_register_device(driver, i, NULL);
3788 }
3789 proc_tty_register_driver(driver);
3790 return 0;
3791}
3792
3793EXPORT_SYMBOL(tty_register_driver);
3794
3795/*
3796 * Called by a tty driver to unregister itself.
3797 */
3798int tty_unregister_driver(struct tty_driver *driver)
3799{
3800 int i;
3801 struct termios *tp;
3802 void *p;
3803
3804 if (driver->refcount)
3805 return -EBUSY;
3806
3807 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3808 driver->num);
3809
3810 list_del(&driver->tty_drivers);
3811
3812 /*
3813 * Free the termios and termios_locked structures because
3814 * we don't want to get memory leaks when modular tty
3815 * drivers are removed from the kernel.
3816 */
3817 for (i = 0; i < driver->num; i++) {
3818 tp = driver->termios[i];
3819 if (tp) {
3820 driver->termios[i] = NULL;
3821 kfree(tp);
3822 }
3823 tp = driver->termios_locked[i];
3824 if (tp) {
3825 driver->termios_locked[i] = NULL;
3826 kfree(tp);
3827 }
331b8319 3828 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
1da177e4
LT
3829 tty_unregister_device(driver, i);
3830 }
3831 p = driver->ttys;
3832 proc_tty_unregister_driver(driver);
3833 driver->ttys = NULL;
3834 driver->termios = driver->termios_locked = NULL;
3835 kfree(p);
3836 cdev_del(&driver->cdev);
3837 return 0;
3838}
1da177e4
LT
3839EXPORT_SYMBOL(tty_unregister_driver);
3840
24ec839c
PZ
3841dev_t tty_devnum(struct tty_struct *tty)
3842{
3843 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3844}
3845EXPORT_SYMBOL(tty_devnum);
3846
3847void proc_clear_tty(struct task_struct *p)
3848{
3849 spin_lock_irq(&p->sighand->siglock);
3850 p->signal->tty = NULL;
3851 spin_unlock_irq(&p->sighand->siglock);
3852}
3853EXPORT_SYMBOL(proc_clear_tty);
3854
3855void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3856{
3857 if (tty) {
3858 tty->session = tsk->signal->session;
3859 tty->pgrp = process_group(tsk);
3860 }
3861 tsk->signal->tty = tty;
3862 tsk->signal->tty_old_pgrp = 0;
3863}
3864
3865void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3866{
3867 spin_lock_irq(&tsk->sighand->siglock);
3868 __proc_set_tty(tsk, tty);
3869 spin_unlock_irq(&tsk->sighand->siglock);
3870}
3871
3872struct tty_struct *get_current_tty(void)
3873{
3874 struct tty_struct *tty;
3875 WARN_ON_ONCE(!mutex_is_locked(&tty_mutex));
3876 tty = current->signal->tty;
3877 /*
3878 * session->tty can be changed/cleared from under us, make sure we
3879 * issue the load. The obtained pointer, when not NULL, is valid as
3880 * long as we hold tty_mutex.
3881 */
3882 barrier();
3883 return tty;
3884}
1da177e4
LT
3885
3886/*
3887 * Initialize the console device. This is called *early*, so
3888 * we can't necessarily depend on lots of kernel help here.
3889 * Just do some early initializations, and do the complex setup
3890 * later.
3891 */
3892void __init console_init(void)
3893{
3894 initcall_t *call;
3895
3896 /* Setup the default TTY line discipline. */
3897 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3898
3899 /*
3900 * set up the console device so that later boot sequences can
3901 * inform about problems etc..
3902 */
3903#ifdef CONFIG_EARLY_PRINTK
3904 disable_early_printk();
1da177e4
LT
3905#endif
3906 call = __con_initcall_start;
3907 while (call < __con_initcall_end) {
3908 (*call)();
3909 call++;
3910 }
3911}
3912
3913#ifdef CONFIG_VT
3914extern int vty_init(void);
3915#endif
3916
3917static int __init tty_class_init(void)
3918{
7fe845d1 3919 tty_class = class_create(THIS_MODULE, "tty");
1da177e4
LT
3920 if (IS_ERR(tty_class))
3921 return PTR_ERR(tty_class);
3922 return 0;
3923}
3924
3925postcore_initcall(tty_class_init);
3926
3927/* 3/2004 jmc: why do these devices exist? */
3928
3929static struct cdev tty_cdev, console_cdev;
3930#ifdef CONFIG_UNIX98_PTYS
3931static struct cdev ptmx_cdev;
3932#endif
3933#ifdef CONFIG_VT
3934static struct cdev vc0_cdev;
3935#endif
3936
3937/*
3938 * Ok, now we can initialize the rest of the tty devices and can count
3939 * on memory allocations, interrupts etc..
3940 */
3941static int __init tty_init(void)
3942{
3943 cdev_init(&tty_cdev, &tty_fops);
3944 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3945 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3946 panic("Couldn't register /dev/tty driver\n");
01107d34 3947 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
1da177e4
LT
3948
3949 cdev_init(&console_cdev, &console_fops);
3950 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3951 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3952 panic("Couldn't register /dev/console driver\n");
01107d34 3953 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
1da177e4
LT
3954
3955#ifdef CONFIG_UNIX98_PTYS
3956 cdev_init(&ptmx_cdev, &ptmx_fops);
3957 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3958 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3959 panic("Couldn't register /dev/ptmx driver\n");
01107d34 3960 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
1da177e4
LT
3961#endif
3962
3963#ifdef CONFIG_VT
3964 cdev_init(&vc0_cdev, &console_fops);
3965 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3966 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3967 panic("Couldn't register /dev/tty0 driver\n");
01107d34 3968 device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
1da177e4
LT
3969
3970 vty_init();
3971#endif
3972 return 0;
3973}
3974module_init(tty_init);