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