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