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