aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/char/tty_io.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/char/tty_io.c')
-rw-r--r--drivers/char/tty_io.c2980
1 files changed, 2980 insertions, 0 deletions
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
new file mode 100644
index 000000000000..06e5a3f1836d
--- /dev/null
+++ b/drivers/char/tty_io.c
@@ -0,0 +1,2980 @@
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
68#include <linux/config.h>
69#include <linux/types.h>
70#include <linux/major.h>
71#include <linux/errno.h>
72#include <linux/signal.h>
73#include <linux/fcntl.h>
74#include <linux/sched.h>
75#include <linux/interrupt.h>
76#include <linux/tty.h>
77#include <linux/tty_driver.h>
78#include <linux/tty_flip.h>
79#include <linux/devpts_fs.h>
80#include <linux/file.h>
81#include <linux/console.h>
82#include <linux/timer.h>
83#include <linux/ctype.h>
84#include <linux/kd.h>
85#include <linux/mm.h>
86#include <linux/string.h>
87#include <linux/slab.h>
88#include <linux/poll.h>
89#include <linux/proc_fs.h>
90#include <linux/init.h>
91#include <linux/module.h>
92#include <linux/smp_lock.h>
93#include <linux/device.h>
94#include <linux/idr.h>
95#include <linux/wait.h>
96#include <linux/bitops.h>
97
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>
104#include <linux/devfs_fs_kernel.h>
105
106#include <linux/kmod.h>
107
108#undef TTY_DEBUG_HANGUP
109
110#define TTY_PARANOIA_CHECK 1
111#define CHECK_TTY_COUNT 1
112
113struct termios tty_std_termios = { /* for the benefit of tty drivers */
114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
119 .c_cc = INIT_C_CC
120};
121
122EXPORT_SYMBOL(tty_std_termios);
123
124/* This list gets poked at by procfs and various bits of boot up code. This
125 could do with some rationalisation such as pulling the tty proc function
126 into this file */
127
128LIST_HEAD(tty_drivers); /* linked list of tty drivers */
129
130/* Semaphore to protect creating and releasing a tty. This is shared with
131 vt.c for deeply disgusting hack reasons */
132DECLARE_MUTEX(tty_sem);
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);
155extern void rs_360_init(void);
156static void release_mem(struct tty_struct *tty, int idx);
157
158
159static struct tty_struct *alloc_tty_struct(void)
160{
161 struct tty_struct *tty;
162
163 tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
164 if (tty)
165 memset(tty, 0, sizeof(struct tty_struct));
166 return tty;
167}
168
169static inline void free_tty_struct(struct tty_struct *tty)
170{
171 kfree(tty->write_buf);
172 kfree(tty);
173}
174
175#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
176
177char *tty_name(struct tty_struct *tty, char *buf)
178{
179 if (!tty) /* Hmm. NULL pointer. That's fun. */
180 strcpy(buf, "NULL tty");
181 else
182 strcpy(buf, tty->name);
183 return buf;
184}
185
186EXPORT_SYMBOL(tty_name);
187
188inline int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
189 const char *routine)
190{
191#ifdef TTY_PARANOIA_CHECK
192 if (!tty) {
193 printk(KERN_WARNING
194 "null TTY for (%d:%d) in %s\n",
195 imajor(inode), iminor(inode), routine);
196 return 1;
197 }
198 if (tty->magic != TTY_MAGIC) {
199 printk(KERN_WARNING
200 "bad magic number for tty struct (%d:%d) in %s\n",
201 imajor(inode), iminor(inode), routine);
202 return 1;
203 }
204#endif
205 return 0;
206}
207
208static int check_tty_count(struct tty_struct *tty, const char *routine)
209{
210#ifdef CHECK_TTY_COUNT
211 struct list_head *p;
212 int count = 0;
213
214 file_list_lock();
215 list_for_each(p, &tty->tty_files) {
216 count++;
217 }
218 file_list_unlock();
219 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
220 tty->driver->subtype == PTY_TYPE_SLAVE &&
221 tty->link && tty->link->count)
222 count++;
223 if (tty->count != count) {
224 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
225 "!= #fd's(%d) in %s\n",
226 tty->name, tty->count, count, routine);
227 return count;
228 }
229#endif
230 return 0;
231}
232
233/*
234 * This is probably overkill for real world processors but
235 * they are not on hot paths so a little discipline won't do
236 * any harm.
237 */
238
239static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
240{
241 down(&tty->termios_sem);
242 tty->termios->c_line = num;
243 up(&tty->termios_sem);
244}
245
246/*
247 * This guards the refcounted line discipline lists. The lock
248 * must be taken with irqs off because there are hangup path
249 * callers who will do ldisc lookups and cannot sleep.
250 */
251
252static DEFINE_SPINLOCK(tty_ldisc_lock);
253static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
254static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
255
256int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
257{
258 unsigned long flags;
259 int ret = 0;
260
261 if (disc < N_TTY || disc >= NR_LDISCS)
262 return -EINVAL;
263
264 spin_lock_irqsave(&tty_ldisc_lock, flags);
265 if (new_ldisc) {
266 tty_ldiscs[disc] = *new_ldisc;
267 tty_ldiscs[disc].num = disc;
268 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
269 tty_ldiscs[disc].refcount = 0;
270 } else {
271 if(tty_ldiscs[disc].refcount)
272 ret = -EBUSY;
273 else
274 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
275 }
276 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
277
278 return ret;
279}
280
281EXPORT_SYMBOL(tty_register_ldisc);
282
283struct tty_ldisc *tty_ldisc_get(int disc)
284{
285 unsigned long flags;
286 struct tty_ldisc *ld;
287
288 if (disc < N_TTY || disc >= NR_LDISCS)
289 return NULL;
290
291 spin_lock_irqsave(&tty_ldisc_lock, flags);
292
293 ld = &tty_ldiscs[disc];
294 /* Check the entry is defined */
295 if(ld->flags & LDISC_FLAG_DEFINED)
296 {
297 /* If the module is being unloaded we can't use it */
298 if (!try_module_get(ld->owner))
299 ld = NULL;
300 else /* lock it */
301 ld->refcount++;
302 }
303 else
304 ld = NULL;
305 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
306 return ld;
307}
308
309EXPORT_SYMBOL_GPL(tty_ldisc_get);
310
311void tty_ldisc_put(int disc)
312{
313 struct tty_ldisc *ld;
314 unsigned long flags;
315
316 if (disc < N_TTY || disc >= NR_LDISCS)
317 BUG();
318
319 spin_lock_irqsave(&tty_ldisc_lock, flags);
320 ld = &tty_ldiscs[disc];
321 if(ld->refcount == 0)
322 BUG();
323 ld->refcount --;
324 module_put(ld->owner);
325 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
326}
327
328EXPORT_SYMBOL_GPL(tty_ldisc_put);
329
330static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
331{
332 tty->ldisc = *ld;
333 tty->ldisc.refcount = 0;
334}
335
336/**
337 * tty_ldisc_try - internal helper
338 * @tty: the tty
339 *
340 * Make a single attempt to grab and bump the refcount on
341 * the tty ldisc. Return 0 on failure or 1 on success. This is
342 * used to implement both the waiting and non waiting versions
343 * of tty_ldisc_ref
344 */
345
346static int tty_ldisc_try(struct tty_struct *tty)
347{
348 unsigned long flags;
349 struct tty_ldisc *ld;
350 int ret = 0;
351
352 spin_lock_irqsave(&tty_ldisc_lock, flags);
353 ld = &tty->ldisc;
354 if(test_bit(TTY_LDISC, &tty->flags))
355 {
356 ld->refcount++;
357 ret = 1;
358 }
359 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
360 return ret;
361}
362
363/**
364 * tty_ldisc_ref_wait - wait for the tty ldisc
365 * @tty: tty device
366 *
367 * Dereference the line discipline for the terminal and take a
368 * reference to it. If the line discipline is in flux then
369 * wait patiently until it changes.
370 *
371 * Note: Must not be called from an IRQ/timer context. The caller
372 * must also be careful not to hold other locks that will deadlock
373 * against a discipline change, such as an existing ldisc reference
374 * (which we check for)
375 */
376
377struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
378{
379 /* wait_event is a macro */
380 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
381 if(tty->ldisc.refcount == 0)
382 printk(KERN_ERR "tty_ldisc_ref_wait\n");
383 return &tty->ldisc;
384}
385
386EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
387
388/**
389 * tty_ldisc_ref - get the tty ldisc
390 * @tty: tty device
391 *
392 * Dereference the line discipline for the terminal and take a
393 * reference to it. If the line discipline is in flux then
394 * return NULL. Can be called from IRQ and timer functions.
395 */
396
397struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
398{
399 if(tty_ldisc_try(tty))
400 return &tty->ldisc;
401 return NULL;
402}
403
404EXPORT_SYMBOL_GPL(tty_ldisc_ref);
405
406/**
407 * tty_ldisc_deref - free a tty ldisc reference
408 * @ld: reference to free up
409 *
410 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
411 * be called in IRQ context.
412 */
413
414void tty_ldisc_deref(struct tty_ldisc *ld)
415{
416 unsigned long flags;
417
418 if(ld == NULL)
419 BUG();
420
421 spin_lock_irqsave(&tty_ldisc_lock, flags);
422 if(ld->refcount == 0)
423 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
424 else
425 ld->refcount--;
426 if(ld->refcount == 0)
427 wake_up(&tty_ldisc_wait);
428 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
429}
430
431EXPORT_SYMBOL_GPL(tty_ldisc_deref);
432
433/**
434 * tty_ldisc_enable - allow ldisc use
435 * @tty: terminal to activate ldisc on
436 *
437 * Set the TTY_LDISC flag when the line discipline can be called
438 * again. Do neccessary wakeups for existing sleepers.
439 *
440 * Note: nobody should set this bit except via this function. Clearing
441 * directly is allowed.
442 */
443
444static void tty_ldisc_enable(struct tty_struct *tty)
445{
446 set_bit(TTY_LDISC, &tty->flags);
447 wake_up(&tty_ldisc_wait);
448}
449
450/**
451 * tty_set_ldisc - set line discipline
452 * @tty: the terminal to set
453 * @ldisc: the line discipline
454 *
455 * Set the discipline of a tty line. Must be called from a process
456 * context.
457 */
458
459static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
460{
461 int retval = 0;
462 struct tty_ldisc o_ldisc;
463 char buf[64];
464 int work;
465 unsigned long flags;
466 struct tty_ldisc *ld;
467
468 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
469 return -EINVAL;
470
471restart:
472
473 if (tty->ldisc.num == ldisc)
474 return 0; /* We are already in the desired discipline */
475
476 ld = tty_ldisc_get(ldisc);
477 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
478 /* Cyrus Durgin <cider@speakeasy.org> */
479 if (ld == NULL) {
480 request_module("tty-ldisc-%d", ldisc);
481 ld = tty_ldisc_get(ldisc);
482 }
483 if (ld == NULL)
484 return -EINVAL;
485
486 o_ldisc = tty->ldisc;
487
488 tty_wait_until_sent(tty, 0);
489
490 /*
491 * Make sure we don't change while someone holds a
492 * reference to the line discipline. The TTY_LDISC bit
493 * prevents anyone taking a reference once it is clear.
494 * We need the lock to avoid racing reference takers.
495 */
496
497 spin_lock_irqsave(&tty_ldisc_lock, flags);
498 if(tty->ldisc.refcount)
499 {
500 /* Free the new ldisc we grabbed. Must drop the lock
501 first. */
502 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
503 tty_ldisc_put(ldisc);
504 /*
505 * There are several reasons we may be busy, including
506 * random momentary I/O traffic. We must therefore
507 * retry. We could distinguish between blocking ops
508 * and retries if we made tty_ldisc_wait() smarter. That
509 * is up for discussion.
510 */
511 if(wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
512 return -ERESTARTSYS;
513 goto restart;
514 }
515 clear_bit(TTY_LDISC, &tty->flags);
516 clear_bit(TTY_DONT_FLIP, &tty->flags);
517 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
518
519 /*
520 * From this point on we know nobody has an ldisc
521 * usage reference, nor can they obtain one until
522 * we say so later on.
523 */
524
525 work = cancel_delayed_work(&tty->flip.work);
526 /*
527 * Wait for ->hangup_work and ->flip.work handlers to terminate
528 */
529
530 flush_scheduled_work();
531 /* Shutdown the current discipline. */
532 if (tty->ldisc.close)
533 (tty->ldisc.close)(tty);
534
535 /* Now set up the new line discipline. */
536 tty_ldisc_assign(tty, ld);
537 tty_set_termios_ldisc(tty, ldisc);
538 if (tty->ldisc.open)
539 retval = (tty->ldisc.open)(tty);
540 if (retval < 0) {
541 tty_ldisc_put(ldisc);
542 /* There is an outstanding reference here so this is safe */
543 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
544 tty_set_termios_ldisc(tty, tty->ldisc.num);
545 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
546 tty_ldisc_put(o_ldisc.num);
547 /* This driver is always present */
548 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
549 tty_set_termios_ldisc(tty, N_TTY);
550 if (tty->ldisc.open) {
551 int r = tty->ldisc.open(tty);
552
553 if (r < 0)
554 panic("Couldn't open N_TTY ldisc for "
555 "%s --- error %d.",
556 tty_name(tty, buf), r);
557 }
558 }
559 }
560 /* At this point we hold a reference to the new ldisc and a
561 a reference to the old ldisc. If we ended up flipping back
562 to the existing ldisc we have two references to it */
563
564 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
565 tty->driver->set_ldisc(tty);
566
567 tty_ldisc_put(o_ldisc.num);
568
569 /*
570 * Allow ldisc referencing to occur as soon as the driver
571 * ldisc callback completes.
572 */
573
574 tty_ldisc_enable(tty);
575
576 /* Restart it in case no characters kick it off. Safe if
577 already running */
578 if(work)
579 schedule_delayed_work(&tty->flip.work, 1);
580 return retval;
581}
582
583/*
584 * This routine returns a tty driver structure, given a device number
585 */
586static struct tty_driver *get_tty_driver(dev_t device, int *index)
587{
588 struct tty_driver *p;
589
590 list_for_each_entry(p, &tty_drivers, tty_drivers) {
591 dev_t base = MKDEV(p->major, p->minor_start);
592 if (device < base || device >= base + p->num)
593 continue;
594 *index = device - base;
595 return p;
596 }
597 return NULL;
598}
599
600/*
601 * If we try to write to, or set the state of, a terminal and we're
602 * not in the foreground, send a SIGTTOU. If the signal is blocked or
603 * ignored, go ahead and perform the operation. (POSIX 7.2)
604 */
605int tty_check_change(struct tty_struct * tty)
606{
607 if (current->signal->tty != tty)
608 return 0;
609 if (tty->pgrp <= 0) {
610 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
611 return 0;
612 }
613 if (process_group(current) == tty->pgrp)
614 return 0;
615 if (is_ignored(SIGTTOU))
616 return 0;
617 if (is_orphaned_pgrp(process_group(current)))
618 return -EIO;
619 (void) kill_pg(process_group(current), SIGTTOU, 1);
620 return -ERESTARTSYS;
621}
622
623EXPORT_SYMBOL(tty_check_change);
624
625static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
626 size_t count, loff_t *ppos)
627{
628 return 0;
629}
630
631static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
632 size_t count, loff_t *ppos)
633{
634 return -EIO;
635}
636
637/* No kernel lock held - none needed ;) */
638static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
639{
640 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
641}
642
643static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
644 unsigned int cmd, unsigned long arg)
645{
646 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
647}
648
649static struct file_operations tty_fops = {
650 .llseek = no_llseek,
651 .read = tty_read,
652 .write = tty_write,
653 .poll = tty_poll,
654 .ioctl = tty_ioctl,
655 .open = tty_open,
656 .release = tty_release,
657 .fasync = tty_fasync,
658};
659
660#ifdef CONFIG_UNIX98_PTYS
661static struct file_operations ptmx_fops = {
662 .llseek = no_llseek,
663 .read = tty_read,
664 .write = tty_write,
665 .poll = tty_poll,
666 .ioctl = tty_ioctl,
667 .open = ptmx_open,
668 .release = tty_release,
669 .fasync = tty_fasync,
670};
671#endif
672
673static struct file_operations console_fops = {
674 .llseek = no_llseek,
675 .read = tty_read,
676 .write = redirected_tty_write,
677 .poll = tty_poll,
678 .ioctl = tty_ioctl,
679 .open = tty_open,
680 .release = tty_release,
681 .fasync = tty_fasync,
682};
683
684static struct file_operations hung_up_tty_fops = {
685 .llseek = no_llseek,
686 .read = hung_up_tty_read,
687 .write = hung_up_tty_write,
688 .poll = hung_up_tty_poll,
689 .ioctl = hung_up_tty_ioctl,
690 .release = tty_release,
691};
692
693static DEFINE_SPINLOCK(redirect_lock);
694static struct file *redirect;
695
696/**
697 * tty_wakeup - request more data
698 * @tty: terminal
699 *
700 * Internal and external helper for wakeups of tty. This function
701 * informs the line discipline if present that the driver is ready
702 * to receive more output data.
703 */
704
705void tty_wakeup(struct tty_struct *tty)
706{
707 struct tty_ldisc *ld;
708
709 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
710 ld = tty_ldisc_ref(tty);
711 if(ld) {
712 if(ld->write_wakeup)
713 ld->write_wakeup(tty);
714 tty_ldisc_deref(ld);
715 }
716 }
717 wake_up_interruptible(&tty->write_wait);
718}
719
720EXPORT_SYMBOL_GPL(tty_wakeup);
721
722/**
723 * tty_ldisc_flush - flush line discipline queue
724 * @tty: tty
725 *
726 * Flush the line discipline queue (if any) for this tty. If there
727 * is no line discipline active this is a no-op.
728 */
729
730void tty_ldisc_flush(struct tty_struct *tty)
731{
732 struct tty_ldisc *ld = tty_ldisc_ref(tty);
733 if(ld) {
734 if(ld->flush_buffer)
735 ld->flush_buffer(tty);
736 tty_ldisc_deref(ld);
737 }
738}
739
740EXPORT_SYMBOL_GPL(tty_ldisc_flush);
741
742/*
743 * This can be called by the "eventd" kernel thread. That is process synchronous,
744 * but doesn't hold any locks, so we need to make sure we have the appropriate
745 * locks for what we're doing..
746 */
747static void do_tty_hangup(void *data)
748{
749 struct tty_struct *tty = (struct tty_struct *) data;
750 struct file * cons_filp = NULL;
751 struct file *filp, *f = NULL;
752 struct task_struct *p;
753 struct tty_ldisc *ld;
754 int closecount = 0, n;
755
756 if (!tty)
757 return;
758
759 /* inuse_filps is protected by the single kernel lock */
760 lock_kernel();
761
762 spin_lock(&redirect_lock);
763 if (redirect && redirect->private_data == tty) {
764 f = redirect;
765 redirect = NULL;
766 }
767 spin_unlock(&redirect_lock);
768
769 check_tty_count(tty, "do_tty_hangup");
770 file_list_lock();
771 /* This breaks for file handles being sent over AF_UNIX sockets ? */
772 list_for_each_entry(filp, &tty->tty_files, f_list) {
773 if (filp->f_op->write == redirected_tty_write)
774 cons_filp = filp;
775 if (filp->f_op->write != tty_write)
776 continue;
777 closecount++;
778 tty_fasync(-1, filp, 0); /* can't block */
779 filp->f_op = &hung_up_tty_fops;
780 }
781 file_list_unlock();
782
783 /* FIXME! What are the locking issues here? This may me overdoing things..
784 * this question is especially important now that we've removed the irqlock. */
785
786 ld = tty_ldisc_ref(tty);
787 if(ld != NULL) /* We may have no line discipline at this point */
788 {
789 if (ld->flush_buffer)
790 ld->flush_buffer(tty);
791 if (tty->driver->flush_buffer)
792 tty->driver->flush_buffer(tty);
793 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
794 ld->write_wakeup)
795 ld->write_wakeup(tty);
796 if (ld->hangup)
797 ld->hangup(tty);
798 }
799
800 /* FIXME: Once we trust the LDISC code better we can wait here for
801 ldisc completion and fix the driver call race */
802
803 wake_up_interruptible(&tty->write_wait);
804 wake_up_interruptible(&tty->read_wait);
805
806 /*
807 * Shutdown the current line discipline, and reset it to
808 * N_TTY.
809 */
810 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
811 {
812 down(&tty->termios_sem);
813 *tty->termios = tty->driver->init_termios;
814 up(&tty->termios_sem);
815 }
816
817 /* Defer ldisc switch */
818 /* tty_deferred_ldisc_switch(N_TTY);
819
820 This should get done automatically when the port closes and
821 tty_release is called */
822
823 read_lock(&tasklist_lock);
824 if (tty->session > 0) {
825 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
826 if (p->signal->tty == tty)
827 p->signal->tty = NULL;
828 if (!p->signal->leader)
829 continue;
830 send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
831 send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
832 if (tty->pgrp > 0)
833 p->signal->tty_old_pgrp = tty->pgrp;
834 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
835 }
836 read_unlock(&tasklist_lock);
837
838 tty->flags = 0;
839 tty->session = 0;
840 tty->pgrp = -1;
841 tty->ctrl_status = 0;
842 /*
843 * If one of the devices matches a console pointer, we
844 * cannot just call hangup() because that will cause
845 * tty->count and state->count to go out of sync.
846 * So we just call close() the right number of times.
847 */
848 if (cons_filp) {
849 if (tty->driver->close)
850 for (n = 0; n < closecount; n++)
851 tty->driver->close(tty, cons_filp);
852 } else if (tty->driver->hangup)
853 (tty->driver->hangup)(tty);
854
855 /* We don't want to have driver/ldisc interactions beyond
856 the ones we did here. The driver layer expects no
857 calls after ->hangup() from the ldisc side. However we
858 can't yet guarantee all that */
859
860 set_bit(TTY_HUPPED, &tty->flags);
861 if (ld) {
862 tty_ldisc_enable(tty);
863 tty_ldisc_deref(ld);
864 }
865 unlock_kernel();
866 if (f)
867 fput(f);
868}
869
870void tty_hangup(struct tty_struct * tty)
871{
872#ifdef TTY_DEBUG_HANGUP
873 char buf[64];
874
875 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
876#endif
877 schedule_work(&tty->hangup_work);
878}
879
880EXPORT_SYMBOL(tty_hangup);
881
882void tty_vhangup(struct tty_struct * tty)
883{
884#ifdef TTY_DEBUG_HANGUP
885 char buf[64];
886
887 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
888#endif
889 do_tty_hangup((void *) tty);
890}
891EXPORT_SYMBOL(tty_vhangup);
892
893int tty_hung_up_p(struct file * filp)
894{
895 return (filp->f_op == &hung_up_tty_fops);
896}
897
898EXPORT_SYMBOL(tty_hung_up_p);
899
900/*
901 * This function is typically called only by the session leader, when
902 * it wants to disassociate itself from its controlling tty.
903 *
904 * It performs the following functions:
905 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
906 * (2) Clears the tty from being controlling the session
907 * (3) Clears the controlling tty for all processes in the
908 * session group.
909 *
910 * The argument on_exit is set to 1 if called when a process is
911 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
912 */
913void disassociate_ctty(int on_exit)
914{
915 struct tty_struct *tty;
916 struct task_struct *p;
917 int tty_pgrp = -1;
918
919 lock_kernel();
920
921 down(&tty_sem);
922 tty = current->signal->tty;
923 if (tty) {
924 tty_pgrp = tty->pgrp;
925 up(&tty_sem);
926 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
927 tty_vhangup(tty);
928 } else {
929 if (current->signal->tty_old_pgrp) {
930 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
931 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
932 }
933 up(&tty_sem);
934 unlock_kernel();
935 return;
936 }
937 if (tty_pgrp > 0) {
938 kill_pg(tty_pgrp, SIGHUP, on_exit);
939 if (!on_exit)
940 kill_pg(tty_pgrp, SIGCONT, on_exit);
941 }
942
943 /* Must lock changes to tty_old_pgrp */
944 down(&tty_sem);
945 current->signal->tty_old_pgrp = 0;
946 tty->session = 0;
947 tty->pgrp = -1;
948
949 /* Now clear signal->tty under the lock */
950 read_lock(&tasklist_lock);
951 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
952 p->signal->tty = NULL;
953 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
954 read_unlock(&tasklist_lock);
955 up(&tty_sem);
956 unlock_kernel();
957}
958
959void stop_tty(struct tty_struct *tty)
960{
961 if (tty->stopped)
962 return;
963 tty->stopped = 1;
964 if (tty->link && tty->link->packet) {
965 tty->ctrl_status &= ~TIOCPKT_START;
966 tty->ctrl_status |= TIOCPKT_STOP;
967 wake_up_interruptible(&tty->link->read_wait);
968 }
969 if (tty->driver->stop)
970 (tty->driver->stop)(tty);
971}
972
973EXPORT_SYMBOL(stop_tty);
974
975void start_tty(struct tty_struct *tty)
976{
977 if (!tty->stopped || tty->flow_stopped)
978 return;
979 tty->stopped = 0;
980 if (tty->link && tty->link->packet) {
981 tty->ctrl_status &= ~TIOCPKT_STOP;
982 tty->ctrl_status |= TIOCPKT_START;
983 wake_up_interruptible(&tty->link->read_wait);
984 }
985 if (tty->driver->start)
986 (tty->driver->start)(tty);
987
988 /* If we have a running line discipline it may need kicking */
989 tty_wakeup(tty);
990 wake_up_interruptible(&tty->write_wait);
991}
992
993EXPORT_SYMBOL(start_tty);
994
995static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
996 loff_t *ppos)
997{
998 int i;
999 struct tty_struct * tty;
1000 struct inode *inode;
1001 struct tty_ldisc *ld;
1002
1003 tty = (struct tty_struct *)file->private_data;
1004 inode = file->f_dentry->d_inode;
1005 if (tty_paranoia_check(tty, inode, "tty_read"))
1006 return -EIO;
1007 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1008 return -EIO;
1009
1010 /* We want to wait for the line discipline to sort out in this
1011 situation */
1012 ld = tty_ldisc_ref_wait(tty);
1013 lock_kernel();
1014 if (ld->read)
1015 i = (ld->read)(tty,file,buf,count);
1016 else
1017 i = -EIO;
1018 tty_ldisc_deref(ld);
1019 unlock_kernel();
1020 if (i > 0)
1021 inode->i_atime = current_fs_time(inode->i_sb);
1022 return i;
1023}
1024
1025/*
1026 * Split writes up in sane blocksizes to avoid
1027 * denial-of-service type attacks
1028 */
1029static inline ssize_t do_tty_write(
1030 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1031 struct tty_struct *tty,
1032 struct file *file,
1033 const char __user *buf,
1034 size_t count)
1035{
1036 ssize_t ret = 0, written = 0;
1037 unsigned int chunk;
1038
1039 if (down_interruptible(&tty->atomic_write)) {
1040 return -ERESTARTSYS;
1041 }
1042
1043 /*
1044 * We chunk up writes into a temporary buffer. This
1045 * simplifies low-level drivers immensely, since they
1046 * don't have locking issues and user mode accesses.
1047 *
1048 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1049 * big chunk-size..
1050 *
1051 * The default chunk-size is 2kB, because the NTTY
1052 * layer has problems with bigger chunks. It will
1053 * claim to be able to handle more characters than
1054 * it actually does.
1055 */
1056 chunk = 2048;
1057 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1058 chunk = 65536;
1059 if (count < chunk)
1060 chunk = count;
1061
1062 /* write_buf/write_cnt is protected by the atomic_write semaphore */
1063 if (tty->write_cnt < chunk) {
1064 unsigned char *buf;
1065
1066 if (chunk < 1024)
1067 chunk = 1024;
1068
1069 buf = kmalloc(chunk, GFP_KERNEL);
1070 if (!buf) {
1071 up(&tty->atomic_write);
1072 return -ENOMEM;
1073 }
1074 kfree(tty->write_buf);
1075 tty->write_cnt = chunk;
1076 tty->write_buf = buf;
1077 }
1078
1079 /* Do the write .. */
1080 for (;;) {
1081 size_t size = count;
1082 if (size > chunk)
1083 size = chunk;
1084 ret = -EFAULT;
1085 if (copy_from_user(tty->write_buf, buf, size))
1086 break;
1087 lock_kernel();
1088 ret = write(tty, file, tty->write_buf, size);
1089 unlock_kernel();
1090 if (ret <= 0)
1091 break;
1092 written += ret;
1093 buf += ret;
1094 count -= ret;
1095 if (!count)
1096 break;
1097 ret = -ERESTARTSYS;
1098 if (signal_pending(current))
1099 break;
1100 cond_resched();
1101 }
1102 if (written) {
1103 struct inode *inode = file->f_dentry->d_inode;
1104 inode->i_mtime = current_fs_time(inode->i_sb);
1105 ret = written;
1106 }
1107 up(&tty->atomic_write);
1108 return ret;
1109}
1110
1111
1112static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1113 loff_t *ppos)
1114{
1115 struct tty_struct * tty;
1116 struct inode *inode = file->f_dentry->d_inode;
1117 ssize_t ret;
1118 struct tty_ldisc *ld;
1119
1120 tty = (struct tty_struct *)file->private_data;
1121 if (tty_paranoia_check(tty, inode, "tty_write"))
1122 return -EIO;
1123 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1124 return -EIO;
1125
1126 ld = tty_ldisc_ref_wait(tty);
1127 if (!ld->write)
1128 ret = -EIO;
1129 else
1130 ret = do_tty_write(ld->write, tty, file, buf, count);
1131 tty_ldisc_deref(ld);
1132 return ret;
1133}
1134
1135ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1136 loff_t *ppos)
1137{
1138 struct file *p = NULL;
1139
1140 spin_lock(&redirect_lock);
1141 if (redirect) {
1142 get_file(redirect);
1143 p = redirect;
1144 }
1145 spin_unlock(&redirect_lock);
1146
1147 if (p) {
1148 ssize_t res;
1149 res = vfs_write(p, buf, count, &p->f_pos);
1150 fput(p);
1151 return res;
1152 }
1153
1154 return tty_write(file, buf, count, ppos);
1155}
1156
1157static char ptychar[] = "pqrstuvwxyzabcde";
1158
1159static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1160{
1161 int i = index + driver->name_base;
1162 /* ->name is initialized to "ttyp", but "tty" is expected */
1163 sprintf(p, "%s%c%x",
1164 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1165 ptychar[i >> 4 & 0xf], i & 0xf);
1166}
1167
1168static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1169{
1170 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1171}
1172
1173/*
1174 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1175 * failed open. The new code protects the open with a semaphore, so it's
1176 * really quite straightforward. The semaphore locking can probably be
1177 * relaxed for the (most common) case of reopening a tty.
1178 */
1179static int init_dev(struct tty_driver *driver, int idx,
1180 struct tty_struct **ret_tty)
1181{
1182 struct tty_struct *tty, *o_tty;
1183 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1184 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1185 int retval=0;
1186
1187 /* check whether we're reopening an existing tty */
1188 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1189 tty = devpts_get_tty(idx);
1190 if (tty && driver->subtype == PTY_TYPE_MASTER)
1191 tty = tty->link;
1192 } else {
1193 tty = driver->ttys[idx];
1194 }
1195 if (tty) goto fast_track;
1196
1197 /*
1198 * First time open is complex, especially for PTY devices.
1199 * This code guarantees that either everything succeeds and the
1200 * TTY is ready for operation, or else the table slots are vacated
1201 * and the allocated memory released. (Except that the termios
1202 * and locked termios may be retained.)
1203 */
1204
1205 if (!try_module_get(driver->owner)) {
1206 retval = -ENODEV;
1207 goto end_init;
1208 }
1209
1210 o_tty = NULL;
1211 tp = o_tp = NULL;
1212 ltp = o_ltp = NULL;
1213
1214 tty = alloc_tty_struct();
1215 if(!tty)
1216 goto fail_no_mem;
1217 initialize_tty_struct(tty);
1218 tty->driver = driver;
1219 tty->index = idx;
1220 tty_line_name(driver, idx, tty->name);
1221
1222 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1223 tp_loc = &tty->termios;
1224 ltp_loc = &tty->termios_locked;
1225 } else {
1226 tp_loc = &driver->termios[idx];
1227 ltp_loc = &driver->termios_locked[idx];
1228 }
1229
1230 if (!*tp_loc) {
1231 tp = (struct termios *) kmalloc(sizeof(struct termios),
1232 GFP_KERNEL);
1233 if (!tp)
1234 goto free_mem_out;
1235 *tp = driver->init_termios;
1236 }
1237
1238 if (!*ltp_loc) {
1239 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1240 GFP_KERNEL);
1241 if (!ltp)
1242 goto free_mem_out;
1243 memset(ltp, 0, sizeof(struct termios));
1244 }
1245
1246 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1247 o_tty = alloc_tty_struct();
1248 if (!o_tty)
1249 goto free_mem_out;
1250 initialize_tty_struct(o_tty);
1251 o_tty->driver = driver->other;
1252 o_tty->index = idx;
1253 tty_line_name(driver->other, idx, o_tty->name);
1254
1255 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1256 o_tp_loc = &o_tty->termios;
1257 o_ltp_loc = &o_tty->termios_locked;
1258 } else {
1259 o_tp_loc = &driver->other->termios[idx];
1260 o_ltp_loc = &driver->other->termios_locked[idx];
1261 }
1262
1263 if (!*o_tp_loc) {
1264 o_tp = (struct termios *)
1265 kmalloc(sizeof(struct termios), GFP_KERNEL);
1266 if (!o_tp)
1267 goto free_mem_out;
1268 *o_tp = driver->other->init_termios;
1269 }
1270
1271 if (!*o_ltp_loc) {
1272 o_ltp = (struct termios *)
1273 kmalloc(sizeof(struct termios), GFP_KERNEL);
1274 if (!o_ltp)
1275 goto free_mem_out;
1276 memset(o_ltp, 0, sizeof(struct termios));
1277 }
1278
1279 /*
1280 * Everything allocated ... set up the o_tty structure.
1281 */
1282 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1283 driver->other->ttys[idx] = o_tty;
1284 }
1285 if (!*o_tp_loc)
1286 *o_tp_loc = o_tp;
1287 if (!*o_ltp_loc)
1288 *o_ltp_loc = o_ltp;
1289 o_tty->termios = *o_tp_loc;
1290 o_tty->termios_locked = *o_ltp_loc;
1291 driver->other->refcount++;
1292 if (driver->subtype == PTY_TYPE_MASTER)
1293 o_tty->count++;
1294
1295 /* Establish the links in both directions */
1296 tty->link = o_tty;
1297 o_tty->link = tty;
1298 }
1299
1300 /*
1301 * All structures have been allocated, so now we install them.
1302 * Failures after this point use release_mem to clean up, so
1303 * there's no need to null out the local pointers.
1304 */
1305 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1306 driver->ttys[idx] = tty;
1307 }
1308
1309 if (!*tp_loc)
1310 *tp_loc = tp;
1311 if (!*ltp_loc)
1312 *ltp_loc = ltp;
1313 tty->termios = *tp_loc;
1314 tty->termios_locked = *ltp_loc;
1315 driver->refcount++;
1316 tty->count++;
1317
1318 /*
1319 * Structures all installed ... call the ldisc open routines.
1320 * If we fail here just call release_mem to clean up. No need
1321 * to decrement the use counts, as release_mem doesn't care.
1322 */
1323
1324 if (tty->ldisc.open) {
1325 retval = (tty->ldisc.open)(tty);
1326 if (retval)
1327 goto release_mem_out;
1328 }
1329 if (o_tty && o_tty->ldisc.open) {
1330 retval = (o_tty->ldisc.open)(o_tty);
1331 if (retval) {
1332 if (tty->ldisc.close)
1333 (tty->ldisc.close)(tty);
1334 goto release_mem_out;
1335 }
1336 tty_ldisc_enable(o_tty);
1337 }
1338 tty_ldisc_enable(tty);
1339 goto success;
1340
1341 /*
1342 * This fast open can be used if the tty is already open.
1343 * No memory is allocated, and the only failures are from
1344 * attempting to open a closing tty or attempting multiple
1345 * opens on a pty master.
1346 */
1347fast_track:
1348 if (test_bit(TTY_CLOSING, &tty->flags)) {
1349 retval = -EIO;
1350 goto end_init;
1351 }
1352 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1353 driver->subtype == PTY_TYPE_MASTER) {
1354 /*
1355 * special case for PTY masters: only one open permitted,
1356 * and the slave side open count is incremented as well.
1357 */
1358 if (tty->count) {
1359 retval = -EIO;
1360 goto end_init;
1361 }
1362 tty->link->count++;
1363 }
1364 tty->count++;
1365 tty->driver = driver; /* N.B. why do this every time?? */
1366
1367 /* FIXME */
1368 if(!test_bit(TTY_LDISC, &tty->flags))
1369 printk(KERN_ERR "init_dev but no ldisc\n");
1370success:
1371 *ret_tty = tty;
1372
1373 /* All paths come through here to release the semaphore */
1374end_init:
1375 return retval;
1376
1377 /* Release locally allocated memory ... nothing placed in slots */
1378free_mem_out:
1379 if (o_tp)
1380 kfree(o_tp);
1381 if (o_tty)
1382 free_tty_struct(o_tty);
1383 if (ltp)
1384 kfree(ltp);
1385 if (tp)
1386 kfree(tp);
1387 free_tty_struct(tty);
1388
1389fail_no_mem:
1390 module_put(driver->owner);
1391 retval = -ENOMEM;
1392 goto end_init;
1393
1394 /* call the tty release_mem routine to clean out this slot */
1395release_mem_out:
1396 printk(KERN_INFO "init_dev: ldisc open failed, "
1397 "clearing slot %d\n", idx);
1398 release_mem(tty, idx);
1399 goto end_init;
1400}
1401
1402/*
1403 * Releases memory associated with a tty structure, and clears out the
1404 * driver table slots.
1405 */
1406static void release_mem(struct tty_struct *tty, int idx)
1407{
1408 struct tty_struct *o_tty;
1409 struct termios *tp;
1410 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1411
1412 if ((o_tty = tty->link) != NULL) {
1413 if (!devpts)
1414 o_tty->driver->ttys[idx] = NULL;
1415 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1416 tp = o_tty->termios;
1417 if (!devpts)
1418 o_tty->driver->termios[idx] = NULL;
1419 kfree(tp);
1420
1421 tp = o_tty->termios_locked;
1422 if (!devpts)
1423 o_tty->driver->termios_locked[idx] = NULL;
1424 kfree(tp);
1425 }
1426 o_tty->magic = 0;
1427 o_tty->driver->refcount--;
1428 file_list_lock();
1429 list_del_init(&o_tty->tty_files);
1430 file_list_unlock();
1431 free_tty_struct(o_tty);
1432 }
1433
1434 if (!devpts)
1435 tty->driver->ttys[idx] = NULL;
1436 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1437 tp = tty->termios;
1438 if (!devpts)
1439 tty->driver->termios[idx] = NULL;
1440 kfree(tp);
1441
1442 tp = tty->termios_locked;
1443 if (!devpts)
1444 tty->driver->termios_locked[idx] = NULL;
1445 kfree(tp);
1446 }
1447
1448 tty->magic = 0;
1449 tty->driver->refcount--;
1450 file_list_lock();
1451 list_del_init(&tty->tty_files);
1452 file_list_unlock();
1453 module_put(tty->driver->owner);
1454 free_tty_struct(tty);
1455}
1456
1457/*
1458 * Even releasing the tty structures is a tricky business.. We have
1459 * to be very careful that the structures are all released at the
1460 * same time, as interrupts might otherwise get the wrong pointers.
1461 *
1462 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1463 * lead to double frees or releasing memory still in use.
1464 */
1465static void release_dev(struct file * filp)
1466{
1467 struct tty_struct *tty, *o_tty;
1468 int pty_master, tty_closing, o_tty_closing, do_sleep;
1469 int devpts_master, devpts;
1470 int idx;
1471 char buf[64];
1472 unsigned long flags;
1473
1474 tty = (struct tty_struct *)filp->private_data;
1475 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1476 return;
1477
1478 check_tty_count(tty, "release_dev");
1479
1480 tty_fasync(-1, filp, 0);
1481
1482 idx = tty->index;
1483 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1484 tty->driver->subtype == PTY_TYPE_MASTER);
1485 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1486 devpts_master = pty_master && devpts;
1487 o_tty = tty->link;
1488
1489#ifdef TTY_PARANOIA_CHECK
1490 if (idx < 0 || idx >= tty->driver->num) {
1491 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1492 "free (%s)\n", tty->name);
1493 return;
1494 }
1495 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1496 if (tty != tty->driver->ttys[idx]) {
1497 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1498 "for (%s)\n", idx, tty->name);
1499 return;
1500 }
1501 if (tty->termios != tty->driver->termios[idx]) {
1502 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1503 "for (%s)\n",
1504 idx, tty->name);
1505 return;
1506 }
1507 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1508 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1509 "termios_locked for (%s)\n",
1510 idx, tty->name);
1511 return;
1512 }
1513 }
1514#endif
1515
1516#ifdef TTY_DEBUG_HANGUP
1517 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1518 tty_name(tty, buf), tty->count);
1519#endif
1520
1521#ifdef TTY_PARANOIA_CHECK
1522 if (tty->driver->other &&
1523 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1524 if (o_tty != tty->driver->other->ttys[idx]) {
1525 printk(KERN_DEBUG "release_dev: other->table[%d] "
1526 "not o_tty for (%s)\n",
1527 idx, tty->name);
1528 return;
1529 }
1530 if (o_tty->termios != tty->driver->other->termios[idx]) {
1531 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1532 "not o_termios for (%s)\n",
1533 idx, tty->name);
1534 return;
1535 }
1536 if (o_tty->termios_locked !=
1537 tty->driver->other->termios_locked[idx]) {
1538 printk(KERN_DEBUG "release_dev: other->termios_locked["
1539 "%d] not o_termios_locked for (%s)\n",
1540 idx, tty->name);
1541 return;
1542 }
1543 if (o_tty->link != tty) {
1544 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1545 return;
1546 }
1547 }
1548#endif
1549 if (tty->driver->close)
1550 tty->driver->close(tty, filp);
1551
1552 /*
1553 * Sanity check: if tty->count is going to zero, there shouldn't be
1554 * any waiters on tty->read_wait or tty->write_wait. We test the
1555 * wait queues and kick everyone out _before_ actually starting to
1556 * close. This ensures that we won't block while releasing the tty
1557 * structure.
1558 *
1559 * The test for the o_tty closing is necessary, since the master and
1560 * slave sides may close in any order. If the slave side closes out
1561 * first, its count will be one, since the master side holds an open.
1562 * Thus this test wouldn't be triggered at the time the slave closes,
1563 * so we do it now.
1564 *
1565 * Note that it's possible for the tty to be opened again while we're
1566 * flushing out waiters. By recalculating the closing flags before
1567 * each iteration we avoid any problems.
1568 */
1569 while (1) {
1570 /* Guard against races with tty->count changes elsewhere and
1571 opens on /dev/tty */
1572
1573 down(&tty_sem);
1574 tty_closing = tty->count <= 1;
1575 o_tty_closing = o_tty &&
1576 (o_tty->count <= (pty_master ? 1 : 0));
1577 up(&tty_sem);
1578 do_sleep = 0;
1579
1580 if (tty_closing) {
1581 if (waitqueue_active(&tty->read_wait)) {
1582 wake_up(&tty->read_wait);
1583 do_sleep++;
1584 }
1585 if (waitqueue_active(&tty->write_wait)) {
1586 wake_up(&tty->write_wait);
1587 do_sleep++;
1588 }
1589 }
1590 if (o_tty_closing) {
1591 if (waitqueue_active(&o_tty->read_wait)) {
1592 wake_up(&o_tty->read_wait);
1593 do_sleep++;
1594 }
1595 if (waitqueue_active(&o_tty->write_wait)) {
1596 wake_up(&o_tty->write_wait);
1597 do_sleep++;
1598 }
1599 }
1600 if (!do_sleep)
1601 break;
1602
1603 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1604 "active!\n", tty_name(tty, buf));
1605 schedule();
1606 }
1607
1608 /*
1609 * The closing flags are now consistent with the open counts on
1610 * both sides, and we've completed the last operation that could
1611 * block, so it's safe to proceed with closing.
1612 */
1613
1614 down(&tty_sem);
1615 if (pty_master) {
1616 if (--o_tty->count < 0) {
1617 printk(KERN_WARNING "release_dev: bad pty slave count "
1618 "(%d) for %s\n",
1619 o_tty->count, tty_name(o_tty, buf));
1620 o_tty->count = 0;
1621 }
1622 }
1623 if (--tty->count < 0) {
1624 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1625 tty->count, tty_name(tty, buf));
1626 tty->count = 0;
1627 }
1628 up(&tty_sem);
1629
1630 /*
1631 * We've decremented tty->count, so we need to remove this file
1632 * descriptor off the tty->tty_files list; this serves two
1633 * purposes:
1634 * - check_tty_count sees the correct number of file descriptors
1635 * associated with this tty.
1636 * - do_tty_hangup no longer sees this file descriptor as
1637 * something that needs to be handled for hangups.
1638 */
1639 file_kill(filp);
1640 filp->private_data = NULL;
1641
1642 /*
1643 * Perform some housekeeping before deciding whether to return.
1644 *
1645 * Set the TTY_CLOSING flag if this was the last open. In the
1646 * case of a pty we may have to wait around for the other side
1647 * to close, and TTY_CLOSING makes sure we can't be reopened.
1648 */
1649 if(tty_closing)
1650 set_bit(TTY_CLOSING, &tty->flags);
1651 if(o_tty_closing)
1652 set_bit(TTY_CLOSING, &o_tty->flags);
1653
1654 /*
1655 * If _either_ side is closing, make sure there aren't any
1656 * processes that still think tty or o_tty is their controlling
1657 * tty.
1658 */
1659 if (tty_closing || o_tty_closing) {
1660 struct task_struct *p;
1661
1662 read_lock(&tasklist_lock);
1663 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1664 p->signal->tty = NULL;
1665 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1666 if (o_tty)
1667 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1668 p->signal->tty = NULL;
1669 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1670 read_unlock(&tasklist_lock);
1671 }
1672
1673 /* check whether both sides are closing ... */
1674 if (!tty_closing || (o_tty && !o_tty_closing))
1675 return;
1676
1677#ifdef TTY_DEBUG_HANGUP
1678 printk(KERN_DEBUG "freeing tty structure...");
1679#endif
1680 /*
1681 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1682 * kill any delayed work. As this is the final close it does not
1683 * race with the set_ldisc code path.
1684 */
1685 clear_bit(TTY_LDISC, &tty->flags);
1686 clear_bit(TTY_DONT_FLIP, &tty->flags);
1687 cancel_delayed_work(&tty->flip.work);
1688
1689 /*
1690 * Wait for ->hangup_work and ->flip.work handlers to terminate
1691 */
1692
1693 flush_scheduled_work();
1694
1695 /*
1696 * Wait for any short term users (we know they are just driver
1697 * side waiters as the file is closing so user count on the file
1698 * side is zero.
1699 */
1700 spin_lock_irqsave(&tty_ldisc_lock, flags);
1701 while(tty->ldisc.refcount)
1702 {
1703 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1704 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1705 spin_lock_irqsave(&tty_ldisc_lock, flags);
1706 }
1707 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1708 /*
1709 * Shutdown the current line discipline, and reset it to N_TTY.
1710 * N.B. why reset ldisc when we're releasing the memory??
1711 *
1712 * FIXME: this MUST get fixed for the new reflocking
1713 */
1714 if (tty->ldisc.close)
1715 (tty->ldisc.close)(tty);
1716 tty_ldisc_put(tty->ldisc.num);
1717
1718 /*
1719 * Switch the line discipline back
1720 */
1721 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1722 tty_set_termios_ldisc(tty,N_TTY);
1723 if (o_tty) {
1724 /* FIXME: could o_tty be in setldisc here ? */
1725 clear_bit(TTY_LDISC, &o_tty->flags);
1726 if (o_tty->ldisc.close)
1727 (o_tty->ldisc.close)(o_tty);
1728 tty_ldisc_put(o_tty->ldisc.num);
1729 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1730 tty_set_termios_ldisc(o_tty,N_TTY);
1731 }
1732 /*
1733 * The release_mem function takes care of the details of clearing
1734 * the slots and preserving the termios structure.
1735 */
1736 release_mem(tty, idx);
1737
1738#ifdef CONFIG_UNIX98_PTYS
1739 /* Make this pty number available for reallocation */
1740 if (devpts) {
1741 down(&allocated_ptys_lock);
1742 idr_remove(&allocated_ptys, idx);
1743 up(&allocated_ptys_lock);
1744 }
1745#endif
1746
1747}
1748
1749/*
1750 * tty_open and tty_release keep up the tty count that contains the
1751 * number of opens done on a tty. We cannot use the inode-count, as
1752 * different inodes might point to the same tty.
1753 *
1754 * Open-counting is needed for pty masters, as well as for keeping
1755 * track of serial lines: DTR is dropped when the last close happens.
1756 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1757 *
1758 * The termios state of a pty is reset on first open so that
1759 * settings don't persist across reuse.
1760 */
1761static int tty_open(struct inode * inode, struct file * filp)
1762{
1763 struct tty_struct *tty;
1764 int noctty, retval;
1765 struct tty_driver *driver;
1766 int index;
1767 dev_t device = inode->i_rdev;
1768 unsigned short saved_flags = filp->f_flags;
1769
1770 nonseekable_open(inode, filp);
1771
1772retry_open:
1773 noctty = filp->f_flags & O_NOCTTY;
1774 index = -1;
1775 retval = 0;
1776
1777 down(&tty_sem);
1778
1779 if (device == MKDEV(TTYAUX_MAJOR,0)) {
1780 if (!current->signal->tty) {
1781 up(&tty_sem);
1782 return -ENXIO;
1783 }
1784 driver = current->signal->tty->driver;
1785 index = current->signal->tty->index;
1786 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1787 /* noctty = 1; */
1788 goto got_driver;
1789 }
1790#ifdef CONFIG_VT
1791 if (device == MKDEV(TTY_MAJOR,0)) {
1792 extern struct tty_driver *console_driver;
1793 driver = console_driver;
1794 index = fg_console;
1795 noctty = 1;
1796 goto got_driver;
1797 }
1798#endif
1799 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1800 driver = console_device(&index);
1801 if (driver) {
1802 /* Don't let /dev/console block */
1803 filp->f_flags |= O_NONBLOCK;
1804 noctty = 1;
1805 goto got_driver;
1806 }
1807 up(&tty_sem);
1808 return -ENODEV;
1809 }
1810
1811 driver = get_tty_driver(device, &index);
1812 if (!driver) {
1813 up(&tty_sem);
1814 return -ENODEV;
1815 }
1816got_driver:
1817 retval = init_dev(driver, index, &tty);
1818 up(&tty_sem);
1819 if (retval)
1820 return retval;
1821
1822 filp->private_data = tty;
1823 file_move(filp, &tty->tty_files);
1824 check_tty_count(tty, "tty_open");
1825 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1826 tty->driver->subtype == PTY_TYPE_MASTER)
1827 noctty = 1;
1828#ifdef TTY_DEBUG_HANGUP
1829 printk(KERN_DEBUG "opening %s...", tty->name);
1830#endif
1831 if (!retval) {
1832 if (tty->driver->open)
1833 retval = tty->driver->open(tty, filp);
1834 else
1835 retval = -ENODEV;
1836 }
1837 filp->f_flags = saved_flags;
1838
1839 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1840 retval = -EBUSY;
1841
1842 if (retval) {
1843#ifdef TTY_DEBUG_HANGUP
1844 printk(KERN_DEBUG "error %d in opening %s...", retval,
1845 tty->name);
1846#endif
1847 release_dev(filp);
1848 if (retval != -ERESTARTSYS)
1849 return retval;
1850 if (signal_pending(current))
1851 return retval;
1852 schedule();
1853 /*
1854 * Need to reset f_op in case a hangup happened.
1855 */
1856 if (filp->f_op == &hung_up_tty_fops)
1857 filp->f_op = &tty_fops;
1858 goto retry_open;
1859 }
1860 if (!noctty &&
1861 current->signal->leader &&
1862 !current->signal->tty &&
1863 tty->session == 0) {
1864 task_lock(current);
1865 current->signal->tty = tty;
1866 task_unlock(current);
1867 current->signal->tty_old_pgrp = 0;
1868 tty->session = current->signal->session;
1869 tty->pgrp = process_group(current);
1870 }
1871 return 0;
1872}
1873
1874#ifdef CONFIG_UNIX98_PTYS
1875static int ptmx_open(struct inode * inode, struct file * filp)
1876{
1877 struct tty_struct *tty;
1878 int retval;
1879 int index;
1880 int idr_ret;
1881
1882 nonseekable_open(inode, filp);
1883
1884 /* find a device that is not in use. */
1885 down(&allocated_ptys_lock);
1886 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1887 up(&allocated_ptys_lock);
1888 return -ENOMEM;
1889 }
1890 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1891 if (idr_ret < 0) {
1892 up(&allocated_ptys_lock);
1893 if (idr_ret == -EAGAIN)
1894 return -ENOMEM;
1895 return -EIO;
1896 }
1897 if (index >= pty_limit) {
1898 idr_remove(&allocated_ptys, index);
1899 up(&allocated_ptys_lock);
1900 return -EIO;
1901 }
1902 up(&allocated_ptys_lock);
1903
1904 down(&tty_sem);
1905 retval = init_dev(ptm_driver, index, &tty);
1906 up(&tty_sem);
1907
1908 if (retval)
1909 goto out;
1910
1911 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1912 filp->private_data = tty;
1913 file_move(filp, &tty->tty_files);
1914
1915 retval = -ENOMEM;
1916 if (devpts_pty_new(tty->link))
1917 goto out1;
1918
1919 check_tty_count(tty, "tty_open");
1920 retval = ptm_driver->open(tty, filp);
1921 if (!retval)
1922 return 0;
1923out1:
1924 release_dev(filp);
1925out:
1926 down(&allocated_ptys_lock);
1927 idr_remove(&allocated_ptys, index);
1928 up(&allocated_ptys_lock);
1929 return retval;
1930}
1931#endif
1932
1933static int tty_release(struct inode * inode, struct file * filp)
1934{
1935 lock_kernel();
1936 release_dev(filp);
1937 unlock_kernel();
1938 return 0;
1939}
1940
1941/* No kernel lock held - fine */
1942static unsigned int tty_poll(struct file * filp, poll_table * wait)
1943{
1944 struct tty_struct * tty;
1945 struct tty_ldisc *ld;
1946 int ret = 0;
1947
1948 tty = (struct tty_struct *)filp->private_data;
1949 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1950 return 0;
1951
1952 ld = tty_ldisc_ref_wait(tty);
1953 if (ld->poll)
1954 ret = (ld->poll)(tty, filp, wait);
1955 tty_ldisc_deref(ld);
1956 return ret;
1957}
1958
1959static int tty_fasync(int fd, struct file * filp, int on)
1960{
1961 struct tty_struct * tty;
1962 int retval;
1963
1964 tty = (struct tty_struct *)filp->private_data;
1965 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1966 return 0;
1967
1968 retval = fasync_helper(fd, filp, on, &tty->fasync);
1969 if (retval <= 0)
1970 return retval;
1971
1972 if (on) {
1973 if (!waitqueue_active(&tty->read_wait))
1974 tty->minimum_to_wake = 1;
1975 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1976 if (retval)
1977 return retval;
1978 } else {
1979 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1980 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1981 }
1982 return 0;
1983}
1984
1985static int tiocsti(struct tty_struct *tty, char __user *p)
1986{
1987 char ch, mbz = 0;
1988 struct tty_ldisc *ld;
1989
1990 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1991 return -EPERM;
1992 if (get_user(ch, p))
1993 return -EFAULT;
1994 ld = tty_ldisc_ref_wait(tty);
1995 ld->receive_buf(tty, &ch, &mbz, 1);
1996 tty_ldisc_deref(ld);
1997 return 0;
1998}
1999
2000static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2001{
2002 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2003 return -EFAULT;
2004 return 0;
2005}
2006
2007static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2008 struct winsize __user * arg)
2009{
2010 struct winsize tmp_ws;
2011
2012 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2013 return -EFAULT;
2014 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2015 return 0;
2016#ifdef CONFIG_VT
2017 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2018 int rc;
2019
2020 acquire_console_sem();
2021 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2022 release_console_sem();
2023 if (rc)
2024 return -ENXIO;
2025 }
2026#endif
2027 if (tty->pgrp > 0)
2028 kill_pg(tty->pgrp, SIGWINCH, 1);
2029 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2030 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2031 tty->winsize = tmp_ws;
2032 real_tty->winsize = tmp_ws;
2033 return 0;
2034}
2035
2036static int tioccons(struct file *file)
2037{
2038 if (!capable(CAP_SYS_ADMIN))
2039 return -EPERM;
2040 if (file->f_op->write == redirected_tty_write) {
2041 struct file *f;
2042 spin_lock(&redirect_lock);
2043 f = redirect;
2044 redirect = NULL;
2045 spin_unlock(&redirect_lock);
2046 if (f)
2047 fput(f);
2048 return 0;
2049 }
2050 spin_lock(&redirect_lock);
2051 if (redirect) {
2052 spin_unlock(&redirect_lock);
2053 return -EBUSY;
2054 }
2055 get_file(file);
2056 redirect = file;
2057 spin_unlock(&redirect_lock);
2058 return 0;
2059}
2060
2061
2062static int fionbio(struct file *file, int __user *p)
2063{
2064 int nonblock;
2065
2066 if (get_user(nonblock, p))
2067 return -EFAULT;
2068
2069 if (nonblock)
2070 file->f_flags |= O_NONBLOCK;
2071 else
2072 file->f_flags &= ~O_NONBLOCK;
2073 return 0;
2074}
2075
2076static int tiocsctty(struct tty_struct *tty, int arg)
2077{
2078 task_t *p;
2079
2080 if (current->signal->leader &&
2081 (current->signal->session == tty->session))
2082 return 0;
2083 /*
2084 * The process must be a session leader and
2085 * not have a controlling tty already.
2086 */
2087 if (!current->signal->leader || current->signal->tty)
2088 return -EPERM;
2089 if (tty->session > 0) {
2090 /*
2091 * This tty is already the controlling
2092 * tty for another session group!
2093 */
2094 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2095 /*
2096 * Steal it away
2097 */
2098
2099 read_lock(&tasklist_lock);
2100 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2101 p->signal->tty = NULL;
2102 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2103 read_unlock(&tasklist_lock);
2104 } else
2105 return -EPERM;
2106 }
2107 task_lock(current);
2108 current->signal->tty = tty;
2109 task_unlock(current);
2110 current->signal->tty_old_pgrp = 0;
2111 tty->session = current->signal->session;
2112 tty->pgrp = process_group(current);
2113 return 0;
2114}
2115
2116static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2117{
2118 /*
2119 * (tty == real_tty) is a cheap way of
2120 * testing if the tty is NOT a master pty.
2121 */
2122 if (tty == real_tty && current->signal->tty != real_tty)
2123 return -ENOTTY;
2124 return put_user(real_tty->pgrp, p);
2125}
2126
2127static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2128{
2129 pid_t pgrp;
2130 int retval = tty_check_change(real_tty);
2131
2132 if (retval == -EIO)
2133 return -ENOTTY;
2134 if (retval)
2135 return retval;
2136 if (!current->signal->tty ||
2137 (current->signal->tty != real_tty) ||
2138 (real_tty->session != current->signal->session))
2139 return -ENOTTY;
2140 if (get_user(pgrp, p))
2141 return -EFAULT;
2142 if (pgrp < 0)
2143 return -EINVAL;
2144 if (session_of_pgrp(pgrp) != current->signal->session)
2145 return -EPERM;
2146 real_tty->pgrp = pgrp;
2147 return 0;
2148}
2149
2150static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2151{
2152 /*
2153 * (tty == real_tty) is a cheap way of
2154 * testing if the tty is NOT a master pty.
2155 */
2156 if (tty == real_tty && current->signal->tty != real_tty)
2157 return -ENOTTY;
2158 if (real_tty->session <= 0)
2159 return -ENOTTY;
2160 return put_user(real_tty->session, p);
2161}
2162
2163static int tiocsetd(struct tty_struct *tty, int __user *p)
2164{
2165 int ldisc;
2166
2167 if (get_user(ldisc, p))
2168 return -EFAULT;
2169 return tty_set_ldisc(tty, ldisc);
2170}
2171
2172static int send_break(struct tty_struct *tty, int duration)
2173{
2174 tty->driver->break_ctl(tty, -1);
2175 if (!signal_pending(current)) {
2176 set_current_state(TASK_INTERRUPTIBLE);
2177 schedule_timeout(duration);
2178 }
2179 tty->driver->break_ctl(tty, 0);
2180 if (signal_pending(current))
2181 return -EINTR;
2182 return 0;
2183}
2184
2185static int
2186tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2187{
2188 int retval = -EINVAL;
2189
2190 if (tty->driver->tiocmget) {
2191 retval = tty->driver->tiocmget(tty, file);
2192
2193 if (retval >= 0)
2194 retval = put_user(retval, p);
2195 }
2196 return retval;
2197}
2198
2199static int
2200tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2201 unsigned __user *p)
2202{
2203 int retval = -EINVAL;
2204
2205 if (tty->driver->tiocmset) {
2206 unsigned int set, clear, val;
2207
2208 retval = get_user(val, p);
2209 if (retval)
2210 return retval;
2211
2212 set = clear = 0;
2213 switch (cmd) {
2214 case TIOCMBIS:
2215 set = val;
2216 break;
2217 case TIOCMBIC:
2218 clear = val;
2219 break;
2220 case TIOCMSET:
2221 set = val;
2222 clear = ~val;
2223 break;
2224 }
2225
2226 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2227 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2228
2229 retval = tty->driver->tiocmset(tty, file, set, clear);
2230 }
2231 return retval;
2232}
2233
2234/*
2235 * Split this up, as gcc can choke on it otherwise..
2236 */
2237int tty_ioctl(struct inode * inode, struct file * file,
2238 unsigned int cmd, unsigned long arg)
2239{
2240 struct tty_struct *tty, *real_tty;
2241 void __user *p = (void __user *)arg;
2242 int retval;
2243 struct tty_ldisc *ld;
2244
2245 tty = (struct tty_struct *)file->private_data;
2246 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2247 return -EINVAL;
2248
2249 real_tty = tty;
2250 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2251 tty->driver->subtype == PTY_TYPE_MASTER)
2252 real_tty = tty->link;
2253
2254 /*
2255 * Break handling by driver
2256 */
2257 if (!tty->driver->break_ctl) {
2258 switch(cmd) {
2259 case TIOCSBRK:
2260 case TIOCCBRK:
2261 if (tty->driver->ioctl)
2262 return tty->driver->ioctl(tty, file, cmd, arg);
2263 return -EINVAL;
2264
2265 /* These two ioctl's always return success; even if */
2266 /* the driver doesn't support them. */
2267 case TCSBRK:
2268 case TCSBRKP:
2269 if (!tty->driver->ioctl)
2270 return 0;
2271 retval = tty->driver->ioctl(tty, file, cmd, arg);
2272 if (retval == -ENOIOCTLCMD)
2273 retval = 0;
2274 return retval;
2275 }
2276 }
2277
2278 /*
2279 * Factor out some common prep work
2280 */
2281 switch (cmd) {
2282 case TIOCSETD:
2283 case TIOCSBRK:
2284 case TIOCCBRK:
2285 case TCSBRK:
2286 case TCSBRKP:
2287 retval = tty_check_change(tty);
2288 if (retval)
2289 return retval;
2290 if (cmd != TIOCCBRK) {
2291 tty_wait_until_sent(tty, 0);
2292 if (signal_pending(current))
2293 return -EINTR;
2294 }
2295 break;
2296 }
2297
2298 switch (cmd) {
2299 case TIOCSTI:
2300 return tiocsti(tty, p);
2301 case TIOCGWINSZ:
2302 return tiocgwinsz(tty, p);
2303 case TIOCSWINSZ:
2304 return tiocswinsz(tty, real_tty, p);
2305 case TIOCCONS:
2306 return real_tty!=tty ? -EINVAL : tioccons(file);
2307 case FIONBIO:
2308 return fionbio(file, p);
2309 case TIOCEXCL:
2310 set_bit(TTY_EXCLUSIVE, &tty->flags);
2311 return 0;
2312 case TIOCNXCL:
2313 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2314 return 0;
2315 case TIOCNOTTY:
2316 if (current->signal->tty != tty)
2317 return -ENOTTY;
2318 if (current->signal->leader)
2319 disassociate_ctty(0);
2320 task_lock(current);
2321 current->signal->tty = NULL;
2322 task_unlock(current);
2323 return 0;
2324 case TIOCSCTTY:
2325 return tiocsctty(tty, arg);
2326 case TIOCGPGRP:
2327 return tiocgpgrp(tty, real_tty, p);
2328 case TIOCSPGRP:
2329 return tiocspgrp(tty, real_tty, p);
2330 case TIOCGSID:
2331 return tiocgsid(tty, real_tty, p);
2332 case TIOCGETD:
2333 /* FIXME: check this is ok */
2334 return put_user(tty->ldisc.num, (int __user *)p);
2335 case TIOCSETD:
2336 return tiocsetd(tty, p);
2337#ifdef CONFIG_VT
2338 case TIOCLINUX:
2339 return tioclinux(tty, arg);
2340#endif
2341 /*
2342 * Break handling
2343 */
2344 case TIOCSBRK: /* Turn break on, unconditionally */
2345 tty->driver->break_ctl(tty, -1);
2346 return 0;
2347
2348 case TIOCCBRK: /* Turn break off, unconditionally */
2349 tty->driver->break_ctl(tty, 0);
2350 return 0;
2351 case TCSBRK: /* SVID version: non-zero arg --> no break */
2352 /*
2353 * XXX is the above comment correct, or the
2354 * code below correct? Is this ioctl used at
2355 * all by anyone?
2356 */
2357 if (!arg)
2358 return send_break(tty, HZ/4);
2359 return 0;
2360 case TCSBRKP: /* support for POSIX tcsendbreak() */
2361 return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
2362
2363 case TIOCMGET:
2364 return tty_tiocmget(tty, file, p);
2365
2366 case TIOCMSET:
2367 case TIOCMBIC:
2368 case TIOCMBIS:
2369 return tty_tiocmset(tty, file, cmd, p);
2370 }
2371 if (tty->driver->ioctl) {
2372 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2373 if (retval != -ENOIOCTLCMD)
2374 return retval;
2375 }
2376 ld = tty_ldisc_ref_wait(tty);
2377 retval = -EINVAL;
2378 if (ld->ioctl) {
2379 retval = ld->ioctl(tty, file, cmd, arg);
2380 if (retval == -ENOIOCTLCMD)
2381 retval = -EINVAL;
2382 }
2383 tty_ldisc_deref(ld);
2384 return retval;
2385}
2386
2387
2388/*
2389 * This implements the "Secure Attention Key" --- the idea is to
2390 * prevent trojan horses by killing all processes associated with this
2391 * tty when the user hits the "Secure Attention Key". Required for
2392 * super-paranoid applications --- see the Orange Book for more details.
2393 *
2394 * This code could be nicer; ideally it should send a HUP, wait a few
2395 * seconds, then send a INT, and then a KILL signal. But you then
2396 * have to coordinate with the init process, since all processes associated
2397 * with the current tty must be dead before the new getty is allowed
2398 * to spawn.
2399 *
2400 * Now, if it would be correct ;-/ The current code has a nasty hole -
2401 * it doesn't catch files in flight. We may send the descriptor to ourselves
2402 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2403 *
2404 * Nasty bug: do_SAK is being called in interrupt context. This can
2405 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2406 */
2407static void __do_SAK(void *arg)
2408{
2409#ifdef TTY_SOFT_SAK
2410 tty_hangup(tty);
2411#else
2412 struct tty_struct *tty = arg;
2413 struct task_struct *p;
2414 int session;
2415 int i;
2416 struct file *filp;
2417 struct tty_ldisc *disc;
2418
2419 if (!tty)
2420 return;
2421 session = tty->session;
2422
2423 /* We don't want an ldisc switch during this */
2424 disc = tty_ldisc_ref(tty);
2425 if (disc && disc->flush_buffer)
2426 disc->flush_buffer(tty);
2427 tty_ldisc_deref(disc);
2428
2429 if (tty->driver->flush_buffer)
2430 tty->driver->flush_buffer(tty);
2431
2432 read_lock(&tasklist_lock);
2433 do_each_task_pid(session, PIDTYPE_SID, p) {
2434 if (p->signal->tty == tty || session > 0) {
2435 printk(KERN_NOTICE "SAK: killed process %d"
2436 " (%s): p->signal->session==tty->session\n",
2437 p->pid, p->comm);
2438 send_sig(SIGKILL, p, 1);
2439 continue;
2440 }
2441 task_lock(p);
2442 if (p->files) {
2443 spin_lock(&p->files->file_lock);
2444 for (i=0; i < p->files->max_fds; i++) {
2445 filp = fcheck_files(p->files, i);
2446 if (!filp)
2447 continue;
2448 if (filp->f_op->read == tty_read &&
2449 filp->private_data == tty) {
2450 printk(KERN_NOTICE "SAK: killed process %d"
2451 " (%s): fd#%d opened to the tty\n",
2452 p->pid, p->comm, i);
2453 send_sig(SIGKILL, p, 1);
2454 break;
2455 }
2456 }
2457 spin_unlock(&p->files->file_lock);
2458 }
2459 task_unlock(p);
2460 } while_each_task_pid(session, PIDTYPE_SID, p);
2461 read_unlock(&tasklist_lock);
2462#endif
2463}
2464
2465/*
2466 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2467 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2468 * the values which we write to it will be identical to the values which it
2469 * already has. --akpm
2470 */
2471void do_SAK(struct tty_struct *tty)
2472{
2473 if (!tty)
2474 return;
2475 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2476 schedule_work(&tty->SAK_work);
2477}
2478
2479EXPORT_SYMBOL(do_SAK);
2480
2481/*
2482 * This routine is called out of the software interrupt to flush data
2483 * from the flip buffer to the line discipline.
2484 */
2485
2486static void flush_to_ldisc(void *private_)
2487{
2488 struct tty_struct *tty = (struct tty_struct *) private_;
2489 unsigned char *cp;
2490 char *fp;
2491 int count;
2492 unsigned long flags;
2493 struct tty_ldisc *disc;
2494
2495 disc = tty_ldisc_ref(tty);
2496 if (disc == NULL) /* !TTY_LDISC */
2497 return;
2498
2499 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2500 /*
2501 * Do it after the next timer tick:
2502 */
2503 schedule_delayed_work(&tty->flip.work, 1);
2504 goto out;
2505 }
2506 spin_lock_irqsave(&tty->read_lock, flags);
2507 if (tty->flip.buf_num) {
2508 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2509 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2510 tty->flip.buf_num = 0;
2511 tty->flip.char_buf_ptr = tty->flip.char_buf;
2512 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2513 } else {
2514 cp = tty->flip.char_buf;
2515 fp = tty->flip.flag_buf;
2516 tty->flip.buf_num = 1;
2517 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2518 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2519 }
2520 count = tty->flip.count;
2521 tty->flip.count = 0;
2522 spin_unlock_irqrestore(&tty->read_lock, flags);
2523
2524 disc->receive_buf(tty, cp, fp, count);
2525out:
2526 tty_ldisc_deref(disc);
2527}
2528
2529/*
2530 * Routine which returns the baud rate of the tty
2531 *
2532 * Note that the baud_table needs to be kept in sync with the
2533 * include/asm/termbits.h file.
2534 */
2535static int baud_table[] = {
2536 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2537 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2538#ifdef __sparc__
2539 76800, 153600, 307200, 614400, 921600
2540#else
2541 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2542 2500000, 3000000, 3500000, 4000000
2543#endif
2544};
2545
2546static int n_baud_table = ARRAY_SIZE(baud_table);
2547
2548/**
2549 * tty_termios_baud_rate
2550 * @termios: termios structure
2551 *
2552 * Convert termios baud rate data into a speed. This should be called
2553 * with the termios lock held if this termios is a terminal termios
2554 * structure. May change the termios data.
2555 */
2556
2557int tty_termios_baud_rate(struct termios *termios)
2558{
2559 unsigned int cbaud;
2560
2561 cbaud = termios->c_cflag & CBAUD;
2562
2563 if (cbaud & CBAUDEX) {
2564 cbaud &= ~CBAUDEX;
2565
2566 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2567 termios->c_cflag &= ~CBAUDEX;
2568 else
2569 cbaud += 15;
2570 }
2571 return baud_table[cbaud];
2572}
2573
2574EXPORT_SYMBOL(tty_termios_baud_rate);
2575
2576/**
2577 * tty_get_baud_rate - get tty bit rates
2578 * @tty: tty to query
2579 *
2580 * Returns the baud rate as an integer for this terminal. The
2581 * termios lock must be held by the caller and the terminal bit
2582 * flags may be updated.
2583 */
2584
2585int tty_get_baud_rate(struct tty_struct *tty)
2586{
2587 int baud = tty_termios_baud_rate(tty->termios);
2588
2589 if (baud == 38400 && tty->alt_speed) {
2590 if (!tty->warned) {
2591 printk(KERN_WARNING "Use of setserial/setrocket to "
2592 "set SPD_* flags is deprecated\n");
2593 tty->warned = 1;
2594 }
2595 baud = tty->alt_speed;
2596 }
2597
2598 return baud;
2599}
2600
2601EXPORT_SYMBOL(tty_get_baud_rate);
2602
2603/**
2604 * tty_flip_buffer_push - terminal
2605 * @tty: tty to push
2606 *
2607 * Queue a push of the terminal flip buffers to the line discipline. This
2608 * function must not be called from IRQ context if tty->low_latency is set.
2609 *
2610 * In the event of the queue being busy for flipping the work will be
2611 * held off and retried later.
2612 */
2613
2614void tty_flip_buffer_push(struct tty_struct *tty)
2615{
2616 if (tty->low_latency)
2617 flush_to_ldisc((void *) tty);
2618 else
2619 schedule_delayed_work(&tty->flip.work, 1);
2620}
2621
2622EXPORT_SYMBOL(tty_flip_buffer_push);
2623
2624/*
2625 * This subroutine initializes a tty structure.
2626 */
2627static void initialize_tty_struct(struct tty_struct *tty)
2628{
2629 memset(tty, 0, sizeof(struct tty_struct));
2630 tty->magic = TTY_MAGIC;
2631 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2632 tty->pgrp = -1;
2633 tty->overrun_time = jiffies;
2634 tty->flip.char_buf_ptr = tty->flip.char_buf;
2635 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2636 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2637 init_MUTEX(&tty->flip.pty_sem);
2638 init_MUTEX(&tty->termios_sem);
2639 init_waitqueue_head(&tty->write_wait);
2640 init_waitqueue_head(&tty->read_wait);
2641 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2642 sema_init(&tty->atomic_read, 1);
2643 sema_init(&tty->atomic_write, 1);
2644 spin_lock_init(&tty->read_lock);
2645 INIT_LIST_HEAD(&tty->tty_files);
2646 INIT_WORK(&tty->SAK_work, NULL, NULL);
2647}
2648
2649/*
2650 * The default put_char routine if the driver did not define one.
2651 */
2652static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2653{
2654 tty->driver->write(tty, &ch, 1);
2655}
2656
2657static struct class_simple *tty_class;
2658
2659/**
2660 * tty_register_device - register a tty device
2661 * @driver: the tty driver that describes the tty device
2662 * @index: the index in the tty driver for this tty device
2663 * @device: a struct device that is associated with this tty device.
2664 * This field is optional, if there is no known struct device for this
2665 * tty device it can be set to NULL safely.
2666 *
2667 * This call is required to be made to register an individual tty device if
2668 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2669 * bit is not set, this function should not be called.
2670 */
2671void tty_register_device(struct tty_driver *driver, unsigned index,
2672 struct device *device)
2673{
2674 char name[64];
2675 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2676
2677 if (index >= driver->num) {
2678 printk(KERN_ERR "Attempt to register invalid tty line number "
2679 " (%d).\n", index);
2680 return;
2681 }
2682
2683 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2684 "%s%d", driver->devfs_name, index + driver->name_base);
2685
2686 if (driver->type == TTY_DRIVER_TYPE_PTY)
2687 pty_line_name(driver, index, name);
2688 else
2689 tty_line_name(driver, index, name);
2690 class_simple_device_add(tty_class, dev, device, name);
2691}
2692
2693/**
2694 * tty_unregister_device - unregister a tty device
2695 * @driver: the tty driver that describes the tty device
2696 * @index: the index in the tty driver for this tty device
2697 *
2698 * If a tty device is registered with a call to tty_register_device() then
2699 * this function must be made when the tty device is gone.
2700 */
2701void tty_unregister_device(struct tty_driver *driver, unsigned index)
2702{
2703 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2704 class_simple_device_remove(MKDEV(driver->major, driver->minor_start) + index);
2705}
2706
2707EXPORT_SYMBOL(tty_register_device);
2708EXPORT_SYMBOL(tty_unregister_device);
2709
2710struct tty_driver *alloc_tty_driver(int lines)
2711{
2712 struct tty_driver *driver;
2713
2714 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2715 if (driver) {
2716 memset(driver, 0, sizeof(struct tty_driver));
2717 driver->magic = TTY_DRIVER_MAGIC;
2718 driver->num = lines;
2719 /* later we'll move allocation of tables here */
2720 }
2721 return driver;
2722}
2723
2724void put_tty_driver(struct tty_driver *driver)
2725{
2726 kfree(driver);
2727}
2728
2729void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2730{
2731 driver->open = op->open;
2732 driver->close = op->close;
2733 driver->write = op->write;
2734 driver->put_char = op->put_char;
2735 driver->flush_chars = op->flush_chars;
2736 driver->write_room = op->write_room;
2737 driver->chars_in_buffer = op->chars_in_buffer;
2738 driver->ioctl = op->ioctl;
2739 driver->set_termios = op->set_termios;
2740 driver->throttle = op->throttle;
2741 driver->unthrottle = op->unthrottle;
2742 driver->stop = op->stop;
2743 driver->start = op->start;
2744 driver->hangup = op->hangup;
2745 driver->break_ctl = op->break_ctl;
2746 driver->flush_buffer = op->flush_buffer;
2747 driver->set_ldisc = op->set_ldisc;
2748 driver->wait_until_sent = op->wait_until_sent;
2749 driver->send_xchar = op->send_xchar;
2750 driver->read_proc = op->read_proc;
2751 driver->write_proc = op->write_proc;
2752 driver->tiocmget = op->tiocmget;
2753 driver->tiocmset = op->tiocmset;
2754}
2755
2756
2757EXPORT_SYMBOL(alloc_tty_driver);
2758EXPORT_SYMBOL(put_tty_driver);
2759EXPORT_SYMBOL(tty_set_operations);
2760
2761/*
2762 * Called by a tty driver to register itself.
2763 */
2764int tty_register_driver(struct tty_driver *driver)
2765{
2766 int error;
2767 int i;
2768 dev_t dev;
2769 void **p = NULL;
2770
2771 if (driver->flags & TTY_DRIVER_INSTALLED)
2772 return 0;
2773
2774 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2775 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2776 if (!p)
2777 return -ENOMEM;
2778 memset(p, 0, driver->num * 3 * sizeof(void *));
2779 }
2780
2781 if (!driver->major) {
2782 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2783 (char*)driver->name);
2784 if (!error) {
2785 driver->major = MAJOR(dev);
2786 driver->minor_start = MINOR(dev);
2787 }
2788 } else {
2789 dev = MKDEV(driver->major, driver->minor_start);
2790 error = register_chrdev_region(dev, driver->num,
2791 (char*)driver->name);
2792 }
2793 if (error < 0) {
2794 kfree(p);
2795 return error;
2796 }
2797
2798 if (p) {
2799 driver->ttys = (struct tty_struct **)p;
2800 driver->termios = (struct termios **)(p + driver->num);
2801 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2802 } else {
2803 driver->ttys = NULL;
2804 driver->termios = NULL;
2805 driver->termios_locked = NULL;
2806 }
2807
2808 cdev_init(&driver->cdev, &tty_fops);
2809 driver->cdev.owner = driver->owner;
2810 error = cdev_add(&driver->cdev, dev, driver->num);
2811 if (error) {
2812 cdev_del(&driver->cdev);
2813 unregister_chrdev_region(dev, driver->num);
2814 driver->ttys = NULL;
2815 driver->termios = driver->termios_locked = NULL;
2816 kfree(p);
2817 return error;
2818 }
2819
2820 if (!driver->put_char)
2821 driver->put_char = tty_default_put_char;
2822
2823 list_add(&driver->tty_drivers, &tty_drivers);
2824
2825 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2826 for(i = 0; i < driver->num; i++)
2827 tty_register_device(driver, i, NULL);
2828 }
2829 proc_tty_register_driver(driver);
2830 return 0;
2831}
2832
2833EXPORT_SYMBOL(tty_register_driver);
2834
2835/*
2836 * Called by a tty driver to unregister itself.
2837 */
2838int tty_unregister_driver(struct tty_driver *driver)
2839{
2840 int i;
2841 struct termios *tp;
2842 void *p;
2843
2844 if (driver->refcount)
2845 return -EBUSY;
2846
2847 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2848 driver->num);
2849
2850 list_del(&driver->tty_drivers);
2851
2852 /*
2853 * Free the termios and termios_locked structures because
2854 * we don't want to get memory leaks when modular tty
2855 * drivers are removed from the kernel.
2856 */
2857 for (i = 0; i < driver->num; i++) {
2858 tp = driver->termios[i];
2859 if (tp) {
2860 driver->termios[i] = NULL;
2861 kfree(tp);
2862 }
2863 tp = driver->termios_locked[i];
2864 if (tp) {
2865 driver->termios_locked[i] = NULL;
2866 kfree(tp);
2867 }
2868 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2869 tty_unregister_device(driver, i);
2870 }
2871 p = driver->ttys;
2872 proc_tty_unregister_driver(driver);
2873 driver->ttys = NULL;
2874 driver->termios = driver->termios_locked = NULL;
2875 kfree(p);
2876 cdev_del(&driver->cdev);
2877 return 0;
2878}
2879
2880EXPORT_SYMBOL(tty_unregister_driver);
2881
2882
2883/*
2884 * Initialize the console device. This is called *early*, so
2885 * we can't necessarily depend on lots of kernel help here.
2886 * Just do some early initializations, and do the complex setup
2887 * later.
2888 */
2889void __init console_init(void)
2890{
2891 initcall_t *call;
2892
2893 /* Setup the default TTY line discipline. */
2894 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2895
2896 /*
2897 * set up the console device so that later boot sequences can
2898 * inform about problems etc..
2899 */
2900#ifdef CONFIG_EARLY_PRINTK
2901 disable_early_printk();
2902#endif
2903#ifdef CONFIG_SERIAL_68360
2904 /* This is not a console initcall. I know not what it's doing here.
2905 So I haven't moved it. dwmw2 */
2906 rs_360_init();
2907#endif
2908 call = __con_initcall_start;
2909 while (call < __con_initcall_end) {
2910 (*call)();
2911 call++;
2912 }
2913}
2914
2915#ifdef CONFIG_VT
2916extern int vty_init(void);
2917#endif
2918
2919static int __init tty_class_init(void)
2920{
2921 tty_class = class_simple_create(THIS_MODULE, "tty");
2922 if (IS_ERR(tty_class))
2923 return PTR_ERR(tty_class);
2924 return 0;
2925}
2926
2927postcore_initcall(tty_class_init);
2928
2929/* 3/2004 jmc: why do these devices exist? */
2930
2931static struct cdev tty_cdev, console_cdev;
2932#ifdef CONFIG_UNIX98_PTYS
2933static struct cdev ptmx_cdev;
2934#endif
2935#ifdef CONFIG_VT
2936static struct cdev vc0_cdev;
2937#endif
2938
2939/*
2940 * Ok, now we can initialize the rest of the tty devices and can count
2941 * on memory allocations, interrupts etc..
2942 */
2943static int __init tty_init(void)
2944{
2945 cdev_init(&tty_cdev, &tty_fops);
2946 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2947 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2948 panic("Couldn't register /dev/tty driver\n");
2949 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2950 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2951
2952 cdev_init(&console_cdev, &console_fops);
2953 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2954 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2955 panic("Couldn't register /dev/console driver\n");
2956 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2957 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2958
2959#ifdef CONFIG_UNIX98_PTYS
2960 cdev_init(&ptmx_cdev, &ptmx_fops);
2961 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2962 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2963 panic("Couldn't register /dev/ptmx driver\n");
2964 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2965 class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2966#endif
2967
2968#ifdef CONFIG_VT
2969 cdev_init(&vc0_cdev, &console_fops);
2970 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2971 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2972 panic("Couldn't register /dev/tty0 driver\n");
2973 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
2974 class_simple_device_add(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
2975
2976 vty_init();
2977#endif
2978 return 0;
2979}
2980module_init(tty_init);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-29 19:10:57 -0500