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