blob: 4b1eef51ec5926d97918331f20740c3664067375 [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 ? */
Eric Dumazet2f512012005-10-30 15:02:16 -0800812 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 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:
Jesper Juhl735d5662005-11-07 01:01:29 -08001419 kfree(o_tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 if (o_tty)
1421 free_tty_struct(o_tty);
Jesper Juhl735d5662005-11-07 01:01:29 -08001422 kfree(ltp);
1423 kfree(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 free_tty_struct(tty);
1425
1426fail_no_mem:
1427 module_put(driver->owner);
1428 retval = -ENOMEM;
1429 goto end_init;
1430
1431 /* call the tty release_mem routine to clean out this slot */
1432release_mem_out:
1433 printk(KERN_INFO "init_dev: ldisc open failed, "
1434 "clearing slot %d\n", idx);
1435 release_mem(tty, idx);
1436 goto end_init;
1437}
1438
1439/*
1440 * Releases memory associated with a tty structure, and clears out the
1441 * driver table slots.
1442 */
1443static void release_mem(struct tty_struct *tty, int idx)
1444{
1445 struct tty_struct *o_tty;
1446 struct termios *tp;
1447 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1448
1449 if ((o_tty = tty->link) != NULL) {
1450 if (!devpts)
1451 o_tty->driver->ttys[idx] = NULL;
1452 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1453 tp = o_tty->termios;
1454 if (!devpts)
1455 o_tty->driver->termios[idx] = NULL;
1456 kfree(tp);
1457
1458 tp = o_tty->termios_locked;
1459 if (!devpts)
1460 o_tty->driver->termios_locked[idx] = NULL;
1461 kfree(tp);
1462 }
1463 o_tty->magic = 0;
1464 o_tty->driver->refcount--;
1465 file_list_lock();
1466 list_del_init(&o_tty->tty_files);
1467 file_list_unlock();
1468 free_tty_struct(o_tty);
1469 }
1470
1471 if (!devpts)
1472 tty->driver->ttys[idx] = NULL;
1473 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1474 tp = tty->termios;
1475 if (!devpts)
1476 tty->driver->termios[idx] = NULL;
1477 kfree(tp);
1478
1479 tp = tty->termios_locked;
1480 if (!devpts)
1481 tty->driver->termios_locked[idx] = NULL;
1482 kfree(tp);
1483 }
1484
1485 tty->magic = 0;
1486 tty->driver->refcount--;
1487 file_list_lock();
1488 list_del_init(&tty->tty_files);
1489 file_list_unlock();
1490 module_put(tty->driver->owner);
1491 free_tty_struct(tty);
1492}
1493
1494/*
1495 * Even releasing the tty structures is a tricky business.. We have
1496 * to be very careful that the structures are all released at the
1497 * same time, as interrupts might otherwise get the wrong pointers.
1498 *
1499 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1500 * lead to double frees or releasing memory still in use.
1501 */
1502static void release_dev(struct file * filp)
1503{
1504 struct tty_struct *tty, *o_tty;
1505 int pty_master, tty_closing, o_tty_closing, do_sleep;
1506 int devpts_master, devpts;
1507 int idx;
1508 char buf[64];
1509 unsigned long flags;
1510
1511 tty = (struct tty_struct *)filp->private_data;
1512 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1513 return;
1514
1515 check_tty_count(tty, "release_dev");
1516
1517 tty_fasync(-1, filp, 0);
1518
1519 idx = tty->index;
1520 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1521 tty->driver->subtype == PTY_TYPE_MASTER);
1522 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1523 devpts_master = pty_master && devpts;
1524 o_tty = tty->link;
1525
1526#ifdef TTY_PARANOIA_CHECK
1527 if (idx < 0 || idx >= tty->driver->num) {
1528 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1529 "free (%s)\n", tty->name);
1530 return;
1531 }
1532 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1533 if (tty != tty->driver->ttys[idx]) {
1534 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1535 "for (%s)\n", idx, tty->name);
1536 return;
1537 }
1538 if (tty->termios != tty->driver->termios[idx]) {
1539 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1540 "for (%s)\n",
1541 idx, tty->name);
1542 return;
1543 }
1544 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1545 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1546 "termios_locked for (%s)\n",
1547 idx, tty->name);
1548 return;
1549 }
1550 }
1551#endif
1552
1553#ifdef TTY_DEBUG_HANGUP
1554 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1555 tty_name(tty, buf), tty->count);
1556#endif
1557
1558#ifdef TTY_PARANOIA_CHECK
1559 if (tty->driver->other &&
1560 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1561 if (o_tty != tty->driver->other->ttys[idx]) {
1562 printk(KERN_DEBUG "release_dev: other->table[%d] "
1563 "not o_tty for (%s)\n",
1564 idx, tty->name);
1565 return;
1566 }
1567 if (o_tty->termios != tty->driver->other->termios[idx]) {
1568 printk(KERN_DEBUG "release_dev: other->termios[%d] "
1569 "not o_termios for (%s)\n",
1570 idx, tty->name);
1571 return;
1572 }
1573 if (o_tty->termios_locked !=
1574 tty->driver->other->termios_locked[idx]) {
1575 printk(KERN_DEBUG "release_dev: other->termios_locked["
1576 "%d] not o_termios_locked for (%s)\n",
1577 idx, tty->name);
1578 return;
1579 }
1580 if (o_tty->link != tty) {
1581 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1582 return;
1583 }
1584 }
1585#endif
1586 if (tty->driver->close)
1587 tty->driver->close(tty, filp);
1588
1589 /*
1590 * Sanity check: if tty->count is going to zero, there shouldn't be
1591 * any waiters on tty->read_wait or tty->write_wait. We test the
1592 * wait queues and kick everyone out _before_ actually starting to
1593 * close. This ensures that we won't block while releasing the tty
1594 * structure.
1595 *
1596 * The test for the o_tty closing is necessary, since the master and
1597 * slave sides may close in any order. If the slave side closes out
1598 * first, its count will be one, since the master side holds an open.
1599 * Thus this test wouldn't be triggered at the time the slave closes,
1600 * so we do it now.
1601 *
1602 * Note that it's possible for the tty to be opened again while we're
1603 * flushing out waiters. By recalculating the closing flags before
1604 * each iteration we avoid any problems.
1605 */
1606 while (1) {
1607 /* Guard against races with tty->count changes elsewhere and
1608 opens on /dev/tty */
1609
1610 down(&tty_sem);
1611 tty_closing = tty->count <= 1;
1612 o_tty_closing = o_tty &&
1613 (o_tty->count <= (pty_master ? 1 : 0));
1614 up(&tty_sem);
1615 do_sleep = 0;
1616
1617 if (tty_closing) {
1618 if (waitqueue_active(&tty->read_wait)) {
1619 wake_up(&tty->read_wait);
1620 do_sleep++;
1621 }
1622 if (waitqueue_active(&tty->write_wait)) {
1623 wake_up(&tty->write_wait);
1624 do_sleep++;
1625 }
1626 }
1627 if (o_tty_closing) {
1628 if (waitqueue_active(&o_tty->read_wait)) {
1629 wake_up(&o_tty->read_wait);
1630 do_sleep++;
1631 }
1632 if (waitqueue_active(&o_tty->write_wait)) {
1633 wake_up(&o_tty->write_wait);
1634 do_sleep++;
1635 }
1636 }
1637 if (!do_sleep)
1638 break;
1639
1640 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1641 "active!\n", tty_name(tty, buf));
1642 schedule();
1643 }
1644
1645 /*
1646 * The closing flags are now consistent with the open counts on
1647 * both sides, and we've completed the last operation that could
1648 * block, so it's safe to proceed with closing.
1649 */
1650
1651 down(&tty_sem);
1652 if (pty_master) {
1653 if (--o_tty->count < 0) {
1654 printk(KERN_WARNING "release_dev: bad pty slave count "
1655 "(%d) for %s\n",
1656 o_tty->count, tty_name(o_tty, buf));
1657 o_tty->count = 0;
1658 }
1659 }
1660 if (--tty->count < 0) {
1661 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1662 tty->count, tty_name(tty, buf));
1663 tty->count = 0;
1664 }
1665 up(&tty_sem);
1666
1667 /*
1668 * We've decremented tty->count, so we need to remove this file
1669 * descriptor off the tty->tty_files list; this serves two
1670 * purposes:
1671 * - check_tty_count sees the correct number of file descriptors
1672 * associated with this tty.
1673 * - do_tty_hangup no longer sees this file descriptor as
1674 * something that needs to be handled for hangups.
1675 */
1676 file_kill(filp);
1677 filp->private_data = NULL;
1678
1679 /*
1680 * Perform some housekeeping before deciding whether to return.
1681 *
1682 * Set the TTY_CLOSING flag if this was the last open. In the
1683 * case of a pty we may have to wait around for the other side
1684 * to close, and TTY_CLOSING makes sure we can't be reopened.
1685 */
1686 if(tty_closing)
1687 set_bit(TTY_CLOSING, &tty->flags);
1688 if(o_tty_closing)
1689 set_bit(TTY_CLOSING, &o_tty->flags);
1690
1691 /*
1692 * If _either_ side is closing, make sure there aren't any
1693 * processes that still think tty or o_tty is their controlling
1694 * tty.
1695 */
1696 if (tty_closing || o_tty_closing) {
1697 struct task_struct *p;
1698
1699 read_lock(&tasklist_lock);
1700 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1701 p->signal->tty = NULL;
1702 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1703 if (o_tty)
1704 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1705 p->signal->tty = NULL;
1706 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1707 read_unlock(&tasklist_lock);
1708 }
1709
1710 /* check whether both sides are closing ... */
1711 if (!tty_closing || (o_tty && !o_tty_closing))
1712 return;
1713
1714#ifdef TTY_DEBUG_HANGUP
1715 printk(KERN_DEBUG "freeing tty structure...");
1716#endif
1717 /*
1718 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
1719 * kill any delayed work. As this is the final close it does not
1720 * race with the set_ldisc code path.
1721 */
1722 clear_bit(TTY_LDISC, &tty->flags);
1723 clear_bit(TTY_DONT_FLIP, &tty->flags);
1724 cancel_delayed_work(&tty->flip.work);
1725
1726 /*
1727 * Wait for ->hangup_work and ->flip.work handlers to terminate
1728 */
1729
1730 flush_scheduled_work();
1731
1732 /*
1733 * Wait for any short term users (we know they are just driver
1734 * side waiters as the file is closing so user count on the file
1735 * side is zero.
1736 */
1737 spin_lock_irqsave(&tty_ldisc_lock, flags);
1738 while(tty->ldisc.refcount)
1739 {
1740 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1741 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1742 spin_lock_irqsave(&tty_ldisc_lock, flags);
1743 }
1744 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1745 /*
1746 * Shutdown the current line discipline, and reset it to N_TTY.
1747 * N.B. why reset ldisc when we're releasing the memory??
1748 *
1749 * FIXME: this MUST get fixed for the new reflocking
1750 */
1751 if (tty->ldisc.close)
1752 (tty->ldisc.close)(tty);
1753 tty_ldisc_put(tty->ldisc.num);
1754
1755 /*
1756 * Switch the line discipline back
1757 */
1758 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1759 tty_set_termios_ldisc(tty,N_TTY);
1760 if (o_tty) {
1761 /* FIXME: could o_tty be in setldisc here ? */
1762 clear_bit(TTY_LDISC, &o_tty->flags);
1763 if (o_tty->ldisc.close)
1764 (o_tty->ldisc.close)(o_tty);
1765 tty_ldisc_put(o_tty->ldisc.num);
1766 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1767 tty_set_termios_ldisc(o_tty,N_TTY);
1768 }
1769 /*
1770 * The release_mem function takes care of the details of clearing
1771 * the slots and preserving the termios structure.
1772 */
1773 release_mem(tty, idx);
1774
1775#ifdef CONFIG_UNIX98_PTYS
1776 /* Make this pty number available for reallocation */
1777 if (devpts) {
1778 down(&allocated_ptys_lock);
1779 idr_remove(&allocated_ptys, idx);
1780 up(&allocated_ptys_lock);
1781 }
1782#endif
1783
1784}
1785
1786/*
1787 * tty_open and tty_release keep up the tty count that contains the
1788 * number of opens done on a tty. We cannot use the inode-count, as
1789 * different inodes might point to the same tty.
1790 *
1791 * Open-counting is needed for pty masters, as well as for keeping
1792 * track of serial lines: DTR is dropped when the last close happens.
1793 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1794 *
1795 * The termios state of a pty is reset on first open so that
1796 * settings don't persist across reuse.
1797 */
1798static int tty_open(struct inode * inode, struct file * filp)
1799{
1800 struct tty_struct *tty;
1801 int noctty, retval;
1802 struct tty_driver *driver;
1803 int index;
1804 dev_t device = inode->i_rdev;
1805 unsigned short saved_flags = filp->f_flags;
1806
1807 nonseekable_open(inode, filp);
1808
1809retry_open:
1810 noctty = filp->f_flags & O_NOCTTY;
1811 index = -1;
1812 retval = 0;
1813
1814 down(&tty_sem);
1815
1816 if (device == MKDEV(TTYAUX_MAJOR,0)) {
1817 if (!current->signal->tty) {
1818 up(&tty_sem);
1819 return -ENXIO;
1820 }
1821 driver = current->signal->tty->driver;
1822 index = current->signal->tty->index;
1823 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1824 /* noctty = 1; */
1825 goto got_driver;
1826 }
1827#ifdef CONFIG_VT
1828 if (device == MKDEV(TTY_MAJOR,0)) {
1829 extern struct tty_driver *console_driver;
1830 driver = console_driver;
1831 index = fg_console;
1832 noctty = 1;
1833 goto got_driver;
1834 }
1835#endif
1836 if (device == MKDEV(TTYAUX_MAJOR,1)) {
1837 driver = console_device(&index);
1838 if (driver) {
1839 /* Don't let /dev/console block */
1840 filp->f_flags |= O_NONBLOCK;
1841 noctty = 1;
1842 goto got_driver;
1843 }
1844 up(&tty_sem);
1845 return -ENODEV;
1846 }
1847
1848 driver = get_tty_driver(device, &index);
1849 if (!driver) {
1850 up(&tty_sem);
1851 return -ENODEV;
1852 }
1853got_driver:
1854 retval = init_dev(driver, index, &tty);
1855 up(&tty_sem);
1856 if (retval)
1857 return retval;
1858
1859 filp->private_data = tty;
1860 file_move(filp, &tty->tty_files);
1861 check_tty_count(tty, "tty_open");
1862 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1863 tty->driver->subtype == PTY_TYPE_MASTER)
1864 noctty = 1;
1865#ifdef TTY_DEBUG_HANGUP
1866 printk(KERN_DEBUG "opening %s...", tty->name);
1867#endif
1868 if (!retval) {
1869 if (tty->driver->open)
1870 retval = tty->driver->open(tty, filp);
1871 else
1872 retval = -ENODEV;
1873 }
1874 filp->f_flags = saved_flags;
1875
1876 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1877 retval = -EBUSY;
1878
1879 if (retval) {
1880#ifdef TTY_DEBUG_HANGUP
1881 printk(KERN_DEBUG "error %d in opening %s...", retval,
1882 tty->name);
1883#endif
1884 release_dev(filp);
1885 if (retval != -ERESTARTSYS)
1886 return retval;
1887 if (signal_pending(current))
1888 return retval;
1889 schedule();
1890 /*
1891 * Need to reset f_op in case a hangup happened.
1892 */
1893 if (filp->f_op == &hung_up_tty_fops)
1894 filp->f_op = &tty_fops;
1895 goto retry_open;
1896 }
1897 if (!noctty &&
1898 current->signal->leader &&
1899 !current->signal->tty &&
1900 tty->session == 0) {
1901 task_lock(current);
1902 current->signal->tty = tty;
1903 task_unlock(current);
1904 current->signal->tty_old_pgrp = 0;
1905 tty->session = current->signal->session;
1906 tty->pgrp = process_group(current);
1907 }
1908 return 0;
1909}
1910
1911#ifdef CONFIG_UNIX98_PTYS
1912static int ptmx_open(struct inode * inode, struct file * filp)
1913{
1914 struct tty_struct *tty;
1915 int retval;
1916 int index;
1917 int idr_ret;
1918
1919 nonseekable_open(inode, filp);
1920
1921 /* find a device that is not in use. */
1922 down(&allocated_ptys_lock);
1923 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1924 up(&allocated_ptys_lock);
1925 return -ENOMEM;
1926 }
1927 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1928 if (idr_ret < 0) {
1929 up(&allocated_ptys_lock);
1930 if (idr_ret == -EAGAIN)
1931 return -ENOMEM;
1932 return -EIO;
1933 }
1934 if (index >= pty_limit) {
1935 idr_remove(&allocated_ptys, index);
1936 up(&allocated_ptys_lock);
1937 return -EIO;
1938 }
1939 up(&allocated_ptys_lock);
1940
1941 down(&tty_sem);
1942 retval = init_dev(ptm_driver, index, &tty);
1943 up(&tty_sem);
1944
1945 if (retval)
1946 goto out;
1947
1948 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1949 filp->private_data = tty;
1950 file_move(filp, &tty->tty_files);
1951
1952 retval = -ENOMEM;
1953 if (devpts_pty_new(tty->link))
1954 goto out1;
1955
1956 check_tty_count(tty, "tty_open");
1957 retval = ptm_driver->open(tty, filp);
1958 if (!retval)
1959 return 0;
1960out1:
1961 release_dev(filp);
1962out:
1963 down(&allocated_ptys_lock);
1964 idr_remove(&allocated_ptys, index);
1965 up(&allocated_ptys_lock);
1966 return retval;
1967}
1968#endif
1969
1970static int tty_release(struct inode * inode, struct file * filp)
1971{
1972 lock_kernel();
1973 release_dev(filp);
1974 unlock_kernel();
1975 return 0;
1976}
1977
1978/* No kernel lock held - fine */
1979static unsigned int tty_poll(struct file * filp, poll_table * wait)
1980{
1981 struct tty_struct * tty;
1982 struct tty_ldisc *ld;
1983 int ret = 0;
1984
1985 tty = (struct tty_struct *)filp->private_data;
1986 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1987 return 0;
1988
1989 ld = tty_ldisc_ref_wait(tty);
1990 if (ld->poll)
1991 ret = (ld->poll)(tty, filp, wait);
1992 tty_ldisc_deref(ld);
1993 return ret;
1994}
1995
1996static int tty_fasync(int fd, struct file * filp, int on)
1997{
1998 struct tty_struct * tty;
1999 int retval;
2000
2001 tty = (struct tty_struct *)filp->private_data;
2002 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2003 return 0;
2004
2005 retval = fasync_helper(fd, filp, on, &tty->fasync);
2006 if (retval <= 0)
2007 return retval;
2008
2009 if (on) {
2010 if (!waitqueue_active(&tty->read_wait))
2011 tty->minimum_to_wake = 1;
2012 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2013 if (retval)
2014 return retval;
2015 } else {
2016 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2017 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2018 }
2019 return 0;
2020}
2021
2022static int tiocsti(struct tty_struct *tty, char __user *p)
2023{
2024 char ch, mbz = 0;
2025 struct tty_ldisc *ld;
2026
2027 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2028 return -EPERM;
2029 if (get_user(ch, p))
2030 return -EFAULT;
2031 ld = tty_ldisc_ref_wait(tty);
2032 ld->receive_buf(tty, &ch, &mbz, 1);
2033 tty_ldisc_deref(ld);
2034 return 0;
2035}
2036
2037static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2038{
2039 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2040 return -EFAULT;
2041 return 0;
2042}
2043
2044static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2045 struct winsize __user * arg)
2046{
2047 struct winsize tmp_ws;
2048
2049 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2050 return -EFAULT;
2051 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2052 return 0;
2053#ifdef CONFIG_VT
2054 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2055 int rc;
2056
2057 acquire_console_sem();
2058 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2059 release_console_sem();
2060 if (rc)
2061 return -ENXIO;
2062 }
2063#endif
2064 if (tty->pgrp > 0)
2065 kill_pg(tty->pgrp, SIGWINCH, 1);
2066 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2067 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2068 tty->winsize = tmp_ws;
2069 real_tty->winsize = tmp_ws;
2070 return 0;
2071}
2072
2073static int tioccons(struct file *file)
2074{
2075 if (!capable(CAP_SYS_ADMIN))
2076 return -EPERM;
2077 if (file->f_op->write == redirected_tty_write) {
2078 struct file *f;
2079 spin_lock(&redirect_lock);
2080 f = redirect;
2081 redirect = NULL;
2082 spin_unlock(&redirect_lock);
2083 if (f)
2084 fput(f);
2085 return 0;
2086 }
2087 spin_lock(&redirect_lock);
2088 if (redirect) {
2089 spin_unlock(&redirect_lock);
2090 return -EBUSY;
2091 }
2092 get_file(file);
2093 redirect = file;
2094 spin_unlock(&redirect_lock);
2095 return 0;
2096}
2097
2098
2099static int fionbio(struct file *file, int __user *p)
2100{
2101 int nonblock;
2102
2103 if (get_user(nonblock, p))
2104 return -EFAULT;
2105
2106 if (nonblock)
2107 file->f_flags |= O_NONBLOCK;
2108 else
2109 file->f_flags &= ~O_NONBLOCK;
2110 return 0;
2111}
2112
2113static int tiocsctty(struct tty_struct *tty, int arg)
2114{
2115 task_t *p;
2116
2117 if (current->signal->leader &&
2118 (current->signal->session == tty->session))
2119 return 0;
2120 /*
2121 * The process must be a session leader and
2122 * not have a controlling tty already.
2123 */
2124 if (!current->signal->leader || current->signal->tty)
2125 return -EPERM;
2126 if (tty->session > 0) {
2127 /*
2128 * This tty is already the controlling
2129 * tty for another session group!
2130 */
2131 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2132 /*
2133 * Steal it away
2134 */
2135
2136 read_lock(&tasklist_lock);
2137 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2138 p->signal->tty = NULL;
2139 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2140 read_unlock(&tasklist_lock);
2141 } else
2142 return -EPERM;
2143 }
2144 task_lock(current);
2145 current->signal->tty = tty;
2146 task_unlock(current);
2147 current->signal->tty_old_pgrp = 0;
2148 tty->session = current->signal->session;
2149 tty->pgrp = process_group(current);
2150 return 0;
2151}
2152
2153static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2154{
2155 /*
2156 * (tty == real_tty) is a cheap way of
2157 * testing if the tty is NOT a master pty.
2158 */
2159 if (tty == real_tty && current->signal->tty != real_tty)
2160 return -ENOTTY;
2161 return put_user(real_tty->pgrp, p);
2162}
2163
2164static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2165{
2166 pid_t pgrp;
2167 int retval = tty_check_change(real_tty);
2168
2169 if (retval == -EIO)
2170 return -ENOTTY;
2171 if (retval)
2172 return retval;
2173 if (!current->signal->tty ||
2174 (current->signal->tty != real_tty) ||
2175 (real_tty->session != current->signal->session))
2176 return -ENOTTY;
2177 if (get_user(pgrp, p))
2178 return -EFAULT;
2179 if (pgrp < 0)
2180 return -EINVAL;
2181 if (session_of_pgrp(pgrp) != current->signal->session)
2182 return -EPERM;
2183 real_tty->pgrp = pgrp;
2184 return 0;
2185}
2186
2187static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2188{
2189 /*
2190 * (tty == real_tty) is a cheap way of
2191 * testing if the tty is NOT a master pty.
2192 */
2193 if (tty == real_tty && current->signal->tty != real_tty)
2194 return -ENOTTY;
2195 if (real_tty->session <= 0)
2196 return -ENOTTY;
2197 return put_user(real_tty->session, p);
2198}
2199
2200static int tiocsetd(struct tty_struct *tty, int __user *p)
2201{
2202 int ldisc;
2203
2204 if (get_user(ldisc, p))
2205 return -EFAULT;
2206 return tty_set_ldisc(tty, ldisc);
2207}
2208
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002209static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210{
2211 tty->driver->break_ctl(tty, -1);
2212 if (!signal_pending(current)) {
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002213 msleep_interruptible(duration);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 }
2215 tty->driver->break_ctl(tty, 0);
2216 if (signal_pending(current))
2217 return -EINTR;
2218 return 0;
2219}
2220
2221static int
2222tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2223{
2224 int retval = -EINVAL;
2225
2226 if (tty->driver->tiocmget) {
2227 retval = tty->driver->tiocmget(tty, file);
2228
2229 if (retval >= 0)
2230 retval = put_user(retval, p);
2231 }
2232 return retval;
2233}
2234
2235static int
2236tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2237 unsigned __user *p)
2238{
2239 int retval = -EINVAL;
2240
2241 if (tty->driver->tiocmset) {
2242 unsigned int set, clear, val;
2243
2244 retval = get_user(val, p);
2245 if (retval)
2246 return retval;
2247
2248 set = clear = 0;
2249 switch (cmd) {
2250 case TIOCMBIS:
2251 set = val;
2252 break;
2253 case TIOCMBIC:
2254 clear = val;
2255 break;
2256 case TIOCMSET:
2257 set = val;
2258 clear = ~val;
2259 break;
2260 }
2261
2262 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2263 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2264
2265 retval = tty->driver->tiocmset(tty, file, set, clear);
2266 }
2267 return retval;
2268}
2269
2270/*
2271 * Split this up, as gcc can choke on it otherwise..
2272 */
2273int tty_ioctl(struct inode * inode, struct file * file,
2274 unsigned int cmd, unsigned long arg)
2275{
2276 struct tty_struct *tty, *real_tty;
2277 void __user *p = (void __user *)arg;
2278 int retval;
2279 struct tty_ldisc *ld;
2280
2281 tty = (struct tty_struct *)file->private_data;
2282 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2283 return -EINVAL;
2284
2285 real_tty = tty;
2286 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2287 tty->driver->subtype == PTY_TYPE_MASTER)
2288 real_tty = tty->link;
2289
2290 /*
2291 * Break handling by driver
2292 */
2293 if (!tty->driver->break_ctl) {
2294 switch(cmd) {
2295 case TIOCSBRK:
2296 case TIOCCBRK:
2297 if (tty->driver->ioctl)
2298 return tty->driver->ioctl(tty, file, cmd, arg);
2299 return -EINVAL;
2300
2301 /* These two ioctl's always return success; even if */
2302 /* the driver doesn't support them. */
2303 case TCSBRK:
2304 case TCSBRKP:
2305 if (!tty->driver->ioctl)
2306 return 0;
2307 retval = tty->driver->ioctl(tty, file, cmd, arg);
2308 if (retval == -ENOIOCTLCMD)
2309 retval = 0;
2310 return retval;
2311 }
2312 }
2313
2314 /*
2315 * Factor out some common prep work
2316 */
2317 switch (cmd) {
2318 case TIOCSETD:
2319 case TIOCSBRK:
2320 case TIOCCBRK:
2321 case TCSBRK:
2322 case TCSBRKP:
2323 retval = tty_check_change(tty);
2324 if (retval)
2325 return retval;
2326 if (cmd != TIOCCBRK) {
2327 tty_wait_until_sent(tty, 0);
2328 if (signal_pending(current))
2329 return -EINTR;
2330 }
2331 break;
2332 }
2333
2334 switch (cmd) {
2335 case TIOCSTI:
2336 return tiocsti(tty, p);
2337 case TIOCGWINSZ:
2338 return tiocgwinsz(tty, p);
2339 case TIOCSWINSZ:
2340 return tiocswinsz(tty, real_tty, p);
2341 case TIOCCONS:
2342 return real_tty!=tty ? -EINVAL : tioccons(file);
2343 case FIONBIO:
2344 return fionbio(file, p);
2345 case TIOCEXCL:
2346 set_bit(TTY_EXCLUSIVE, &tty->flags);
2347 return 0;
2348 case TIOCNXCL:
2349 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2350 return 0;
2351 case TIOCNOTTY:
2352 if (current->signal->tty != tty)
2353 return -ENOTTY;
2354 if (current->signal->leader)
2355 disassociate_ctty(0);
2356 task_lock(current);
2357 current->signal->tty = NULL;
2358 task_unlock(current);
2359 return 0;
2360 case TIOCSCTTY:
2361 return tiocsctty(tty, arg);
2362 case TIOCGPGRP:
2363 return tiocgpgrp(tty, real_tty, p);
2364 case TIOCSPGRP:
2365 return tiocspgrp(tty, real_tty, p);
2366 case TIOCGSID:
2367 return tiocgsid(tty, real_tty, p);
2368 case TIOCGETD:
2369 /* FIXME: check this is ok */
2370 return put_user(tty->ldisc.num, (int __user *)p);
2371 case TIOCSETD:
2372 return tiocsetd(tty, p);
2373#ifdef CONFIG_VT
2374 case TIOCLINUX:
2375 return tioclinux(tty, arg);
2376#endif
2377 /*
2378 * Break handling
2379 */
2380 case TIOCSBRK: /* Turn break on, unconditionally */
2381 tty->driver->break_ctl(tty, -1);
2382 return 0;
2383
2384 case TIOCCBRK: /* Turn break off, unconditionally */
2385 tty->driver->break_ctl(tty, 0);
2386 return 0;
2387 case TCSBRK: /* SVID version: non-zero arg --> no break */
2388 /*
2389 * XXX is the above comment correct, or the
2390 * code below correct? Is this ioctl used at
2391 * all by anyone?
2392 */
2393 if (!arg)
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002394 return send_break(tty, 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 return 0;
2396 case TCSBRKP: /* support for POSIX tcsendbreak() */
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002397 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398
2399 case TIOCMGET:
2400 return tty_tiocmget(tty, file, p);
2401
2402 case TIOCMSET:
2403 case TIOCMBIC:
2404 case TIOCMBIS:
2405 return tty_tiocmset(tty, file, cmd, p);
2406 }
2407 if (tty->driver->ioctl) {
2408 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2409 if (retval != -ENOIOCTLCMD)
2410 return retval;
2411 }
2412 ld = tty_ldisc_ref_wait(tty);
2413 retval = -EINVAL;
2414 if (ld->ioctl) {
2415 retval = ld->ioctl(tty, file, cmd, arg);
2416 if (retval == -ENOIOCTLCMD)
2417 retval = -EINVAL;
2418 }
2419 tty_ldisc_deref(ld);
2420 return retval;
2421}
2422
2423
2424/*
2425 * This implements the "Secure Attention Key" --- the idea is to
2426 * prevent trojan horses by killing all processes associated with this
2427 * tty when the user hits the "Secure Attention Key". Required for
2428 * super-paranoid applications --- see the Orange Book for more details.
2429 *
2430 * This code could be nicer; ideally it should send a HUP, wait a few
2431 * seconds, then send a INT, and then a KILL signal. But you then
2432 * have to coordinate with the init process, since all processes associated
2433 * with the current tty must be dead before the new getty is allowed
2434 * to spawn.
2435 *
2436 * Now, if it would be correct ;-/ The current code has a nasty hole -
2437 * it doesn't catch files in flight. We may send the descriptor to ourselves
2438 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2439 *
2440 * Nasty bug: do_SAK is being called in interrupt context. This can
2441 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2442 */
2443static void __do_SAK(void *arg)
2444{
2445#ifdef TTY_SOFT_SAK
2446 tty_hangup(tty);
2447#else
2448 struct tty_struct *tty = arg;
2449 struct task_struct *p;
2450 int session;
2451 int i;
2452 struct file *filp;
2453 struct tty_ldisc *disc;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002454 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455
2456 if (!tty)
2457 return;
2458 session = tty->session;
2459
2460 /* We don't want an ldisc switch during this */
2461 disc = tty_ldisc_ref(tty);
2462 if (disc && disc->flush_buffer)
2463 disc->flush_buffer(tty);
2464 tty_ldisc_deref(disc);
2465
2466 if (tty->driver->flush_buffer)
2467 tty->driver->flush_buffer(tty);
2468
2469 read_lock(&tasklist_lock);
2470 do_each_task_pid(session, PIDTYPE_SID, p) {
2471 if (p->signal->tty == tty || session > 0) {
2472 printk(KERN_NOTICE "SAK: killed process %d"
2473 " (%s): p->signal->session==tty->session\n",
2474 p->pid, p->comm);
2475 send_sig(SIGKILL, p, 1);
2476 continue;
2477 }
2478 task_lock(p);
2479 if (p->files) {
Dipankar Sarmab8359962005-09-09 13:04:14 -07002480 rcu_read_lock();
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002481 fdt = files_fdtable(p->files);
2482 for (i=0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 filp = fcheck_files(p->files, i);
2484 if (!filp)
2485 continue;
2486 if (filp->f_op->read == tty_read &&
2487 filp->private_data == tty) {
2488 printk(KERN_NOTICE "SAK: killed process %d"
2489 " (%s): fd#%d opened to the tty\n",
2490 p->pid, p->comm, i);
2491 send_sig(SIGKILL, p, 1);
2492 break;
2493 }
2494 }
Dipankar Sarmab8359962005-09-09 13:04:14 -07002495 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 }
2497 task_unlock(p);
2498 } while_each_task_pid(session, PIDTYPE_SID, p);
2499 read_unlock(&tasklist_lock);
2500#endif
2501}
2502
2503/*
2504 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2505 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2506 * the values which we write to it will be identical to the values which it
2507 * already has. --akpm
2508 */
2509void do_SAK(struct tty_struct *tty)
2510{
2511 if (!tty)
2512 return;
2513 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2514 schedule_work(&tty->SAK_work);
2515}
2516
2517EXPORT_SYMBOL(do_SAK);
2518
2519/*
2520 * This routine is called out of the software interrupt to flush data
2521 * from the flip buffer to the line discipline.
2522 */
2523
2524static void flush_to_ldisc(void *private_)
2525{
2526 struct tty_struct *tty = (struct tty_struct *) private_;
2527 unsigned char *cp;
2528 char *fp;
2529 int count;
2530 unsigned long flags;
2531 struct tty_ldisc *disc;
2532
2533 disc = tty_ldisc_ref(tty);
2534 if (disc == NULL) /* !TTY_LDISC */
2535 return;
2536
2537 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2538 /*
2539 * Do it after the next timer tick:
2540 */
2541 schedule_delayed_work(&tty->flip.work, 1);
2542 goto out;
2543 }
2544 spin_lock_irqsave(&tty->read_lock, flags);
2545 if (tty->flip.buf_num) {
2546 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2547 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2548 tty->flip.buf_num = 0;
2549 tty->flip.char_buf_ptr = tty->flip.char_buf;
2550 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2551 } else {
2552 cp = tty->flip.char_buf;
2553 fp = tty->flip.flag_buf;
2554 tty->flip.buf_num = 1;
2555 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2556 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2557 }
2558 count = tty->flip.count;
2559 tty->flip.count = 0;
2560 spin_unlock_irqrestore(&tty->read_lock, flags);
2561
2562 disc->receive_buf(tty, cp, fp, count);
2563out:
2564 tty_ldisc_deref(disc);
2565}
2566
2567/*
2568 * Routine which returns the baud rate of the tty
2569 *
2570 * Note that the baud_table needs to be kept in sync with the
2571 * include/asm/termbits.h file.
2572 */
2573static int baud_table[] = {
2574 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2575 9600, 19200, 38400, 57600, 115200, 230400, 460800,
2576#ifdef __sparc__
2577 76800, 153600, 307200, 614400, 921600
2578#else
2579 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2580 2500000, 3000000, 3500000, 4000000
2581#endif
2582};
2583
2584static int n_baud_table = ARRAY_SIZE(baud_table);
2585
2586/**
2587 * tty_termios_baud_rate
2588 * @termios: termios structure
2589 *
2590 * Convert termios baud rate data into a speed. This should be called
2591 * with the termios lock held if this termios is a terminal termios
2592 * structure. May change the termios data.
2593 */
2594
2595int tty_termios_baud_rate(struct termios *termios)
2596{
2597 unsigned int cbaud;
2598
2599 cbaud = termios->c_cflag & CBAUD;
2600
2601 if (cbaud & CBAUDEX) {
2602 cbaud &= ~CBAUDEX;
2603
2604 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2605 termios->c_cflag &= ~CBAUDEX;
2606 else
2607 cbaud += 15;
2608 }
2609 return baud_table[cbaud];
2610}
2611
2612EXPORT_SYMBOL(tty_termios_baud_rate);
2613
2614/**
2615 * tty_get_baud_rate - get tty bit rates
2616 * @tty: tty to query
2617 *
2618 * Returns the baud rate as an integer for this terminal. The
2619 * termios lock must be held by the caller and the terminal bit
2620 * flags may be updated.
2621 */
2622
2623int tty_get_baud_rate(struct tty_struct *tty)
2624{
2625 int baud = tty_termios_baud_rate(tty->termios);
2626
2627 if (baud == 38400 && tty->alt_speed) {
2628 if (!tty->warned) {
2629 printk(KERN_WARNING "Use of setserial/setrocket to "
2630 "set SPD_* flags is deprecated\n");
2631 tty->warned = 1;
2632 }
2633 baud = tty->alt_speed;
2634 }
2635
2636 return baud;
2637}
2638
2639EXPORT_SYMBOL(tty_get_baud_rate);
2640
2641/**
2642 * tty_flip_buffer_push - terminal
2643 * @tty: tty to push
2644 *
2645 * Queue a push of the terminal flip buffers to the line discipline. This
2646 * function must not be called from IRQ context if tty->low_latency is set.
2647 *
2648 * In the event of the queue being busy for flipping the work will be
2649 * held off and retried later.
2650 */
2651
2652void tty_flip_buffer_push(struct tty_struct *tty)
2653{
2654 if (tty->low_latency)
2655 flush_to_ldisc((void *) tty);
2656 else
2657 schedule_delayed_work(&tty->flip.work, 1);
2658}
2659
2660EXPORT_SYMBOL(tty_flip_buffer_push);
2661
2662/*
2663 * This subroutine initializes a tty structure.
2664 */
2665static void initialize_tty_struct(struct tty_struct *tty)
2666{
2667 memset(tty, 0, sizeof(struct tty_struct));
2668 tty->magic = TTY_MAGIC;
2669 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2670 tty->pgrp = -1;
2671 tty->overrun_time = jiffies;
2672 tty->flip.char_buf_ptr = tty->flip.char_buf;
2673 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2674 INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2675 init_MUTEX(&tty->flip.pty_sem);
2676 init_MUTEX(&tty->termios_sem);
2677 init_waitqueue_head(&tty->write_wait);
2678 init_waitqueue_head(&tty->read_wait);
2679 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2680 sema_init(&tty->atomic_read, 1);
2681 sema_init(&tty->atomic_write, 1);
2682 spin_lock_init(&tty->read_lock);
2683 INIT_LIST_HEAD(&tty->tty_files);
2684 INIT_WORK(&tty->SAK_work, NULL, NULL);
2685}
2686
2687/*
2688 * The default put_char routine if the driver did not define one.
2689 */
2690static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2691{
2692 tty->driver->write(tty, &ch, 1);
2693}
2694
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08002695static struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696
2697/**
2698 * tty_register_device - register a tty device
2699 * @driver: the tty driver that describes the tty device
2700 * @index: the index in the tty driver for this tty device
2701 * @device: a struct device that is associated with this tty device.
2702 * This field is optional, if there is no known struct device for this
2703 * tty device it can be set to NULL safely.
2704 *
2705 * This call is required to be made to register an individual tty device if
2706 * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set. If that
2707 * bit is not set, this function should not be called.
2708 */
2709void tty_register_device(struct tty_driver *driver, unsigned index,
2710 struct device *device)
2711{
2712 char name[64];
2713 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2714
2715 if (index >= driver->num) {
2716 printk(KERN_ERR "Attempt to register invalid tty line number "
2717 " (%d).\n", index);
2718 return;
2719 }
2720
2721 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2722 "%s%d", driver->devfs_name, index + driver->name_base);
2723
2724 if (driver->type == TTY_DRIVER_TYPE_PTY)
2725 pty_line_name(driver, index, name);
2726 else
2727 tty_line_name(driver, index, name);
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07002728 class_device_create(tty_class, NULL, dev, device, "%s", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729}
2730
2731/**
2732 * tty_unregister_device - unregister a tty device
2733 * @driver: the tty driver that describes the tty device
2734 * @index: the index in the tty driver for this tty device
2735 *
2736 * If a tty device is registered with a call to tty_register_device() then
2737 * this function must be made when the tty device is gone.
2738 */
2739void tty_unregister_device(struct tty_driver *driver, unsigned index)
2740{
2741 devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08002742 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743}
2744
2745EXPORT_SYMBOL(tty_register_device);
2746EXPORT_SYMBOL(tty_unregister_device);
2747
2748struct tty_driver *alloc_tty_driver(int lines)
2749{
2750 struct tty_driver *driver;
2751
2752 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2753 if (driver) {
2754 memset(driver, 0, sizeof(struct tty_driver));
2755 driver->magic = TTY_DRIVER_MAGIC;
2756 driver->num = lines;
2757 /* later we'll move allocation of tables here */
2758 }
2759 return driver;
2760}
2761
2762void put_tty_driver(struct tty_driver *driver)
2763{
2764 kfree(driver);
2765}
2766
2767void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2768{
2769 driver->open = op->open;
2770 driver->close = op->close;
2771 driver->write = op->write;
2772 driver->put_char = op->put_char;
2773 driver->flush_chars = op->flush_chars;
2774 driver->write_room = op->write_room;
2775 driver->chars_in_buffer = op->chars_in_buffer;
2776 driver->ioctl = op->ioctl;
2777 driver->set_termios = op->set_termios;
2778 driver->throttle = op->throttle;
2779 driver->unthrottle = op->unthrottle;
2780 driver->stop = op->stop;
2781 driver->start = op->start;
2782 driver->hangup = op->hangup;
2783 driver->break_ctl = op->break_ctl;
2784 driver->flush_buffer = op->flush_buffer;
2785 driver->set_ldisc = op->set_ldisc;
2786 driver->wait_until_sent = op->wait_until_sent;
2787 driver->send_xchar = op->send_xchar;
2788 driver->read_proc = op->read_proc;
2789 driver->write_proc = op->write_proc;
2790 driver->tiocmget = op->tiocmget;
2791 driver->tiocmset = op->tiocmset;
2792}
2793
2794
2795EXPORT_SYMBOL(alloc_tty_driver);
2796EXPORT_SYMBOL(put_tty_driver);
2797EXPORT_SYMBOL(tty_set_operations);
2798
2799/*
2800 * Called by a tty driver to register itself.
2801 */
2802int tty_register_driver(struct tty_driver *driver)
2803{
2804 int error;
2805 int i;
2806 dev_t dev;
2807 void **p = NULL;
2808
2809 if (driver->flags & TTY_DRIVER_INSTALLED)
2810 return 0;
2811
2812 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2813 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2814 if (!p)
2815 return -ENOMEM;
2816 memset(p, 0, driver->num * 3 * sizeof(void *));
2817 }
2818
2819 if (!driver->major) {
2820 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2821 (char*)driver->name);
2822 if (!error) {
2823 driver->major = MAJOR(dev);
2824 driver->minor_start = MINOR(dev);
2825 }
2826 } else {
2827 dev = MKDEV(driver->major, driver->minor_start);
2828 error = register_chrdev_region(dev, driver->num,
2829 (char*)driver->name);
2830 }
2831 if (error < 0) {
2832 kfree(p);
2833 return error;
2834 }
2835
2836 if (p) {
2837 driver->ttys = (struct tty_struct **)p;
2838 driver->termios = (struct termios **)(p + driver->num);
2839 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2840 } else {
2841 driver->ttys = NULL;
2842 driver->termios = NULL;
2843 driver->termios_locked = NULL;
2844 }
2845
2846 cdev_init(&driver->cdev, &tty_fops);
2847 driver->cdev.owner = driver->owner;
2848 error = cdev_add(&driver->cdev, dev, driver->num);
2849 if (error) {
2850 cdev_del(&driver->cdev);
2851 unregister_chrdev_region(dev, driver->num);
2852 driver->ttys = NULL;
2853 driver->termios = driver->termios_locked = NULL;
2854 kfree(p);
2855 return error;
2856 }
2857
2858 if (!driver->put_char)
2859 driver->put_char = tty_default_put_char;
2860
2861 list_add(&driver->tty_drivers, &tty_drivers);
2862
2863 if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2864 for(i = 0; i < driver->num; i++)
2865 tty_register_device(driver, i, NULL);
2866 }
2867 proc_tty_register_driver(driver);
2868 return 0;
2869}
2870
2871EXPORT_SYMBOL(tty_register_driver);
2872
2873/*
2874 * Called by a tty driver to unregister itself.
2875 */
2876int tty_unregister_driver(struct tty_driver *driver)
2877{
2878 int i;
2879 struct termios *tp;
2880 void *p;
2881
2882 if (driver->refcount)
2883 return -EBUSY;
2884
2885 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2886 driver->num);
2887
2888 list_del(&driver->tty_drivers);
2889
2890 /*
2891 * Free the termios and termios_locked structures because
2892 * we don't want to get memory leaks when modular tty
2893 * drivers are removed from the kernel.
2894 */
2895 for (i = 0; i < driver->num; i++) {
2896 tp = driver->termios[i];
2897 if (tp) {
2898 driver->termios[i] = NULL;
2899 kfree(tp);
2900 }
2901 tp = driver->termios_locked[i];
2902 if (tp) {
2903 driver->termios_locked[i] = NULL;
2904 kfree(tp);
2905 }
2906 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2907 tty_unregister_device(driver, i);
2908 }
2909 p = driver->ttys;
2910 proc_tty_unregister_driver(driver);
2911 driver->ttys = NULL;
2912 driver->termios = driver->termios_locked = NULL;
2913 kfree(p);
2914 cdev_del(&driver->cdev);
2915 return 0;
2916}
2917
2918EXPORT_SYMBOL(tty_unregister_driver);
2919
2920
2921/*
2922 * Initialize the console device. This is called *early*, so
2923 * we can't necessarily depend on lots of kernel help here.
2924 * Just do some early initializations, and do the complex setup
2925 * later.
2926 */
2927void __init console_init(void)
2928{
2929 initcall_t *call;
2930
2931 /* Setup the default TTY line discipline. */
2932 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2933
2934 /*
2935 * set up the console device so that later boot sequences can
2936 * inform about problems etc..
2937 */
2938#ifdef CONFIG_EARLY_PRINTK
2939 disable_early_printk();
2940#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 call = __con_initcall_start;
2942 while (call < __con_initcall_end) {
2943 (*call)();
2944 call++;
2945 }
2946}
2947
2948#ifdef CONFIG_VT
2949extern int vty_init(void);
2950#endif
2951
2952static int __init tty_class_init(void)
2953{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08002954 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 if (IS_ERR(tty_class))
2956 return PTR_ERR(tty_class);
2957 return 0;
2958}
2959
2960postcore_initcall(tty_class_init);
2961
2962/* 3/2004 jmc: why do these devices exist? */
2963
2964static struct cdev tty_cdev, console_cdev;
2965#ifdef CONFIG_UNIX98_PTYS
2966static struct cdev ptmx_cdev;
2967#endif
2968#ifdef CONFIG_VT
2969static struct cdev vc0_cdev;
2970#endif
2971
2972/*
2973 * Ok, now we can initialize the rest of the tty devices and can count
2974 * on memory allocations, interrupts etc..
2975 */
2976static int __init tty_init(void)
2977{
2978 cdev_init(&tty_cdev, &tty_fops);
2979 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2980 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2981 panic("Couldn't register /dev/tty driver\n");
2982 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07002983 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984
2985 cdev_init(&console_cdev, &console_fops);
2986 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2987 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2988 panic("Couldn't register /dev/console driver\n");
2989 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07002990 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991
2992#ifdef CONFIG_UNIX98_PTYS
2993 cdev_init(&ptmx_cdev, &ptmx_fops);
2994 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2995 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2996 panic("Couldn't register /dev/ptmx driver\n");
2997 devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07002998 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999#endif
3000
3001#ifdef CONFIG_VT
3002 cdev_init(&vc0_cdev, &console_fops);
3003 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3004 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3005 panic("Couldn't register /dev/tty0 driver\n");
3006 devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003007 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008
3009 vty_init();
3010#endif
3011 return 0;
3012}
3013module_init(tty_init);