tty: restore locked ioctl file op
[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
1da177e4
LT
68#include <linux/types.h>
69#include <linux/major.h>
70#include <linux/errno.h>
71#include <linux/signal.h>
72#include <linux/fcntl.h>
73#include <linux/sched.h>
74#include <linux/interrupt.h>
75#include <linux/tty.h>
76#include <linux/tty_driver.h>
77#include <linux/tty_flip.h>
78#include <linux/devpts_fs.h>
79#include <linux/file.h>
80#include <linux/console.h>
81#include <linux/timer.h>
82#include <linux/ctype.h>
83#include <linux/kd.h>
84#include <linux/mm.h>
85#include <linux/string.h>
86#include <linux/slab.h>
87#include <linux/poll.h>
88#include <linux/proc_fs.h>
89#include <linux/init.h>
90#include <linux/module.h>
91#include <linux/smp_lock.h>
92#include <linux/device.h>
93#include <linux/idr.h>
94#include <linux/wait.h>
95#include <linux/bitops.h>
b20f3ae5 96#include <linux/delay.h>
1da177e4
LT
97
98#include <asm/uaccess.h>
99#include <asm/system.h>
100
101#include <linux/kbd_kern.h>
102#include <linux/vt_kern.h>
103#include <linux/selection.h>
1da177e4
LT
104
105#include <linux/kmod.h>
106
107#undef TTY_DEBUG_HANGUP
108
109#define TTY_PARANOIA_CHECK 1
110#define CHECK_TTY_COUNT 1
111
edc6afc5 112struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
1da177e4
LT
113 .c_iflag = ICRNL | IXON,
114 .c_oflag = OPOST | ONLCR,
115 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
116 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
117 ECHOCTL | ECHOKE | IEXTEN,
edc6afc5
AC
118 .c_cc = INIT_C_CC,
119 .c_ispeed = 38400,
120 .c_ospeed = 38400
1da177e4
LT
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
24ec839c 131/* Mutex to protect creating and releasing a tty. This is shared with
1da177e4 132 vt.c for deeply disgusting hack reasons */
70522e12 133DEFINE_MUTEX(tty_mutex);
de2a84f2 134EXPORT_SYMBOL(tty_mutex);
1da177e4
LT
135
136#ifdef CONFIG_UNIX98_PTYS
137extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
138extern int pty_limit; /* Config limit on Unix98 ptys */
139static DEFINE_IDR(allocated_ptys);
140static DECLARE_MUTEX(allocated_ptys_lock);
141static int ptmx_open(struct inode *, struct file *);
142#endif
143
1da177e4
LT
144static void initialize_tty_struct(struct tty_struct *tty);
145
146static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149static unsigned int tty_poll(struct file *, poll_table *);
150static int tty_open(struct inode *, struct file *);
151static int tty_release(struct inode *, struct file *);
152int tty_ioctl(struct inode * inode, struct file * file,
153 unsigned int cmd, unsigned long arg);
e10cc1df
PF
154#ifdef CONFIG_COMPAT
155static long tty_compat_ioctl(struct file * file, unsigned int cmd,
156 unsigned long arg);
157#else
158#define tty_compat_ioctl NULL
159#endif
1da177e4 160static int tty_fasync(int fd, struct file * filp, int on);
d5698c28 161static void release_tty(struct tty_struct *tty, int idx);
2a65f1d9 162static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
98a27ba4 163static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
1da177e4 164
af9b897e
AC
165/**
166 * alloc_tty_struct - allocate a tty object
167 *
168 * Return a new empty tty structure. The data fields have not
169 * been initialized in any way but has been zeroed
170 *
171 * Locking: none
af9b897e 172 */
1da177e4
LT
173
174static struct tty_struct *alloc_tty_struct(void)
175{
1266b1e1 176 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
1da177e4
LT
177}
178
33f0f88f
AC
179static void tty_buffer_free_all(struct tty_struct *);
180
af9b897e
AC
181/**
182 * free_tty_struct - free a disused tty
183 * @tty: tty struct to free
184 *
185 * Free the write buffers, tty queue and tty memory itself.
186 *
187 * Locking: none. Must be called after tty is definitely unused
188 */
189
1da177e4
LT
190static inline void free_tty_struct(struct tty_struct *tty)
191{
192 kfree(tty->write_buf);
33f0f88f 193 tty_buffer_free_all(tty);
1da177e4
LT
194 kfree(tty);
195}
196
197#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
198
af9b897e
AC
199/**
200 * tty_name - return tty naming
201 * @tty: tty structure
202 * @buf: buffer for output
203 *
204 * Convert a tty structure into a name. The name reflects the kernel
205 * naming policy and if udev is in use may not reflect user space
206 *
207 * Locking: none
208 */
209
1da177e4
LT
210char *tty_name(struct tty_struct *tty, char *buf)
211{
212 if (!tty) /* Hmm. NULL pointer. That's fun. */
213 strcpy(buf, "NULL tty");
214 else
215 strcpy(buf, tty->name);
216 return buf;
217}
218
219EXPORT_SYMBOL(tty_name);
220
d769a669 221int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
1da177e4
LT
222 const char *routine)
223{
224#ifdef TTY_PARANOIA_CHECK
225 if (!tty) {
226 printk(KERN_WARNING
227 "null TTY for (%d:%d) in %s\n",
228 imajor(inode), iminor(inode), routine);
229 return 1;
230 }
231 if (tty->magic != TTY_MAGIC) {
232 printk(KERN_WARNING
233 "bad magic number for tty struct (%d:%d) in %s\n",
234 imajor(inode), iminor(inode), routine);
235 return 1;
236 }
237#endif
238 return 0;
239}
240
241static int check_tty_count(struct tty_struct *tty, const char *routine)
242{
243#ifdef CHECK_TTY_COUNT
244 struct list_head *p;
245 int count = 0;
246
247 file_list_lock();
248 list_for_each(p, &tty->tty_files) {
249 count++;
250 }
251 file_list_unlock();
252 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
253 tty->driver->subtype == PTY_TYPE_SLAVE &&
254 tty->link && tty->link->count)
255 count++;
256 if (tty->count != count) {
257 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
258 "!= #fd's(%d) in %s\n",
259 tty->name, tty->count, count, routine);
260 return count;
24ec839c 261 }
1da177e4
LT
262#endif
263 return 0;
264}
265
33f0f88f
AC
266/*
267 * Tty buffer allocation management
268 */
269
af9b897e
AC
270/**
271 * tty_buffer_free_all - free buffers used by a tty
272 * @tty: tty to free from
273 *
274 * Remove all the buffers pending on a tty whether queued with data
275 * or in the free ring. Must be called when the tty is no longer in use
276 *
277 * Locking: none
278 */
279
33f0f88f
AC
280static void tty_buffer_free_all(struct tty_struct *tty)
281{
282 struct tty_buffer *thead;
283 while((thead = tty->buf.head) != NULL) {
284 tty->buf.head = thead->next;
285 kfree(thead);
286 }
287 while((thead = tty->buf.free) != NULL) {
288 tty->buf.free = thead->next;
289 kfree(thead);
290 }
291 tty->buf.tail = NULL;
01da5fd8 292 tty->buf.memory_used = 0;
33f0f88f
AC
293}
294
01da5fd8
AC
295/**
296 * tty_buffer_init - prepare a tty buffer structure
297 * @tty: tty to initialise
298 *
299 * Set up the initial state of the buffer management for a tty device.
300 * Must be called before the other tty buffer functions are used.
301 *
302 * Locking: none
303 */
304
33f0f88f
AC
305static void tty_buffer_init(struct tty_struct *tty)
306{
808249ce 307 spin_lock_init(&tty->buf.lock);
33f0f88f
AC
308 tty->buf.head = NULL;
309 tty->buf.tail = NULL;
310 tty->buf.free = NULL;
01da5fd8 311 tty->buf.memory_used = 0;
33f0f88f
AC
312}
313
01da5fd8
AC
314/**
315 * tty_buffer_alloc - allocate a tty buffer
316 * @tty: tty device
317 * @size: desired size (characters)
318 *
319 * Allocate a new tty buffer to hold the desired number of characters.
320 * Return NULL if out of memory or the allocation would exceed the
321 * per device queue
322 *
323 * Locking: Caller must hold tty->buf.lock
324 */
325
326static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
33f0f88f 327{
01da5fd8
AC
328 struct tty_buffer *p;
329
330 if (tty->buf.memory_used + size > 65536)
331 return NULL;
332 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
33f0f88f
AC
333 if(p == NULL)
334 return NULL;
335 p->used = 0;
336 p->size = size;
337 p->next = NULL;
8977d929
PF
338 p->commit = 0;
339 p->read = 0;
33f0f88f
AC
340 p->char_buf_ptr = (char *)(p->data);
341 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
01da5fd8 342 tty->buf.memory_used += size;
33f0f88f
AC
343 return p;
344}
345
01da5fd8
AC
346/**
347 * tty_buffer_free - free a tty buffer
348 * @tty: tty owning the buffer
349 * @b: the buffer to free
350 *
351 * Free a tty buffer, or add it to the free list according to our
352 * internal strategy
353 *
354 * Locking: Caller must hold tty->buf.lock
355 */
33f0f88f
AC
356
357static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
358{
359 /* Dumb strategy for now - should keep some stats */
01da5fd8
AC
360 tty->buf.memory_used -= b->size;
361 WARN_ON(tty->buf.memory_used < 0);
362
33f0f88f
AC
363 if(b->size >= 512)
364 kfree(b);
365 else {
366 b->next = tty->buf.free;
367 tty->buf.free = b;
368 }
369}
370
c5c34d48
PF
371/**
372 * tty_buffer_flush - flush full tty buffers
373 * @tty: tty to flush
374 *
375 * flush all the buffers containing receive data
376 *
377 * Locking: none
378 */
379
380static void tty_buffer_flush(struct tty_struct *tty)
381{
382 struct tty_buffer *thead;
383 unsigned long flags;
384
385 spin_lock_irqsave(&tty->buf.lock, flags);
386 while((thead = tty->buf.head) != NULL) {
387 tty->buf.head = thead->next;
388 tty_buffer_free(tty, thead);
389 }
390 tty->buf.tail = NULL;
391 spin_unlock_irqrestore(&tty->buf.lock, flags);
392}
393
01da5fd8
AC
394/**
395 * tty_buffer_find - find a free tty buffer
396 * @tty: tty owning the buffer
397 * @size: characters wanted
398 *
399 * Locate an existing suitable tty buffer or if we are lacking one then
400 * allocate a new one. We round our buffers off in 256 character chunks
401 * to get better allocation behaviour.
402 *
403 * Locking: Caller must hold tty->buf.lock
404 */
405
33f0f88f
AC
406static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
407{
408 struct tty_buffer **tbh = &tty->buf.free;
409 while((*tbh) != NULL) {
410 struct tty_buffer *t = *tbh;
411 if(t->size >= size) {
412 *tbh = t->next;
413 t->next = NULL;
414 t->used = 0;
8977d929
PF
415 t->commit = 0;
416 t->read = 0;
01da5fd8 417 tty->buf.memory_used += t->size;
33f0f88f
AC
418 return t;
419 }
420 tbh = &((*tbh)->next);
421 }
422 /* Round the buffer size out */
423 size = (size + 0xFF) & ~ 0xFF;
01da5fd8 424 return tty_buffer_alloc(tty, size);
33f0f88f
AC
425 /* Should possibly check if this fails for the largest buffer we
426 have queued and recycle that ? */
427}
428
01da5fd8
AC
429/**
430 * tty_buffer_request_room - grow tty buffer if needed
431 * @tty: tty structure
432 * @size: size desired
433 *
434 * Make at least size bytes of linear space available for the tty
435 * buffer. If we fail return the size we managed to find.
436 *
437 * Locking: Takes tty->buf.lock
438 */
33f0f88f
AC
439int tty_buffer_request_room(struct tty_struct *tty, size_t size)
440{
808249ce
PF
441 struct tty_buffer *b, *n;
442 int left;
443 unsigned long flags;
444
445 spin_lock_irqsave(&tty->buf.lock, flags);
33f0f88f
AC
446
447 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
448 remove this conditional if its worth it. This would be invisible
449 to the callers */
33b37a33 450 if ((b = tty->buf.tail) != NULL)
33f0f88f 451 left = b->size - b->used;
33b37a33 452 else
808249ce
PF
453 left = 0;
454
455 if (left < size) {
456 /* This is the slow path - looking for new buffers to use */
457 if ((n = tty_buffer_find(tty, size)) != NULL) {
458 if (b != NULL) {
459 b->next = n;
8977d929 460 b->commit = b->used;
808249ce
PF
461 } else
462 tty->buf.head = n;
463 tty->buf.tail = n;
808249ce
PF
464 } else
465 size = left;
466 }
467
468 spin_unlock_irqrestore(&tty->buf.lock, flags);
33f0f88f
AC
469 return size;
470}
33f0f88f
AC
471EXPORT_SYMBOL_GPL(tty_buffer_request_room);
472
af9b897e
AC
473/**
474 * tty_insert_flip_string - Add characters to the tty buffer
475 * @tty: tty structure
476 * @chars: characters
477 * @size: size
478 *
479 * Queue a series of bytes to the tty buffering. All the characters
480 * passed are marked as without error. Returns the number added.
481 *
482 * Locking: Called functions may take tty->buf.lock
483 */
484
e1a25090
AM
485int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
486 size_t size)
33f0f88f
AC
487{
488 int copied = 0;
489 do {
490 int space = tty_buffer_request_room(tty, size - copied);
491 struct tty_buffer *tb = tty->buf.tail;
492 /* If there is no space then tb may be NULL */
493 if(unlikely(space == 0))
494 break;
495 memcpy(tb->char_buf_ptr + tb->used, chars, space);
496 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
497 tb->used += space;
498 copied += space;
499 chars += space;
527063ba
AD
500 /* There is a small chance that we need to split the data over
501 several buffers. If this is the case we must loop */
502 } while (unlikely(size > copied));
33f0f88f
AC
503 return copied;
504}
ee37df78 505EXPORT_SYMBOL(tty_insert_flip_string);
33f0f88f 506
af9b897e
AC
507/**
508 * tty_insert_flip_string_flags - Add characters to the tty buffer
509 * @tty: tty structure
510 * @chars: characters
511 * @flags: flag bytes
512 * @size: size
513 *
514 * Queue a series of bytes to the tty buffering. For each character
515 * the flags array indicates the status of the character. Returns the
516 * number added.
517 *
518 * Locking: Called functions may take tty->buf.lock
519 */
520
e1a25090
AM
521int tty_insert_flip_string_flags(struct tty_struct *tty,
522 const unsigned char *chars, const char *flags, size_t size)
33f0f88f
AC
523{
524 int copied = 0;
525 do {
526 int space = tty_buffer_request_room(tty, size - copied);
527 struct tty_buffer *tb = tty->buf.tail;
528 /* If there is no space then tb may be NULL */
529 if(unlikely(space == 0))
530 break;
531 memcpy(tb->char_buf_ptr + tb->used, chars, space);
532 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
533 tb->used += space;
534 copied += space;
535 chars += space;
536 flags += space;
527063ba
AD
537 /* There is a small chance that we need to split the data over
538 several buffers. If this is the case we must loop */
539 } while (unlikely(size > copied));
33f0f88f
AC
540 return copied;
541}
ff4547f4 542EXPORT_SYMBOL(tty_insert_flip_string_flags);
33f0f88f 543
af9b897e
AC
544/**
545 * tty_schedule_flip - push characters to ldisc
546 * @tty: tty to push from
547 *
548 * Takes any pending buffers and transfers their ownership to the
549 * ldisc side of the queue. It then schedules those characters for
550 * processing by the line discipline.
551 *
552 * Locking: Takes tty->buf.lock
553 */
554
e1a25090
AM
555void tty_schedule_flip(struct tty_struct *tty)
556{
557 unsigned long flags;
558 spin_lock_irqsave(&tty->buf.lock, flags);
33b37a33 559 if (tty->buf.tail != NULL)
e1a25090 560 tty->buf.tail->commit = tty->buf.tail->used;
e1a25090
AM
561 spin_unlock_irqrestore(&tty->buf.lock, flags);
562 schedule_delayed_work(&tty->buf.work, 1);
563}
564EXPORT_SYMBOL(tty_schedule_flip);
33f0f88f 565
af9b897e
AC
566/**
567 * tty_prepare_flip_string - make room for characters
568 * @tty: tty
569 * @chars: return pointer for character write area
570 * @size: desired size
571 *
33f0f88f
AC
572 * Prepare a block of space in the buffer for data. Returns the length
573 * available and buffer pointer to the space which is now allocated and
574 * accounted for as ready for normal characters. This is used for drivers
575 * that need their own block copy routines into the buffer. There is no
576 * guarantee the buffer is a DMA target!
af9b897e
AC
577 *
578 * Locking: May call functions taking tty->buf.lock
33f0f88f
AC
579 */
580
581int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
582{
583 int space = tty_buffer_request_room(tty, size);
808249ce
PF
584 if (likely(space)) {
585 struct tty_buffer *tb = tty->buf.tail;
586 *chars = tb->char_buf_ptr + tb->used;
587 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
588 tb->used += space;
589 }
33f0f88f
AC
590 return space;
591}
592
593EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
594
af9b897e
AC
595/**
596 * tty_prepare_flip_string_flags - make room for characters
597 * @tty: tty
598 * @chars: return pointer for character write area
599 * @flags: return pointer for status flag write area
600 * @size: desired size
601 *
33f0f88f
AC
602 * Prepare a block of space in the buffer for data. Returns the length
603 * available and buffer pointer to the space which is now allocated and
604 * accounted for as ready for characters. This is used for drivers
605 * that need their own block copy routines into the buffer. There is no
606 * guarantee the buffer is a DMA target!
af9b897e
AC
607 *
608 * Locking: May call functions taking tty->buf.lock
33f0f88f
AC
609 */
610
611int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
612{
613 int space = tty_buffer_request_room(tty, size);
808249ce
PF
614 if (likely(space)) {
615 struct tty_buffer *tb = tty->buf.tail;
616 *chars = tb->char_buf_ptr + tb->used;
617 *flags = tb->flag_buf_ptr + tb->used;
618 tb->used += space;
619 }
33f0f88f
AC
620 return space;
621}
622
623EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
624
625
626
af9b897e
AC
627/**
628 * tty_set_termios_ldisc - set ldisc field
629 * @tty: tty structure
630 * @num: line discipline number
631 *
1da177e4
LT
632 * This is probably overkill for real world processors but
633 * they are not on hot paths so a little discipline won't do
634 * any harm.
af9b897e 635 *
24ec839c 636 * Locking: takes termios_mutex
1da177e4
LT
637 */
638
639static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
640{
5785c95b 641 mutex_lock(&tty->termios_mutex);
1da177e4 642 tty->termios->c_line = num;
5785c95b 643 mutex_unlock(&tty->termios_mutex);
1da177e4
LT
644}
645
646/*
647 * This guards the refcounted line discipline lists. The lock
648 * must be taken with irqs off because there are hangup path
649 * callers who will do ldisc lookups and cannot sleep.
650 */
651
652static DEFINE_SPINLOCK(tty_ldisc_lock);
653static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
bfb07599 654static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
1da177e4 655
af9b897e
AC
656/**
657 * tty_register_ldisc - install a line discipline
658 * @disc: ldisc number
659 * @new_ldisc: pointer to the ldisc object
660 *
661 * Installs a new line discipline into the kernel. The discipline
662 * is set up as unreferenced and then made available to the kernel
663 * from this point onwards.
664 *
665 * Locking:
666 * takes tty_ldisc_lock to guard against ldisc races
667 */
668
1da177e4
LT
669int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
670{
671 unsigned long flags;
672 int ret = 0;
673
674 if (disc < N_TTY || disc >= NR_LDISCS)
675 return -EINVAL;
676
677 spin_lock_irqsave(&tty_ldisc_lock, flags);
bfb07599
AD
678 tty_ldiscs[disc] = *new_ldisc;
679 tty_ldiscs[disc].num = disc;
680 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
681 tty_ldiscs[disc].refcount = 0;
1da177e4
LT
682 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
683
684 return ret;
685}
1da177e4
LT
686EXPORT_SYMBOL(tty_register_ldisc);
687
af9b897e
AC
688/**
689 * tty_unregister_ldisc - unload a line discipline
690 * @disc: ldisc number
691 * @new_ldisc: pointer to the ldisc object
692 *
693 * Remove a line discipline from the kernel providing it is not
694 * currently in use.
695 *
696 * Locking:
697 * takes tty_ldisc_lock to guard against ldisc races
698 */
699
bfb07599
AD
700int tty_unregister_ldisc(int disc)
701{
702 unsigned long flags;
703 int ret = 0;
704
705 if (disc < N_TTY || disc >= NR_LDISCS)
706 return -EINVAL;
707
708 spin_lock_irqsave(&tty_ldisc_lock, flags);
709 if (tty_ldiscs[disc].refcount)
710 ret = -EBUSY;
711 else
712 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
713 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
714
715 return ret;
716}
717EXPORT_SYMBOL(tty_unregister_ldisc);
718
af9b897e
AC
719/**
720 * tty_ldisc_get - take a reference to an ldisc
721 * @disc: ldisc number
722 *
723 * Takes a reference to a line discipline. Deals with refcounts and
724 * module locking counts. Returns NULL if the discipline is not available.
725 * Returns a pointer to the discipline and bumps the ref count if it is
726 * available
727 *
728 * Locking:
729 * takes tty_ldisc_lock to guard against ldisc races
730 */
731
1da177e4
LT
732struct tty_ldisc *tty_ldisc_get(int disc)
733{
734 unsigned long flags;
735 struct tty_ldisc *ld;
736
737 if (disc < N_TTY || disc >= NR_LDISCS)
738 return NULL;
739
740 spin_lock_irqsave(&tty_ldisc_lock, flags);
741
742 ld = &tty_ldiscs[disc];
743 /* Check the entry is defined */
744 if(ld->flags & LDISC_FLAG_DEFINED)
745 {
746 /* If the module is being unloaded we can't use it */
747 if (!try_module_get(ld->owner))
748 ld = NULL;
749 else /* lock it */
750 ld->refcount++;
751 }
752 else
753 ld = NULL;
754 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
755 return ld;
756}
757
758EXPORT_SYMBOL_GPL(tty_ldisc_get);
759
af9b897e
AC
760/**
761 * tty_ldisc_put - drop ldisc reference
762 * @disc: ldisc number
763 *
764 * Drop a reference to a line discipline. Manage refcounts and
765 * module usage counts
766 *
767 * Locking:
768 * takes tty_ldisc_lock to guard against ldisc races
769 */
770
1da177e4
LT
771void tty_ldisc_put(int disc)
772{
773 struct tty_ldisc *ld;
774 unsigned long flags;
775
56ee4827 776 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
1da177e4
LT
777
778 spin_lock_irqsave(&tty_ldisc_lock, flags);
779 ld = &tty_ldiscs[disc];
56ee4827
ES
780 BUG_ON(ld->refcount == 0);
781 ld->refcount--;
1da177e4
LT
782 module_put(ld->owner);
783 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
784}
785
786EXPORT_SYMBOL_GPL(tty_ldisc_put);
787
af9b897e
AC
788/**
789 * tty_ldisc_assign - set ldisc on a tty
790 * @tty: tty to assign
791 * @ld: line discipline
792 *
793 * Install an instance of a line discipline into a tty structure. The
794 * ldisc must have a reference count above zero to ensure it remains/
795 * The tty instance refcount starts at zero.
796 *
797 * Locking:
798 * Caller must hold references
799 */
800
1da177e4
LT
801static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
802{
803 tty->ldisc = *ld;
804 tty->ldisc.refcount = 0;
805}
806
807/**
808 * tty_ldisc_try - internal helper
809 * @tty: the tty
810 *
811 * Make a single attempt to grab and bump the refcount on
812 * the tty ldisc. Return 0 on failure or 1 on success. This is
813 * used to implement both the waiting and non waiting versions
814 * of tty_ldisc_ref
af9b897e
AC
815 *
816 * Locking: takes tty_ldisc_lock
1da177e4
LT
817 */
818
819static int tty_ldisc_try(struct tty_struct *tty)
820{
821 unsigned long flags;
822 struct tty_ldisc *ld;
823 int ret = 0;
824
825 spin_lock_irqsave(&tty_ldisc_lock, flags);
826 ld = &tty->ldisc;
827 if(test_bit(TTY_LDISC, &tty->flags))
828 {
829 ld->refcount++;
830 ret = 1;
831 }
832 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
833 return ret;
834}
835
836/**
837 * tty_ldisc_ref_wait - wait for the tty ldisc
838 * @tty: tty device
839 *
840 * Dereference the line discipline for the terminal and take a
841 * reference to it. If the line discipline is in flux then
842 * wait patiently until it changes.
843 *
844 * Note: Must not be called from an IRQ/timer context. The caller
845 * must also be careful not to hold other locks that will deadlock
846 * against a discipline change, such as an existing ldisc reference
847 * (which we check for)
af9b897e
AC
848 *
849 * Locking: call functions take tty_ldisc_lock
1da177e4
LT
850 */
851
852struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
853{
854 /* wait_event is a macro */
855 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
856 if(tty->ldisc.refcount == 0)
857 printk(KERN_ERR "tty_ldisc_ref_wait\n");
858 return &tty->ldisc;
859}
860
861EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
862
863/**
864 * tty_ldisc_ref - get the tty ldisc
865 * @tty: tty device
866 *
867 * Dereference the line discipline for the terminal and take a
868 * reference to it. If the line discipline is in flux then
869 * return NULL. Can be called from IRQ and timer functions.
af9b897e
AC
870 *
871 * Locking: called functions take tty_ldisc_lock
1da177e4
LT
872 */
873
874struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
875{
876 if(tty_ldisc_try(tty))
877 return &tty->ldisc;
878 return NULL;
879}
880
881EXPORT_SYMBOL_GPL(tty_ldisc_ref);
882
883/**
884 * tty_ldisc_deref - free a tty ldisc reference
885 * @ld: reference to free up
886 *
887 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
888 * be called in IRQ context.
af9b897e
AC
889 *
890 * Locking: takes tty_ldisc_lock
1da177e4
LT
891 */
892
893void tty_ldisc_deref(struct tty_ldisc *ld)
894{
895 unsigned long flags;
896
56ee4827 897 BUG_ON(ld == NULL);
1da177e4
LT
898
899 spin_lock_irqsave(&tty_ldisc_lock, flags);
900 if(ld->refcount == 0)
901 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
902 else
903 ld->refcount--;
904 if(ld->refcount == 0)
905 wake_up(&tty_ldisc_wait);
906 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
907}
908
909EXPORT_SYMBOL_GPL(tty_ldisc_deref);
910
911/**
912 * tty_ldisc_enable - allow ldisc use
913 * @tty: terminal to activate ldisc on
914 *
915 * Set the TTY_LDISC flag when the line discipline can be called
916 * again. Do neccessary wakeups for existing sleepers.
917 *
918 * Note: nobody should set this bit except via this function. Clearing
919 * directly is allowed.
920 */
921
922static void tty_ldisc_enable(struct tty_struct *tty)
923{
924 set_bit(TTY_LDISC, &tty->flags);
925 wake_up(&tty_ldisc_wait);
926}
927
928/**
929 * tty_set_ldisc - set line discipline
930 * @tty: the terminal to set
931 * @ldisc: the line discipline
932 *
933 * Set the discipline of a tty line. Must be called from a process
934 * context.
af9b897e
AC
935 *
936 * Locking: takes tty_ldisc_lock.
24ec839c 937 * called functions take termios_mutex
1da177e4
LT
938 */
939
940static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
941{
ff55fe20
JB
942 int retval = 0;
943 struct tty_ldisc o_ldisc;
1da177e4
LT
944 char buf[64];
945 int work;
946 unsigned long flags;
947 struct tty_ldisc *ld;
ff55fe20 948 struct tty_struct *o_tty;
1da177e4
LT
949
950 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
951 return -EINVAL;
952
953restart:
954
1da177e4
LT
955 ld = tty_ldisc_get(ldisc);
956 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
957 /* Cyrus Durgin <cider@speakeasy.org> */
958 if (ld == NULL) {
959 request_module("tty-ldisc-%d", ldisc);
960 ld = tty_ldisc_get(ldisc);
961 }
962 if (ld == NULL)
963 return -EINVAL;
964
33f0f88f
AC
965 /*
966 * Problem: What do we do if this blocks ?
967 */
968
1da177e4
LT
969 tty_wait_until_sent(tty, 0);
970
ff55fe20
JB
971 if (tty->ldisc.num == ldisc) {
972 tty_ldisc_put(ldisc);
973 return 0;
974 }
975
ae030e43
PF
976 /*
977 * No more input please, we are switching. The new ldisc
978 * will update this value in the ldisc open function
979 */
980
981 tty->receive_room = 0;
982
ff55fe20
JB
983 o_ldisc = tty->ldisc;
984 o_tty = tty->link;
985
1da177e4
LT
986 /*
987 * Make sure we don't change while someone holds a
988 * reference to the line discipline. The TTY_LDISC bit
989 * prevents anyone taking a reference once it is clear.
990 * We need the lock to avoid racing reference takers.
991 */
ff55fe20 992
1da177e4 993 spin_lock_irqsave(&tty_ldisc_lock, flags);
ff55fe20
JB
994 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
995 if(tty->ldisc.refcount) {
996 /* Free the new ldisc we grabbed. Must drop the lock
997 first. */
998 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
999 tty_ldisc_put(ldisc);
1000 /*
1001 * There are several reasons we may be busy, including
1002 * random momentary I/O traffic. We must therefore
1003 * retry. We could distinguish between blocking ops
1004 * and retries if we made tty_ldisc_wait() smarter. That
1005 * is up for discussion.
1006 */
1007 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
1008 return -ERESTARTSYS;
1009 goto restart;
1010 }
1011 if(o_tty && o_tty->ldisc.refcount) {
1012 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1013 tty_ldisc_put(ldisc);
1014 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
1015 return -ERESTARTSYS;
1016 goto restart;
1017 }
1018 }
1019
1020 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
1021
1022 if (!test_bit(TTY_LDISC, &tty->flags)) {
1da177e4
LT
1023 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1024 tty_ldisc_put(ldisc);
ff55fe20
JB
1025 ld = tty_ldisc_ref_wait(tty);
1026 tty_ldisc_deref(ld);
1da177e4
LT
1027 goto restart;
1028 }
ff55fe20
JB
1029
1030 clear_bit(TTY_LDISC, &tty->flags);
817d6d3b 1031 if (o_tty)
ff55fe20 1032 clear_bit(TTY_LDISC, &o_tty->flags);
1da177e4 1033 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
ff55fe20 1034
1da177e4
LT
1035 /*
1036 * From this point on we know nobody has an ldisc
1037 * usage reference, nor can they obtain one until
1038 * we say so later on.
1039 */
ff55fe20 1040
33f0f88f 1041 work = cancel_delayed_work(&tty->buf.work);
1da177e4 1042 /*
33f0f88f 1043 * Wait for ->hangup_work and ->buf.work handlers to terminate
1da177e4
LT
1044 */
1045
1046 flush_scheduled_work();
1047 /* Shutdown the current discipline. */
1048 if (tty->ldisc.close)
1049 (tty->ldisc.close)(tty);
1050
1051 /* Now set up the new line discipline. */
1052 tty_ldisc_assign(tty, ld);
1053 tty_set_termios_ldisc(tty, ldisc);
1054 if (tty->ldisc.open)
1055 retval = (tty->ldisc.open)(tty);
1056 if (retval < 0) {
1057 tty_ldisc_put(ldisc);
1058 /* There is an outstanding reference here so this is safe */
1059 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1060 tty_set_termios_ldisc(tty, tty->ldisc.num);
1061 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1062 tty_ldisc_put(o_ldisc.num);
1063 /* This driver is always present */
1064 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1065 tty_set_termios_ldisc(tty, N_TTY);
1066 if (tty->ldisc.open) {
1067 int r = tty->ldisc.open(tty);
1068
1069 if (r < 0)
1070 panic("Couldn't open N_TTY ldisc for "
1071 "%s --- error %d.",
1072 tty_name(tty, buf), r);
1073 }
1074 }
1075 }
1076 /* At this point we hold a reference to the new ldisc and a
1077 a reference to the old ldisc. If we ended up flipping back
1078 to the existing ldisc we have two references to it */
1079
1080 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1081 tty->driver->set_ldisc(tty);
1082
1083 tty_ldisc_put(o_ldisc.num);
1084
1085 /*
1086 * Allow ldisc referencing to occur as soon as the driver
1087 * ldisc callback completes.
1088 */
1089
1090 tty_ldisc_enable(tty);
ff55fe20
JB
1091 if (o_tty)
1092 tty_ldisc_enable(o_tty);
1da177e4
LT
1093
1094 /* Restart it in case no characters kick it off. Safe if
1095 already running */
ff55fe20 1096 if (work)
33f0f88f 1097 schedule_delayed_work(&tty->buf.work, 1);
1da177e4
LT
1098 return retval;
1099}
1100
af9b897e
AC
1101/**
1102 * get_tty_driver - find device of a tty
1103 * @dev_t: device identifier
1104 * @index: returns the index of the tty
1105 *
1106 * This routine returns a tty driver structure, given a device number
1107 * and also passes back the index number.
1108 *
1109 * Locking: caller must hold tty_mutex
1da177e4 1110 */
af9b897e 1111
1da177e4
LT
1112static struct tty_driver *get_tty_driver(dev_t device, int *index)
1113{
1114 struct tty_driver *p;
1115
1116 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1117 dev_t base = MKDEV(p->major, p->minor_start);
1118 if (device < base || device >= base + p->num)
1119 continue;
1120 *index = device - base;
1121 return p;
1122 }
1123 return NULL;
1124}
1125
af9b897e
AC
1126/**
1127 * tty_check_change - check for POSIX terminal changes
1128 * @tty: tty to check
1129 *
1130 * If we try to write to, or set the state of, a terminal and we're
1131 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1132 * ignored, go ahead and perform the operation. (POSIX 7.2)
1133 *
1134 * Locking: none
1da177e4 1135 */
af9b897e 1136
1da177e4
LT
1137int tty_check_change(struct tty_struct * tty)
1138{
1139 if (current->signal->tty != tty)
1140 return 0;
ab521dc0
EB
1141 if (!tty->pgrp) {
1142 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
1da177e4
LT
1143 return 0;
1144 }
ab521dc0 1145 if (task_pgrp(current) == tty->pgrp)
1da177e4
LT
1146 return 0;
1147 if (is_ignored(SIGTTOU))
1148 return 0;
3e7cd6c4 1149 if (is_current_pgrp_orphaned())
1da177e4 1150 return -EIO;
040b6362
ON
1151 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
1152 set_thread_flag(TIF_SIGPENDING);
1da177e4
LT
1153 return -ERESTARTSYS;
1154}
1155
1156EXPORT_SYMBOL(tty_check_change);
1157
1158static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1159 size_t count, loff_t *ppos)
1160{
1161 return 0;
1162}
1163
1164static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1165 size_t count, loff_t *ppos)
1166{
1167 return -EIO;
1168}
1169
1170/* No kernel lock held - none needed ;) */
1171static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1172{
1173 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1174}
1175
38ad2ed0
PF
1176static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1177 unsigned int cmd, unsigned long arg)
1178{
1179 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1180}
1181
1182static long hung_up_tty_compat_ioctl(struct file * file,
1183 unsigned int cmd, unsigned long arg)
1da177e4
LT
1184{
1185 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1186}
1187
62322d25 1188static const struct file_operations tty_fops = {
1da177e4
LT
1189 .llseek = no_llseek,
1190 .read = tty_read,
1191 .write = tty_write,
1192 .poll = tty_poll,
1193 .ioctl = tty_ioctl,
e10cc1df 1194 .compat_ioctl = tty_compat_ioctl,
1da177e4
LT
1195 .open = tty_open,
1196 .release = tty_release,
1197 .fasync = tty_fasync,
1198};
1199
1200#ifdef CONFIG_UNIX98_PTYS
62322d25 1201static const struct file_operations ptmx_fops = {
1da177e4
LT
1202 .llseek = no_llseek,
1203 .read = tty_read,
1204 .write = tty_write,
1205 .poll = tty_poll,
1206 .ioctl = tty_ioctl,
e10cc1df 1207 .compat_ioctl = tty_compat_ioctl,
1da177e4
LT
1208 .open = ptmx_open,
1209 .release = tty_release,
1210 .fasync = tty_fasync,
1211};
1212#endif
1213
62322d25 1214static const struct file_operations console_fops = {
1da177e4
LT
1215 .llseek = no_llseek,
1216 .read = tty_read,
1217 .write = redirected_tty_write,
1218 .poll = tty_poll,
1219 .ioctl = tty_ioctl,
e10cc1df 1220 .compat_ioctl = tty_compat_ioctl,
1da177e4
LT
1221 .open = tty_open,
1222 .release = tty_release,
1223 .fasync = tty_fasync,
1224};
1225
62322d25 1226static const struct file_operations hung_up_tty_fops = {
1da177e4
LT
1227 .llseek = no_llseek,
1228 .read = hung_up_tty_read,
1229 .write = hung_up_tty_write,
1230 .poll = hung_up_tty_poll,
38ad2ed0
PF
1231 .ioctl = hung_up_tty_ioctl,
1232 .compat_ioctl = hung_up_tty_compat_ioctl,
1da177e4
LT
1233 .release = tty_release,
1234};
1235
1236static DEFINE_SPINLOCK(redirect_lock);
1237static struct file *redirect;
1238
1239/**
1240 * tty_wakeup - request more data
1241 * @tty: terminal
1242 *
1243 * Internal and external helper for wakeups of tty. This function
1244 * informs the line discipline if present that the driver is ready
1245 * to receive more output data.
1246 */
1247
1248void tty_wakeup(struct tty_struct *tty)
1249{
1250 struct tty_ldisc *ld;
1251
1252 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1253 ld = tty_ldisc_ref(tty);
1254 if(ld) {
1255 if(ld->write_wakeup)
1256 ld->write_wakeup(tty);
1257 tty_ldisc_deref(ld);
1258 }
1259 }
1260 wake_up_interruptible(&tty->write_wait);
1261}
1262
1263EXPORT_SYMBOL_GPL(tty_wakeup);
1264
1265/**
1266 * tty_ldisc_flush - flush line discipline queue
1267 * @tty: tty
1268 *
1269 * Flush the line discipline queue (if any) for this tty. If there
1270 * is no line discipline active this is a no-op.
1271 */
1272
1273void tty_ldisc_flush(struct tty_struct *tty)
1274{
1275 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1276 if(ld) {
1277 if(ld->flush_buffer)
1278 ld->flush_buffer(tty);
1279 tty_ldisc_deref(ld);
1280 }
c5c34d48 1281 tty_buffer_flush(tty);
1da177e4
LT
1282}
1283
1284EXPORT_SYMBOL_GPL(tty_ldisc_flush);
edc6afc5
AC
1285
1286/**
1287 * tty_reset_termios - reset terminal state
1288 * @tty: tty to reset
1289 *
1290 * Restore a terminal to the driver default state
1291 */
1292
1293static void tty_reset_termios(struct tty_struct *tty)
1294{
1295 mutex_lock(&tty->termios_mutex);
1296 *tty->termios = tty->driver->init_termios;
1297 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1298 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1299 mutex_unlock(&tty->termios_mutex);
1300}
1da177e4 1301
af9b897e
AC
1302/**
1303 * do_tty_hangup - actual handler for hangup events
65f27f38 1304 * @work: tty device
af9b897e
AC
1305 *
1306 * This can be called by the "eventd" kernel thread. That is process
1307 * synchronous but doesn't hold any locks, so we need to make sure we
1308 * have the appropriate locks for what we're doing.
1309 *
1310 * The hangup event clears any pending redirections onto the hung up
1311 * device. It ensures future writes will error and it does the needed
1312 * line discipline hangup and signal delivery. The tty object itself
1313 * remains intact.
1314 *
1315 * Locking:
1316 * BKL
24ec839c
PZ
1317 * redirect lock for undoing redirection
1318 * file list lock for manipulating list of ttys
1319 * tty_ldisc_lock from called functions
1320 * termios_mutex resetting termios data
1321 * tasklist_lock to walk task list for hangup event
1322 * ->siglock to protect ->signal/->sighand
1da177e4 1323 */
65f27f38 1324static void do_tty_hangup(struct work_struct *work)
1da177e4 1325{
65f27f38
DH
1326 struct tty_struct *tty =
1327 container_of(work, struct tty_struct, hangup_work);
1da177e4
LT
1328 struct file * cons_filp = NULL;
1329 struct file *filp, *f = NULL;
1330 struct task_struct *p;
1331 struct tty_ldisc *ld;
1332 int closecount = 0, n;
1333
1334 if (!tty)
1335 return;
1336
1337 /* inuse_filps is protected by the single kernel lock */
1338 lock_kernel();
1339
1340 spin_lock(&redirect_lock);
1341 if (redirect && redirect->private_data == tty) {
1342 f = redirect;
1343 redirect = NULL;
1344 }
1345 spin_unlock(&redirect_lock);
1346
1347 check_tty_count(tty, "do_tty_hangup");
1348 file_list_lock();
1349 /* This breaks for file handles being sent over AF_UNIX sockets ? */
2f512016 1350 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1da177e4
LT
1351 if (filp->f_op->write == redirected_tty_write)
1352 cons_filp = filp;
1353 if (filp->f_op->write != tty_write)
1354 continue;
1355 closecount++;
1356 tty_fasync(-1, filp, 0); /* can't block */
1357 filp->f_op = &hung_up_tty_fops;
1358 }
1359 file_list_unlock();
1360
1361 /* FIXME! What are the locking issues here? This may me overdoing things..
1362 * this question is especially important now that we've removed the irqlock. */
1363
1364 ld = tty_ldisc_ref(tty);
1365 if(ld != NULL) /* We may have no line discipline at this point */
1366 {
1367 if (ld->flush_buffer)
1368 ld->flush_buffer(tty);
1369 if (tty->driver->flush_buffer)
1370 tty->driver->flush_buffer(tty);
1371 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1372 ld->write_wakeup)
1373 ld->write_wakeup(tty);
1374 if (ld->hangup)
1375 ld->hangup(tty);
1376 }
1377
1378 /* FIXME: Once we trust the LDISC code better we can wait here for
1379 ldisc completion and fix the driver call race */
1380
1381 wake_up_interruptible(&tty->write_wait);
1382 wake_up_interruptible(&tty->read_wait);
1383
1384 /*
1385 * Shutdown the current line discipline, and reset it to
1386 * N_TTY.
1387 */
1388 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
edc6afc5 1389 tty_reset_termios(tty);
1da177e4
LT
1390
1391 /* Defer ldisc switch */
1392 /* tty_deferred_ldisc_switch(N_TTY);
1393
1394 This should get done automatically when the port closes and
1395 tty_release is called */
1396
1397 read_lock(&tasklist_lock);
ab521dc0
EB
1398 if (tty->session) {
1399 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
24ec839c 1400 spin_lock_irq(&p->sighand->siglock);
1da177e4
LT
1401 if (p->signal->tty == tty)
1402 p->signal->tty = NULL;
24ec839c
PZ
1403 if (!p->signal->leader) {
1404 spin_unlock_irq(&p->sighand->siglock);
1da177e4 1405 continue;
24ec839c
PZ
1406 }
1407 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1408 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
ab521dc0
EB
1409 put_pid(p->signal->tty_old_pgrp); /* A noop */
1410 if (tty->pgrp)
1411 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
24ec839c 1412 spin_unlock_irq(&p->sighand->siglock);
ab521dc0 1413 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
1da177e4
LT
1414 }
1415 read_unlock(&tasklist_lock);
1416
1417 tty->flags = 0;
d9c1e9a8
EB
1418 put_pid(tty->session);
1419 put_pid(tty->pgrp);
ab521dc0
EB
1420 tty->session = NULL;
1421 tty->pgrp = NULL;
1da177e4
LT
1422 tty->ctrl_status = 0;
1423 /*
1424 * If one of the devices matches a console pointer, we
1425 * cannot just call hangup() because that will cause
1426 * tty->count and state->count to go out of sync.
1427 * So we just call close() the right number of times.
1428 */
1429 if (cons_filp) {
1430 if (tty->driver->close)
1431 for (n = 0; n < closecount; n++)
1432 tty->driver->close(tty, cons_filp);
1433 } else if (tty->driver->hangup)
1434 (tty->driver->hangup)(tty);
1435
1436 /* We don't want to have driver/ldisc interactions beyond
1437 the ones we did here. The driver layer expects no
1438 calls after ->hangup() from the ldisc side. However we
1439 can't yet guarantee all that */
1440
1441 set_bit(TTY_HUPPED, &tty->flags);
1442 if (ld) {
1443 tty_ldisc_enable(tty);
1444 tty_ldisc_deref(ld);
1445 }
1446 unlock_kernel();
1447 if (f)
1448 fput(f);
1449}
1450
af9b897e
AC
1451/**
1452 * tty_hangup - trigger a hangup event
1453 * @tty: tty to hangup
1454 *
1455 * A carrier loss (virtual or otherwise) has occurred on this like
1456 * schedule a hangup sequence to run after this event.
1457 */
1458
1da177e4
LT
1459void tty_hangup(struct tty_struct * tty)
1460{
1461#ifdef TTY_DEBUG_HANGUP
1462 char buf[64];
1463
1464 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1465#endif
1466 schedule_work(&tty->hangup_work);
1467}
1468
1469EXPORT_SYMBOL(tty_hangup);
1470
af9b897e
AC
1471/**
1472 * tty_vhangup - process vhangup
1473 * @tty: tty to hangup
1474 *
1475 * The user has asked via system call for the terminal to be hung up.
1476 * We do this synchronously so that when the syscall returns the process
1477 * is complete. That guarantee is neccessary for security reasons.
1478 */
1479
1da177e4
LT
1480void tty_vhangup(struct tty_struct * tty)
1481{
1482#ifdef TTY_DEBUG_HANGUP
1483 char buf[64];
1484
1485 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1486#endif
65f27f38 1487 do_tty_hangup(&tty->hangup_work);
1da177e4
LT
1488}
1489EXPORT_SYMBOL(tty_vhangup);
1490
af9b897e
AC
1491/**
1492 * tty_hung_up_p - was tty hung up
1493 * @filp: file pointer of tty
1494 *
1495 * Return true if the tty has been subject to a vhangup or a carrier
1496 * loss
1497 */
1498
1da177e4
LT
1499int tty_hung_up_p(struct file * filp)
1500{
1501 return (filp->f_op == &hung_up_tty_fops);
1502}
1503
1504EXPORT_SYMBOL(tty_hung_up_p);
1505
ab521dc0 1506static void session_clear_tty(struct pid *session)
24ec839c
PZ
1507{
1508 struct task_struct *p;
ab521dc0 1509 do_each_pid_task(session, PIDTYPE_SID, p) {
24ec839c 1510 proc_clear_tty(p);
ab521dc0 1511 } while_each_pid_task(session, PIDTYPE_SID, p);
24ec839c
PZ
1512}
1513
af9b897e
AC
1514/**
1515 * disassociate_ctty - disconnect controlling tty
1516 * @on_exit: true if exiting so need to "hang up" the session
1da177e4 1517 *
af9b897e
AC
1518 * This function is typically called only by the session leader, when
1519 * it wants to disassociate itself from its controlling tty.
1520 *
1521 * It performs the following functions:
1da177e4
LT
1522 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1523 * (2) Clears the tty from being controlling the session
1524 * (3) Clears the controlling tty for all processes in the
1525 * session group.
1526 *
af9b897e
AC
1527 * The argument on_exit is set to 1 if called when a process is
1528 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1529 *
24ec839c 1530 * Locking:
af9b897e 1531 * BKL is taken for hysterical raisins
24ec839c
PZ
1532 * tty_mutex is taken to protect tty
1533 * ->siglock is taken to protect ->signal/->sighand
1534 * tasklist_lock is taken to walk process list for sessions
1535 * ->siglock is taken to protect ->signal/->sighand
1da177e4 1536 */
af9b897e 1537
1da177e4
LT
1538void disassociate_ctty(int on_exit)
1539{
1540 struct tty_struct *tty;
ab521dc0 1541 struct pid *tty_pgrp = NULL;
1da177e4
LT
1542
1543 lock_kernel();
1544
70522e12 1545 mutex_lock(&tty_mutex);
24ec839c 1546 tty = get_current_tty();
1da177e4 1547 if (tty) {
ab521dc0 1548 tty_pgrp = get_pid(tty->pgrp);
70522e12 1549 mutex_unlock(&tty_mutex);
24ec839c 1550 /* XXX: here we race, there is nothing protecting tty */
1da177e4
LT
1551 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1552 tty_vhangup(tty);
680a9671 1553 } else if (on_exit) {
ab521dc0 1554 struct pid *old_pgrp;
680a9671
EB
1555 spin_lock_irq(&current->sighand->siglock);
1556 old_pgrp = current->signal->tty_old_pgrp;
ab521dc0 1557 current->signal->tty_old_pgrp = NULL;
680a9671 1558 spin_unlock_irq(&current->sighand->siglock);
24ec839c 1559 if (old_pgrp) {
ab521dc0
EB
1560 kill_pgrp(old_pgrp, SIGHUP, on_exit);
1561 kill_pgrp(old_pgrp, SIGCONT, on_exit);
1562 put_pid(old_pgrp);
1da177e4 1563 }
70522e12 1564 mutex_unlock(&tty_mutex);
1da177e4
LT
1565 unlock_kernel();
1566 return;
1567 }
ab521dc0
EB
1568 if (tty_pgrp) {
1569 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
1da177e4 1570 if (!on_exit)
ab521dc0
EB
1571 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
1572 put_pid(tty_pgrp);
1da177e4
LT
1573 }
1574
24ec839c 1575 spin_lock_irq(&current->sighand->siglock);
2a65f1d9 1576 put_pid(current->signal->tty_old_pgrp);
23cac8de 1577 current->signal->tty_old_pgrp = NULL;
24ec839c
PZ
1578 spin_unlock_irq(&current->sighand->siglock);
1579
1580 mutex_lock(&tty_mutex);
1581 /* It is possible that do_tty_hangup has free'd this tty */
1582 tty = get_current_tty();
1583 if (tty) {
ab521dc0
EB
1584 put_pid(tty->session);
1585 put_pid(tty->pgrp);
1586 tty->session = NULL;
1587 tty->pgrp = NULL;
24ec839c
PZ
1588 } else {
1589#ifdef TTY_DEBUG_HANGUP
1590 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
1591 " = NULL", tty);
1592#endif
1593 }
1594 mutex_unlock(&tty_mutex);
1da177e4
LT
1595
1596 /* Now clear signal->tty under the lock */
1597 read_lock(&tasklist_lock);
ab521dc0 1598 session_clear_tty(task_session(current));
1da177e4 1599 read_unlock(&tasklist_lock);
1da177e4
LT
1600 unlock_kernel();
1601}
1602
98a27ba4
EB
1603/**
1604 *
1605 * no_tty - Ensure the current process does not have a controlling tty
1606 */
1607void no_tty(void)
1608{
1609 struct task_struct *tsk = current;
1610 if (tsk->signal->leader)
1611 disassociate_ctty(0);
1612 proc_clear_tty(tsk);
1613}
1614
af9b897e
AC
1615
1616/**
beb7dd86 1617 * stop_tty - propagate flow control
af9b897e
AC
1618 * @tty: tty to stop
1619 *
1620 * Perform flow control to the driver. For PTY/TTY pairs we
beb7dd86 1621 * must also propagate the TIOCKPKT status. May be called
af9b897e
AC
1622 * on an already stopped device and will not re-call the driver
1623 * method.
1624 *
1625 * This functionality is used by both the line disciplines for
1626 * halting incoming flow and by the driver. It may therefore be
1627 * called from any context, may be under the tty atomic_write_lock
1628 * but not always.
1629 *
1630 * Locking:
1631 * Broken. Relies on BKL which is unsafe here.
1632 */
1633
1da177e4
LT
1634void stop_tty(struct tty_struct *tty)
1635{
1636 if (tty->stopped)
1637 return;
1638 tty->stopped = 1;
1639 if (tty->link && tty->link->packet) {
1640 tty->ctrl_status &= ~TIOCPKT_START;
1641 tty->ctrl_status |= TIOCPKT_STOP;
1642 wake_up_interruptible(&tty->link->read_wait);
1643 }
1644 if (tty->driver->stop)
1645 (tty->driver->stop)(tty);
1646}
1647
1648EXPORT_SYMBOL(stop_tty);
1649
af9b897e 1650/**
beb7dd86 1651 * start_tty - propagate flow control
af9b897e
AC
1652 * @tty: tty to start
1653 *
1654 * Start a tty that has been stopped if at all possible. Perform
beb7dd86 1655 * any neccessary wakeups and propagate the TIOCPKT status. If this
af9b897e
AC
1656 * is the tty was previous stopped and is being started then the
1657 * driver start method is invoked and the line discipline woken.
1658 *
1659 * Locking:
1660 * Broken. Relies on BKL which is unsafe here.
1661 */
1662
1da177e4
LT
1663void start_tty(struct tty_struct *tty)
1664{
1665 if (!tty->stopped || tty->flow_stopped)
1666 return;
1667 tty->stopped = 0;
1668 if (tty->link && tty->link->packet) {
1669 tty->ctrl_status &= ~TIOCPKT_STOP;
1670 tty->ctrl_status |= TIOCPKT_START;
1671 wake_up_interruptible(&tty->link->read_wait);
1672 }
1673 if (tty->driver->start)
1674 (tty->driver->start)(tty);
1675
1676 /* If we have a running line discipline it may need kicking */
1677 tty_wakeup(tty);
1da177e4
LT
1678}
1679
1680EXPORT_SYMBOL(start_tty);
1681
af9b897e
AC
1682/**
1683 * tty_read - read method for tty device files
1684 * @file: pointer to tty file
1685 * @buf: user buffer
1686 * @count: size of user buffer
1687 * @ppos: unused
1688 *
1689 * Perform the read system call function on this terminal device. Checks
1690 * for hung up devices before calling the line discipline method.
1691 *
1692 * Locking:
1693 * Locks the line discipline internally while needed
1694 * For historical reasons the line discipline read method is
1695 * invoked under the BKL. This will go away in time so do not rely on it
1696 * in new code. Multiple read calls may be outstanding in parallel.
1697 */
1698
1da177e4
LT
1699static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1700 loff_t *ppos)
1701{
1702 int i;
1703 struct tty_struct * tty;
1704 struct inode *inode;
1705 struct tty_ldisc *ld;
1706
1707 tty = (struct tty_struct *)file->private_data;
a7113a96 1708 inode = file->f_path.dentry->d_inode;
1da177e4
LT
1709 if (tty_paranoia_check(tty, inode, "tty_read"))
1710 return -EIO;
1711 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1712 return -EIO;
1713
1714 /* We want to wait for the line discipline to sort out in this
1715 situation */
1716 ld = tty_ldisc_ref_wait(tty);
1717 lock_kernel();
1718 if (ld->read)
1719 i = (ld->read)(tty,file,buf,count);
1720 else
1721 i = -EIO;
1722 tty_ldisc_deref(ld);
1723 unlock_kernel();
1724 if (i > 0)
1725 inode->i_atime = current_fs_time(inode->i_sb);
1726 return i;
1727}
1728
1729/*
1730 * Split writes up in sane blocksizes to avoid
1731 * denial-of-service type attacks
1732 */
1733static inline ssize_t do_tty_write(
1734 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1735 struct tty_struct *tty,
1736 struct file *file,
1737 const char __user *buf,
1738 size_t count)
1739{
1740 ssize_t ret = 0, written = 0;
1741 unsigned int chunk;
1742
af9b897e 1743 /* FIXME: O_NDELAY ... */
70522e12 1744 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
1da177e4
LT
1745 return -ERESTARTSYS;
1746 }
1747
1748 /*
1749 * We chunk up writes into a temporary buffer. This
1750 * simplifies low-level drivers immensely, since they
1751 * don't have locking issues and user mode accesses.
1752 *
1753 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1754 * big chunk-size..
1755 *
1756 * The default chunk-size is 2kB, because the NTTY
1757 * layer has problems with bigger chunks. It will
1758 * claim to be able to handle more characters than
1759 * it actually does.
af9b897e
AC
1760 *
1761 * FIXME: This can probably go away now except that 64K chunks
1762 * are too likely to fail unless switched to vmalloc...
1da177e4
LT
1763 */
1764 chunk = 2048;
1765 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1766 chunk = 65536;
1767 if (count < chunk)
1768 chunk = count;
1769
70522e12 1770 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1da177e4
LT
1771 if (tty->write_cnt < chunk) {
1772 unsigned char *buf;
1773
1774 if (chunk < 1024)
1775 chunk = 1024;
1776
1777 buf = kmalloc(chunk, GFP_KERNEL);
1778 if (!buf) {
70522e12 1779 mutex_unlock(&tty->atomic_write_lock);
1da177e4
LT
1780 return -ENOMEM;
1781 }
1782 kfree(tty->write_buf);
1783 tty->write_cnt = chunk;
1784 tty->write_buf = buf;
1785 }
1786
1787 /* Do the write .. */
1788 for (;;) {
1789 size_t size = count;
1790 if (size > chunk)
1791 size = chunk;
1792 ret = -EFAULT;
1793 if (copy_from_user(tty->write_buf, buf, size))
1794 break;
1795 lock_kernel();
1796 ret = write(tty, file, tty->write_buf, size);
1797 unlock_kernel();
1798 if (ret <= 0)
1799 break;
1800 written += ret;
1801 buf += ret;
1802 count -= ret;
1803 if (!count)
1804 break;
1805 ret = -ERESTARTSYS;
1806 if (signal_pending(current))
1807 break;
1808 cond_resched();
1809 }
1810 if (written) {
a7113a96 1811 struct inode *inode = file->f_path.dentry->d_inode;
1da177e4
LT
1812 inode->i_mtime = current_fs_time(inode->i_sb);
1813 ret = written;
1814 }
70522e12 1815 mutex_unlock(&tty->atomic_write_lock);
1da177e4
LT
1816 return ret;
1817}
1818
1819
af9b897e
AC
1820/**
1821 * tty_write - write method for tty device file
1822 * @file: tty file pointer
1823 * @buf: user data to write
1824 * @count: bytes to write
1825 * @ppos: unused
1826 *
1827 * Write data to a tty device via the line discipline.
1828 *
1829 * Locking:
1830 * Locks the line discipline as required
1831 * Writes to the tty driver are serialized by the atomic_write_lock
1832 * and are then processed in chunks to the device. The line discipline
1833 * write method will not be involked in parallel for each device
1834 * The line discipline write method is called under the big
1835 * kernel lock for historical reasons. New code should not rely on this.
1836 */
1837
1da177e4
LT
1838static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1839 loff_t *ppos)
1840{
1841 struct tty_struct * tty;
a7113a96 1842 struct inode *inode = file->f_path.dentry->d_inode;
1da177e4
LT
1843 ssize_t ret;
1844 struct tty_ldisc *ld;
1845
1846 tty = (struct tty_struct *)file->private_data;
1847 if (tty_paranoia_check(tty, inode, "tty_write"))
1848 return -EIO;
1849 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1850 return -EIO;
1851
1852 ld = tty_ldisc_ref_wait(tty);
1853 if (!ld->write)
1854 ret = -EIO;
1855 else
1856 ret = do_tty_write(ld->write, tty, file, buf, count);
1857 tty_ldisc_deref(ld);
1858 return ret;
1859}
1860
1861ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1862 loff_t *ppos)
1863{
1864 struct file *p = NULL;
1865
1866 spin_lock(&redirect_lock);
1867 if (redirect) {
1868 get_file(redirect);
1869 p = redirect;
1870 }
1871 spin_unlock(&redirect_lock);
1872
1873 if (p) {
1874 ssize_t res;
1875 res = vfs_write(p, buf, count, &p->f_pos);
1876 fput(p);
1877 return res;
1878 }
1879
1880 return tty_write(file, buf, count, ppos);
1881}
1882
1883static char ptychar[] = "pqrstuvwxyzabcde";
1884
af9b897e
AC
1885/**
1886 * pty_line_name - generate name for a pty
1887 * @driver: the tty driver in use
1888 * @index: the minor number
1889 * @p: output buffer of at least 6 bytes
1890 *
1891 * Generate a name from a driver reference and write it to the output
1892 * buffer.
1893 *
1894 * Locking: None
1895 */
1896static void pty_line_name(struct tty_driver *driver, int index, char *p)
1da177e4
LT
1897{
1898 int i = index + driver->name_base;
1899 /* ->name is initialized to "ttyp", but "tty" is expected */
1900 sprintf(p, "%s%c%x",
1901 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1902 ptychar[i >> 4 & 0xf], i & 0xf);
1903}
1904
af9b897e
AC
1905/**
1906 * pty_line_name - generate name for a tty
1907 * @driver: the tty driver in use
1908 * @index: the minor number
1909 * @p: output buffer of at least 7 bytes
1910 *
1911 * Generate a name from a driver reference and write it to the output
1912 * buffer.
1913 *
1914 * Locking: None
1915 */
1916static void tty_line_name(struct tty_driver *driver, int index, char *p)
1da177e4
LT
1917{
1918 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1919}
1920
af9b897e
AC
1921/**
1922 * init_dev - initialise a tty device
1923 * @driver: tty driver we are opening a device on
1924 * @idx: device index
1925 * @tty: returned tty structure
1926 *
1927 * Prepare a tty device. This may not be a "new" clean device but
1928 * could also be an active device. The pty drivers require special
1929 * handling because of this.
1930 *
1931 * Locking:
1932 * The function is called under the tty_mutex, which
1933 * protects us from the tty struct or driver itself going away.
1934 *
1935 * On exit the tty device has the line discipline attached and
1936 * a reference count of 1. If a pair was created for pty/tty use
1937 * and the other was a pty master then it too has a reference count of 1.
1938 *
1da177e4 1939 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
70522e12
IM
1940 * failed open. The new code protects the open with a mutex, so it's
1941 * really quite straightforward. The mutex locking can probably be
1da177e4
LT
1942 * relaxed for the (most common) case of reopening a tty.
1943 */
af9b897e 1944
1da177e4
LT
1945static int init_dev(struct tty_driver *driver, int idx,
1946 struct tty_struct **ret_tty)
1947{
1948 struct tty_struct *tty, *o_tty;
edc6afc5
AC
1949 struct ktermios *tp, **tp_loc, *o_tp, **o_tp_loc;
1950 struct ktermios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
af9b897e 1951 int retval = 0;
1da177e4
LT
1952
1953 /* check whether we're reopening an existing tty */
1954 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1955 tty = devpts_get_tty(idx);
5a39e8c6
ASRF
1956 /*
1957 * If we don't have a tty here on a slave open, it's because
1958 * the master already started the close process and there's
1959 * no relation between devpts file and tty anymore.
1960 */
1961 if (!tty && driver->subtype == PTY_TYPE_SLAVE) {
1962 retval = -EIO;
1963 goto end_init;
1964 }
1965 /*
1966 * It's safe from now on because init_dev() is called with
1967 * tty_mutex held and release_dev() won't change tty->count
1968 * or tty->flags without having to grab tty_mutex
1969 */
1da177e4
LT
1970 if (tty && driver->subtype == PTY_TYPE_MASTER)
1971 tty = tty->link;
1972 } else {
1973 tty = driver->ttys[idx];
1974 }
1975 if (tty) goto fast_track;
1976
1977 /*
1978 * First time open is complex, especially for PTY devices.
1979 * This code guarantees that either everything succeeds and the
1980 * TTY is ready for operation, or else the table slots are vacated
1981 * and the allocated memory released. (Except that the termios
1982 * and locked termios may be retained.)
1983 */
1984
1985 if (!try_module_get(driver->owner)) {
1986 retval = -ENODEV;
1987 goto end_init;
1988 }
1989
1990 o_tty = NULL;
1991 tp = o_tp = NULL;
1992 ltp = o_ltp = NULL;
1993
1994 tty = alloc_tty_struct();
1995 if(!tty)
1996 goto fail_no_mem;
1997 initialize_tty_struct(tty);
1998 tty->driver = driver;
1999 tty->index = idx;
2000 tty_line_name(driver, idx, tty->name);
2001
2002 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
2003 tp_loc = &tty->termios;
2004 ltp_loc = &tty->termios_locked;
2005 } else {
2006 tp_loc = &driver->termios[idx];
2007 ltp_loc = &driver->termios_locked[idx];
2008 }
2009
2010 if (!*tp_loc) {
edc6afc5 2011 tp = (struct ktermios *) kmalloc(sizeof(struct ktermios),
1da177e4
LT
2012 GFP_KERNEL);
2013 if (!tp)
2014 goto free_mem_out;
2015 *tp = driver->init_termios;
2016 }
2017
2018 if (!*ltp_loc) {
edc6afc5 2019 ltp = (struct ktermios *) kmalloc(sizeof(struct ktermios),
1da177e4
LT
2020 GFP_KERNEL);
2021 if (!ltp)
2022 goto free_mem_out;
edc6afc5 2023 memset(ltp, 0, sizeof(struct ktermios));
1da177e4
LT
2024 }
2025
2026 if (driver->type == TTY_DRIVER_TYPE_PTY) {
2027 o_tty = alloc_tty_struct();
2028 if (!o_tty)
2029 goto free_mem_out;
2030 initialize_tty_struct(o_tty);
2031 o_tty->driver = driver->other;
2032 o_tty->index = idx;
2033 tty_line_name(driver->other, idx, o_tty->name);
2034
2035 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
2036 o_tp_loc = &o_tty->termios;
2037 o_ltp_loc = &o_tty->termios_locked;
2038 } else {
2039 o_tp_loc = &driver->other->termios[idx];
2040 o_ltp_loc = &driver->other->termios_locked[idx];
2041 }
2042
2043 if (!*o_tp_loc) {
edc6afc5
AC
2044 o_tp = (struct ktermios *)
2045 kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1da177e4
LT
2046 if (!o_tp)
2047 goto free_mem_out;
2048 *o_tp = driver->other->init_termios;
2049 }
2050
2051 if (!*o_ltp_loc) {
edc6afc5
AC
2052 o_ltp = (struct ktermios *)
2053 kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1da177e4
LT
2054 if (!o_ltp)
2055 goto free_mem_out;
edc6afc5 2056 memset(o_ltp, 0, sizeof(struct ktermios));
1da177e4
LT
2057 }
2058
2059 /*
2060 * Everything allocated ... set up the o_tty structure.
2061 */
2062 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
2063 driver->other->ttys[idx] = o_tty;
2064 }
2065 if (!*o_tp_loc)
2066 *o_tp_loc = o_tp;
2067 if (!*o_ltp_loc)
2068 *o_ltp_loc = o_ltp;
2069 o_tty->termios = *o_tp_loc;
2070 o_tty->termios_locked = *o_ltp_loc;
2071 driver->other->refcount++;
2072 if (driver->subtype == PTY_TYPE_MASTER)
2073 o_tty->count++;
2074
2075 /* Establish the links in both directions */
2076 tty->link = o_tty;
2077 o_tty->link = tty;
2078 }
2079
2080 /*
2081 * All structures have been allocated, so now we install them.
d5698c28 2082 * Failures after this point use release_tty to clean up, so
1da177e4
LT
2083 * there's no need to null out the local pointers.
2084 */
2085 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2086 driver->ttys[idx] = tty;
2087 }
2088
2089 if (!*tp_loc)
2090 *tp_loc = tp;
2091 if (!*ltp_loc)
2092 *ltp_loc = ltp;
2093 tty->termios = *tp_loc;
2094 tty->termios_locked = *ltp_loc;
edc6afc5
AC
2095 /* Compatibility until drivers always set this */
2096 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
2097 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1da177e4
LT
2098 driver->refcount++;
2099 tty->count++;
2100
2101 /*
2102 * Structures all installed ... call the ldisc open routines.
d5698c28
CH
2103 * If we fail here just call release_tty to clean up. No need
2104 * to decrement the use counts, as release_tty doesn't care.
1da177e4
LT
2105 */
2106
2107 if (tty->ldisc.open) {
2108 retval = (tty->ldisc.open)(tty);
2109 if (retval)
2110 goto release_mem_out;
2111 }
2112 if (o_tty && o_tty->ldisc.open) {
2113 retval = (o_tty->ldisc.open)(o_tty);
2114 if (retval) {
2115 if (tty->ldisc.close)
2116 (tty->ldisc.close)(tty);
2117 goto release_mem_out;
2118 }
2119 tty_ldisc_enable(o_tty);
2120 }
2121 tty_ldisc_enable(tty);
2122 goto success;
2123
2124 /*
2125 * This fast open can be used if the tty is already open.
2126 * No memory is allocated, and the only failures are from
2127 * attempting to open a closing tty or attempting multiple
2128 * opens on a pty master.
2129 */
2130fast_track:
2131 if (test_bit(TTY_CLOSING, &tty->flags)) {
2132 retval = -EIO;
2133 goto end_init;
2134 }
2135 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2136 driver->subtype == PTY_TYPE_MASTER) {
2137 /*
2138 * special case for PTY masters: only one open permitted,
2139 * and the slave side open count is incremented as well.
2140 */
2141 if (tty->count) {
2142 retval = -EIO;
2143 goto end_init;
2144 }
2145 tty->link->count++;
2146 }
2147 tty->count++;
2148 tty->driver = driver; /* N.B. why do this every time?? */
2149
2150 /* FIXME */
2151 if(!test_bit(TTY_LDISC, &tty->flags))
2152 printk(KERN_ERR "init_dev but no ldisc\n");
2153success:
2154 *ret_tty = tty;
2155
70522e12 2156 /* All paths come through here to release the mutex */
1da177e4
LT
2157end_init:
2158 return retval;
2159
2160 /* Release locally allocated memory ... nothing placed in slots */
2161free_mem_out:
735d5661 2162 kfree(o_tp);
1da177e4
LT
2163 if (o_tty)
2164 free_tty_struct(o_tty);
735d5661
JJ
2165 kfree(ltp);
2166 kfree(tp);
1da177e4
LT
2167 free_tty_struct(tty);
2168
2169fail_no_mem:
2170 module_put(driver->owner);
2171 retval = -ENOMEM;
2172 goto end_init;
2173
d5698c28 2174 /* call the tty release_tty routine to clean out this slot */
1da177e4 2175release_mem_out:
4050914f
AM
2176 if (printk_ratelimit())
2177 printk(KERN_INFO "init_dev: ldisc open failed, "
2178 "clearing slot %d\n", idx);
d5698c28 2179 release_tty(tty, idx);
1da177e4
LT
2180 goto end_init;
2181}
2182
af9b897e 2183/**
d5698c28 2184 * release_one_tty - release tty structure memory
af9b897e
AC
2185 *
2186 * Releases memory associated with a tty structure, and clears out the
2187 * driver table slots. This function is called when a device is no longer
2188 * in use. It also gets called when setup of a device fails.
2189 *
2190 * Locking:
2191 * tty_mutex - sometimes only
2192 * takes the file list lock internally when working on the list
2193 * of ttys that the driver keeps.
2194 * FIXME: should we require tty_mutex is held here ??
1da177e4 2195 */
d5698c28 2196static void release_one_tty(struct tty_struct *tty, int idx)
1da177e4 2197{
1da177e4 2198 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
d5698c28 2199 struct ktermios *tp;
1da177e4
LT
2200
2201 if (!devpts)
2202 tty->driver->ttys[idx] = NULL;
d5698c28 2203
1da177e4
LT
2204 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2205 tp = tty->termios;
2206 if (!devpts)
2207 tty->driver->termios[idx] = NULL;
2208 kfree(tp);
2209
2210 tp = tty->termios_locked;
2211 if (!devpts)
2212 tty->driver->termios_locked[idx] = NULL;
2213 kfree(tp);
2214 }
2215
d5698c28 2216
1da177e4
LT
2217 tty->magic = 0;
2218 tty->driver->refcount--;
d5698c28 2219
1da177e4
LT
2220 file_list_lock();
2221 list_del_init(&tty->tty_files);
2222 file_list_unlock();
d5698c28 2223
1da177e4
LT
2224 free_tty_struct(tty);
2225}
2226
d5698c28
CH
2227/**
2228 * release_tty - release tty structure memory
2229 *
2230 * Release both @tty and a possible linked partner (think pty pair),
2231 * and decrement the refcount of the backing module.
2232 *
2233 * Locking:
2234 * tty_mutex - sometimes only
2235 * takes the file list lock internally when working on the list
2236 * of ttys that the driver keeps.
2237 * FIXME: should we require tty_mutex is held here ??
2238 */
2239static void release_tty(struct tty_struct *tty, int idx)
2240{
2241 struct tty_driver *driver = tty->driver;
2242
2243 if (tty->link)
2244 release_one_tty(tty->link, idx);
2245 release_one_tty(tty, idx);
2246 module_put(driver->owner);
2247}
2248
1da177e4
LT
2249/*
2250 * Even releasing the tty structures is a tricky business.. We have
2251 * to be very careful that the structures are all released at the
2252 * same time, as interrupts might otherwise get the wrong pointers.
2253 *
2254 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2255 * lead to double frees or releasing memory still in use.
2256 */
2257static void release_dev(struct file * filp)
2258{
2259 struct tty_struct *tty, *o_tty;
2260 int pty_master, tty_closing, o_tty_closing, do_sleep;
14a6283e 2261 int devpts;
1da177e4
LT
2262 int idx;
2263 char buf[64];
2264 unsigned long flags;
2265
2266 tty = (struct tty_struct *)filp->private_data;
a7113a96 2267 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "release_dev"))
1da177e4
LT
2268 return;
2269
2270 check_tty_count(tty, "release_dev");
2271
2272 tty_fasync(-1, filp, 0);
2273
2274 idx = tty->index;
2275 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2276 tty->driver->subtype == PTY_TYPE_MASTER);
2277 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1da177e4
LT
2278 o_tty = tty->link;
2279
2280#ifdef TTY_PARANOIA_CHECK
2281 if (idx < 0 || idx >= tty->driver->num) {
2282 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2283 "free (%s)\n", tty->name);
2284 return;
2285 }
2286 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2287 if (tty != tty->driver->ttys[idx]) {
2288 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2289 "for (%s)\n", idx, tty->name);
2290 return;
2291 }
2292 if (tty->termios != tty->driver->termios[idx]) {
2293 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2294 "for (%s)\n",
2295 idx, tty->name);
2296 return;
2297 }
2298 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2299 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2300 "termios_locked for (%s)\n",
2301 idx, tty->name);
2302 return;
2303 }
2304 }
2305#endif
2306
2307#ifdef TTY_DEBUG_HANGUP
2308 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2309 tty_name(tty, buf), tty->count);
2310#endif
2311
2312#ifdef TTY_PARANOIA_CHECK
2313 if (tty->driver->other &&
2314 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2315 if (o_tty != tty->driver->other->ttys[idx]) {
2316 printk(KERN_DEBUG "release_dev: other->table[%d] "
2317 "not o_tty for (%s)\n",
2318 idx, tty->name);
2319 return;
2320 }
2321 if (o_tty->termios != tty->driver->other->termios[idx]) {
2322 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2323 "not o_termios for (%s)\n",
2324 idx, tty->name);
2325 return;
2326 }
2327 if (o_tty->termios_locked !=
2328 tty->driver->other->termios_locked[idx]) {
2329 printk(KERN_DEBUG "release_dev: other->termios_locked["
2330 "%d] not o_termios_locked for (%s)\n",
2331 idx, tty->name);
2332 return;
2333 }
2334 if (o_tty->link != tty) {
2335 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2336 return;
2337 }
2338 }
2339#endif
2340 if (tty->driver->close)
2341 tty->driver->close(tty, filp);
2342
2343 /*
2344 * Sanity check: if tty->count is going to zero, there shouldn't be
2345 * any waiters on tty->read_wait or tty->write_wait. We test the
2346 * wait queues and kick everyone out _before_ actually starting to
2347 * close. This ensures that we won't block while releasing the tty
2348 * structure.
2349 *
2350 * The test for the o_tty closing is necessary, since the master and
2351 * slave sides may close in any order. If the slave side closes out
2352 * first, its count will be one, since the master side holds an open.
2353 * Thus this test wouldn't be triggered at the time the slave closes,
2354 * so we do it now.
2355 *
2356 * Note that it's possible for the tty to be opened again while we're
2357 * flushing out waiters. By recalculating the closing flags before
2358 * each iteration we avoid any problems.
2359 */
2360 while (1) {
2361 /* Guard against races with tty->count changes elsewhere and
2362 opens on /dev/tty */
2363
70522e12 2364 mutex_lock(&tty_mutex);
1da177e4
LT
2365 tty_closing = tty->count <= 1;
2366 o_tty_closing = o_tty &&
2367 (o_tty->count <= (pty_master ? 1 : 0));
1da177e4
LT
2368 do_sleep = 0;
2369
2370 if (tty_closing) {
2371 if (waitqueue_active(&tty->read_wait)) {
2372 wake_up(&tty->read_wait);
2373 do_sleep++;
2374 }
2375 if (waitqueue_active(&tty->write_wait)) {
2376 wake_up(&tty->write_wait);
2377 do_sleep++;
2378 }
2379 }
2380 if (o_tty_closing) {
2381 if (waitqueue_active(&o_tty->read_wait)) {
2382 wake_up(&o_tty->read_wait);
2383 do_sleep++;
2384 }
2385 if (waitqueue_active(&o_tty->write_wait)) {
2386 wake_up(&o_tty->write_wait);
2387 do_sleep++;
2388 }
2389 }
2390 if (!do_sleep)
2391 break;
2392
2393 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2394 "active!\n", tty_name(tty, buf));
70522e12 2395 mutex_unlock(&tty_mutex);
1da177e4
LT
2396 schedule();
2397 }
2398
2399 /*
2400 * The closing flags are now consistent with the open counts on
2401 * both sides, and we've completed the last operation that could
2402 * block, so it's safe to proceed with closing.
2403 */
1da177e4
LT
2404 if (pty_master) {
2405 if (--o_tty->count < 0) {
2406 printk(KERN_WARNING "release_dev: bad pty slave count "
2407 "(%d) for %s\n",
2408 o_tty->count, tty_name(o_tty, buf));
2409 o_tty->count = 0;
2410 }
2411 }
2412 if (--tty->count < 0) {
2413 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2414 tty->count, tty_name(tty, buf));
2415 tty->count = 0;
2416 }
1da177e4
LT
2417
2418 /*
2419 * We've decremented tty->count, so we need to remove this file
2420 * descriptor off the tty->tty_files list; this serves two
2421 * purposes:
2422 * - check_tty_count sees the correct number of file descriptors
2423 * associated with this tty.
2424 * - do_tty_hangup no longer sees this file descriptor as
2425 * something that needs to be handled for hangups.
2426 */
2427 file_kill(filp);
2428 filp->private_data = NULL;
2429
2430 /*
2431 * Perform some housekeeping before deciding whether to return.
2432 *
2433 * Set the TTY_CLOSING flag if this was the last open. In the
2434 * case of a pty we may have to wait around for the other side
2435 * to close, and TTY_CLOSING makes sure we can't be reopened.
2436 */
2437 if(tty_closing)
2438 set_bit(TTY_CLOSING, &tty->flags);
2439 if(o_tty_closing)
2440 set_bit(TTY_CLOSING, &o_tty->flags);
2441
2442 /*
2443 * If _either_ side is closing, make sure there aren't any
2444 * processes that still think tty or o_tty is their controlling
2445 * tty.
2446 */
2447 if (tty_closing || o_tty_closing) {
1da177e4 2448 read_lock(&tasklist_lock);
24ec839c 2449 session_clear_tty(tty->session);
1da177e4 2450 if (o_tty)
24ec839c 2451 session_clear_tty(o_tty->session);
1da177e4
LT
2452 read_unlock(&tasklist_lock);
2453 }
2454
70522e12 2455 mutex_unlock(&tty_mutex);
da965822 2456
1da177e4
LT
2457 /* check whether both sides are closing ... */
2458 if (!tty_closing || (o_tty && !o_tty_closing))
2459 return;
2460
2461#ifdef TTY_DEBUG_HANGUP
2462 printk(KERN_DEBUG "freeing tty structure...");
2463#endif
2464 /*
2465 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2466 * kill any delayed work. As this is the final close it does not
2467 * race with the set_ldisc code path.
2468 */
2469 clear_bit(TTY_LDISC, &tty->flags);
33f0f88f 2470 cancel_delayed_work(&tty->buf.work);
1da177e4
LT
2471
2472 /*
33f0f88f 2473 * Wait for ->hangup_work and ->buf.work handlers to terminate
1da177e4
LT
2474 */
2475
2476 flush_scheduled_work();
2477
2478 /*
2479 * Wait for any short term users (we know they are just driver
2480 * side waiters as the file is closing so user count on the file
2481 * side is zero.
2482 */
2483 spin_lock_irqsave(&tty_ldisc_lock, flags);
2484 while(tty->ldisc.refcount)
2485 {
2486 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2487 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2488 spin_lock_irqsave(&tty_ldisc_lock, flags);
2489 }
2490 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2491 /*
2492 * Shutdown the current line discipline, and reset it to N_TTY.
2493 * N.B. why reset ldisc when we're releasing the memory??
2494 *
2495 * FIXME: this MUST get fixed for the new reflocking
2496 */
2497 if (tty->ldisc.close)
2498 (tty->ldisc.close)(tty);
2499 tty_ldisc_put(tty->ldisc.num);
2500
2501 /*
2502 * Switch the line discipline back
2503 */
2504 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2505 tty_set_termios_ldisc(tty,N_TTY);
2506 if (o_tty) {
2507 /* FIXME: could o_tty be in setldisc here ? */
2508 clear_bit(TTY_LDISC, &o_tty->flags);
2509 if (o_tty->ldisc.close)
2510 (o_tty->ldisc.close)(o_tty);
2511 tty_ldisc_put(o_tty->ldisc.num);
2512 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2513 tty_set_termios_ldisc(o_tty,N_TTY);
2514 }
2515 /*
d5698c28 2516 * The release_tty function takes care of the details of clearing
1da177e4
LT
2517 * the slots and preserving the termios structure.
2518 */
d5698c28 2519 release_tty(tty, idx);
1da177e4
LT
2520
2521#ifdef CONFIG_UNIX98_PTYS
2522 /* Make this pty number available for reallocation */
2523 if (devpts) {
2524 down(&allocated_ptys_lock);
2525 idr_remove(&allocated_ptys, idx);
2526 up(&allocated_ptys_lock);
2527 }
2528#endif
2529
2530}
2531
af9b897e
AC
2532/**
2533 * tty_open - open a tty device
2534 * @inode: inode of device file
2535 * @filp: file pointer to tty
1da177e4 2536 *
af9b897e
AC
2537 * tty_open and tty_release keep up the tty count that contains the
2538 * number of opens done on a tty. We cannot use the inode-count, as
2539 * different inodes might point to the same tty.
1da177e4 2540 *
af9b897e
AC
2541 * Open-counting is needed for pty masters, as well as for keeping
2542 * track of serial lines: DTR is dropped when the last close happens.
2543 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2544 *
2545 * The termios state of a pty is reset on first open so that
2546 * settings don't persist across reuse.
2547 *
24ec839c
PZ
2548 * Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2549 * tty->count should protect the rest.
2550 * ->siglock protects ->signal/->sighand
1da177e4 2551 */
af9b897e 2552
1da177e4
LT
2553static int tty_open(struct inode * inode, struct file * filp)
2554{
2555 struct tty_struct *tty;
2556 int noctty, retval;
2557 struct tty_driver *driver;
2558 int index;
2559 dev_t device = inode->i_rdev;
2560 unsigned short saved_flags = filp->f_flags;
2561
2562 nonseekable_open(inode, filp);
2563
2564retry_open:
2565 noctty = filp->f_flags & O_NOCTTY;
2566 index = -1;
2567 retval = 0;
2568
70522e12 2569 mutex_lock(&tty_mutex);
1da177e4
LT
2570
2571 if (device == MKDEV(TTYAUX_MAJOR,0)) {
24ec839c
PZ
2572 tty = get_current_tty();
2573 if (!tty) {
70522e12 2574 mutex_unlock(&tty_mutex);
1da177e4
LT
2575 return -ENXIO;
2576 }
24ec839c
PZ
2577 driver = tty->driver;
2578 index = tty->index;
1da177e4
LT
2579 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2580 /* noctty = 1; */
2581 goto got_driver;
2582 }
2583#ifdef CONFIG_VT
2584 if (device == MKDEV(TTY_MAJOR,0)) {
2585 extern struct tty_driver *console_driver;
2586 driver = console_driver;
2587 index = fg_console;
2588 noctty = 1;
2589 goto got_driver;
2590 }
2591#endif
2592 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2593 driver = console_device(&index);
2594 if (driver) {
2595 /* Don't let /dev/console block */
2596 filp->f_flags |= O_NONBLOCK;
2597 noctty = 1;
2598 goto got_driver;
2599 }
70522e12 2600 mutex_unlock(&tty_mutex);
1da177e4
LT
2601 return -ENODEV;
2602 }
2603
2604 driver = get_tty_driver(device, &index);
2605 if (!driver) {
70522e12 2606 mutex_unlock(&tty_mutex);
1da177e4
LT
2607 return -ENODEV;
2608 }
2609got_driver:
2610 retval = init_dev(driver, index, &tty);
70522e12 2611 mutex_unlock(&tty_mutex);
1da177e4
LT
2612 if (retval)
2613 return retval;
2614
2615 filp->private_data = tty;
2616 file_move(filp, &tty->tty_files);
2617 check_tty_count(tty, "tty_open");
2618 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2619 tty->driver->subtype == PTY_TYPE_MASTER)
2620 noctty = 1;
2621#ifdef TTY_DEBUG_HANGUP
2622 printk(KERN_DEBUG "opening %s...", tty->name);
2623#endif
2624 if (!retval) {
2625 if (tty->driver->open)
2626 retval = tty->driver->open(tty, filp);
2627 else
2628 retval = -ENODEV;
2629 }
2630 filp->f_flags = saved_flags;
2631
2632 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2633 retval = -EBUSY;
2634
2635 if (retval) {
2636#ifdef TTY_DEBUG_HANGUP
2637 printk(KERN_DEBUG "error %d in opening %s...", retval,
2638 tty->name);
2639#endif
2640 release_dev(filp);
2641 if (retval != -ERESTARTSYS)
2642 return retval;
2643 if (signal_pending(current))
2644 return retval;
2645 schedule();
2646 /*
2647 * Need to reset f_op in case a hangup happened.
2648 */
2649 if (filp->f_op == &hung_up_tty_fops)
2650 filp->f_op = &tty_fops;
2651 goto retry_open;
2652 }
24ec839c
PZ
2653
2654 mutex_lock(&tty_mutex);
2655 spin_lock_irq(&current->sighand->siglock);
1da177e4
LT
2656 if (!noctty &&
2657 current->signal->leader &&
2658 !current->signal->tty &&
ab521dc0 2659 tty->session == NULL)
2a65f1d9 2660 __proc_set_tty(current, tty);
24ec839c
PZ
2661 spin_unlock_irq(&current->sighand->siglock);
2662 mutex_unlock(&tty_mutex);
1da177e4
LT
2663 return 0;
2664}
2665
2666#ifdef CONFIG_UNIX98_PTYS
af9b897e
AC
2667/**
2668 * ptmx_open - open a unix 98 pty master
2669 * @inode: inode of device file
2670 * @filp: file pointer to tty
2671 *
2672 * Allocate a unix98 pty master device from the ptmx driver.
2673 *
2674 * Locking: tty_mutex protects theinit_dev work. tty->count should
2675 protect the rest.
2676 * allocated_ptys_lock handles the list of free pty numbers
2677 */
2678
1da177e4
LT
2679static int ptmx_open(struct inode * inode, struct file * filp)
2680{
2681 struct tty_struct *tty;
2682 int retval;
2683 int index;
2684 int idr_ret;
2685
2686 nonseekable_open(inode, filp);
2687
2688 /* find a device that is not in use. */
2689 down(&allocated_ptys_lock);
2690 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2691 up(&allocated_ptys_lock);
2692 return -ENOMEM;
2693 }
2694 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2695 if (idr_ret < 0) {
2696 up(&allocated_ptys_lock);
2697 if (idr_ret == -EAGAIN)
2698 return -ENOMEM;
2699 return -EIO;
2700 }
2701 if (index >= pty_limit) {
2702 idr_remove(&allocated_ptys, index);
2703 up(&allocated_ptys_lock);
2704 return -EIO;
2705 }
2706 up(&allocated_ptys_lock);
2707
70522e12 2708 mutex_lock(&tty_mutex);
1da177e4 2709 retval = init_dev(ptm_driver, index, &tty);
70522e12 2710 mutex_unlock(&tty_mutex);
1da177e4
LT
2711
2712 if (retval)
2713 goto out;
2714
2715 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2716 filp->private_data = tty;
2717 file_move(filp, &tty->tty_files);
2718
2719 retval = -ENOMEM;
2720 if (devpts_pty_new(tty->link))
2721 goto out1;
2722
2723 check_tty_count(tty, "tty_open");
2724 retval = ptm_driver->open(tty, filp);
2725 if (!retval)
2726 return 0;
2727out1:
2728 release_dev(filp);
9453a5ad 2729 return retval;
1da177e4
LT
2730out:
2731 down(&allocated_ptys_lock);
2732 idr_remove(&allocated_ptys, index);
2733 up(&allocated_ptys_lock);
2734 return retval;
2735}
2736#endif
2737
af9b897e
AC
2738/**
2739 * tty_release - vfs callback for close
2740 * @inode: inode of tty
2741 * @filp: file pointer for handle to tty
2742 *
2743 * Called the last time each file handle is closed that references
2744 * this tty. There may however be several such references.
2745 *
2746 * Locking:
2747 * Takes bkl. See release_dev
2748 */
2749
1da177e4
LT
2750static int tty_release(struct inode * inode, struct file * filp)
2751{
2752 lock_kernel();
2753 release_dev(filp);
2754 unlock_kernel();
2755 return 0;
2756}
2757
af9b897e
AC
2758/**
2759 * tty_poll - check tty status
2760 * @filp: file being polled
2761 * @wait: poll wait structures to update
2762 *
2763 * Call the line discipline polling method to obtain the poll
2764 * status of the device.
2765 *
2766 * Locking: locks called line discipline but ldisc poll method
2767 * may be re-entered freely by other callers.
2768 */
2769
1da177e4
LT
2770static unsigned int tty_poll(struct file * filp, poll_table * wait)
2771{
2772 struct tty_struct * tty;
2773 struct tty_ldisc *ld;
2774 int ret = 0;
2775
2776 tty = (struct tty_struct *)filp->private_data;
a7113a96 2777 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
1da177e4
LT
2778 return 0;
2779
2780 ld = tty_ldisc_ref_wait(tty);
2781 if (ld->poll)
2782 ret = (ld->poll)(tty, filp, wait);
2783 tty_ldisc_deref(ld);
2784 return ret;
2785}
2786
2787static int tty_fasync(int fd, struct file * filp, int on)
2788{
2789 struct tty_struct * tty;
2790 int retval;
2791
2792 tty = (struct tty_struct *)filp->private_data;
a7113a96 2793 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
1da177e4
LT
2794 return 0;
2795
2796 retval = fasync_helper(fd, filp, on, &tty->fasync);
2797 if (retval <= 0)
2798 return retval;
2799
2800 if (on) {
ab521dc0
EB
2801 enum pid_type type;
2802 struct pid *pid;
1da177e4
LT
2803 if (!waitqueue_active(&tty->read_wait))
2804 tty->minimum_to_wake = 1;
ab521dc0
EB
2805 if (tty->pgrp) {
2806 pid = tty->pgrp;
2807 type = PIDTYPE_PGID;
2808 } else {
2809 pid = task_pid(current);
2810 type = PIDTYPE_PID;
2811 }
2812 retval = __f_setown(filp, pid, type, 0);
1da177e4
LT
2813 if (retval)
2814 return retval;
2815 } else {
2816 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2817 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2818 }
2819 return 0;
2820}
2821
af9b897e
AC
2822/**
2823 * tiocsti - fake input character
2824 * @tty: tty to fake input into
2825 * @p: pointer to character
2826 *
2827 * Fake input to a tty device. Does the neccessary locking and
2828 * input management.
2829 *
2830 * FIXME: does not honour flow control ??
2831 *
2832 * Locking:
2833 * Called functions take tty_ldisc_lock
2834 * current->signal->tty check is safe without locks
28298232
AC
2835 *
2836 * FIXME: may race normal receive processing
af9b897e
AC
2837 */
2838
1da177e4
LT
2839static int tiocsti(struct tty_struct *tty, char __user *p)
2840{
2841 char ch, mbz = 0;
2842 struct tty_ldisc *ld;
2843
2844 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2845 return -EPERM;
2846 if (get_user(ch, p))
2847 return -EFAULT;
2848 ld = tty_ldisc_ref_wait(tty);
2849 ld->receive_buf(tty, &ch, &mbz, 1);
2850 tty_ldisc_deref(ld);
2851 return 0;
2852}
2853
af9b897e
AC
2854/**
2855 * tiocgwinsz - implement window query ioctl
2856 * @tty; tty
2857 * @arg: user buffer for result
2858 *
808a0d38 2859 * Copies the kernel idea of the window size into the user buffer.
af9b897e 2860 *
24ec839c 2861 * Locking: tty->termios_mutex is taken to ensure the winsize data
808a0d38 2862 * is consistent.
af9b897e
AC
2863 */
2864
1da177e4
LT
2865static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2866{
808a0d38
AC
2867 int err;
2868
5785c95b 2869 mutex_lock(&tty->termios_mutex);
808a0d38 2870 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
5785c95b 2871 mutex_unlock(&tty->termios_mutex);
808a0d38
AC
2872
2873 return err ? -EFAULT: 0;
1da177e4
LT
2874}
2875
af9b897e
AC
2876/**
2877 * tiocswinsz - implement window size set ioctl
2878 * @tty; tty
2879 * @arg: user buffer for result
2880 *
2881 * Copies the user idea of the window size to the kernel. Traditionally
2882 * this is just advisory information but for the Linux console it
2883 * actually has driver level meaning and triggers a VC resize.
2884 *
2885 * Locking:
ca9bda00
AC
2886 * Called function use the console_sem is used to ensure we do
2887 * not try and resize the console twice at once.
24ec839c
PZ
2888 * The tty->termios_mutex is used to ensure we don't double
2889 * resize and get confused. Lock order - tty->termios_mutex before
ca9bda00 2890 * console sem
af9b897e
AC
2891 */
2892
1da177e4
LT
2893static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2894 struct winsize __user * arg)
2895{
2896 struct winsize tmp_ws;
2897
2898 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2899 return -EFAULT;
ca9bda00 2900
5785c95b 2901 mutex_lock(&tty->termios_mutex);
1da177e4 2902 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
ca9bda00
AC
2903 goto done;
2904
1da177e4
LT
2905#ifdef CONFIG_VT
2906 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
5785c95b
AV
2907 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2908 tmp_ws.ws_row)) {
2909 mutex_unlock(&tty->termios_mutex);
ca9bda00
AC
2910 return -ENXIO;
2911 }
1da177e4
LT
2912 }
2913#endif
ab521dc0
EB
2914 if (tty->pgrp)
2915 kill_pgrp(tty->pgrp, SIGWINCH, 1);
2916 if ((real_tty->pgrp != tty->pgrp) && real_tty->pgrp)
2917 kill_pgrp(real_tty->pgrp, SIGWINCH, 1);
1da177e4
LT
2918 tty->winsize = tmp_ws;
2919 real_tty->winsize = tmp_ws;
ca9bda00 2920done:
5785c95b 2921 mutex_unlock(&tty->termios_mutex);
1da177e4
LT
2922 return 0;
2923}
2924
af9b897e
AC
2925/**
2926 * tioccons - allow admin to move logical console
2927 * @file: the file to become console
2928 *
2929 * Allow the adminstrator to move the redirected console device
2930 *
2931 * Locking: uses redirect_lock to guard the redirect information
2932 */
2933
1da177e4
LT
2934static int tioccons(struct file *file)
2935{
2936 if (!capable(CAP_SYS_ADMIN))
2937 return -EPERM;
2938 if (file->f_op->write == redirected_tty_write) {
2939 struct file *f;
2940 spin_lock(&redirect_lock);
2941 f = redirect;
2942 redirect = NULL;
2943 spin_unlock(&redirect_lock);
2944 if (f)
2945 fput(f);
2946 return 0;
2947 }
2948 spin_lock(&redirect_lock);
2949 if (redirect) {
2950 spin_unlock(&redirect_lock);
2951 return -EBUSY;
2952 }
2953 get_file(file);
2954 redirect = file;
2955 spin_unlock(&redirect_lock);
2956 return 0;
2957}
2958
af9b897e
AC
2959/**
2960 * fionbio - non blocking ioctl
2961 * @file: file to set blocking value
2962 * @p: user parameter
2963 *
2964 * Historical tty interfaces had a blocking control ioctl before
2965 * the generic functionality existed. This piece of history is preserved
2966 * in the expected tty API of posix OS's.
2967 *
2968 * Locking: none, the open fle handle ensures it won't go away.
2969 */
1da177e4
LT
2970
2971static int fionbio(struct file *file, int __user *p)
2972{
2973 int nonblock;
2974
2975 if (get_user(nonblock, p))
2976 return -EFAULT;
2977
2978 if (nonblock)
2979 file->f_flags |= O_NONBLOCK;
2980 else
2981 file->f_flags &= ~O_NONBLOCK;
2982 return 0;
2983}
2984
af9b897e
AC
2985/**
2986 * tiocsctty - set controlling tty
2987 * @tty: tty structure
2988 * @arg: user argument
2989 *
2990 * This ioctl is used to manage job control. It permits a session
2991 * leader to set this tty as the controlling tty for the session.
2992 *
2993 * Locking:
28298232 2994 * Takes tty_mutex() to protect tty instance
24ec839c
PZ
2995 * Takes tasklist_lock internally to walk sessions
2996 * Takes ->siglock() when updating signal->tty
af9b897e
AC
2997 */
2998
1da177e4
LT
2999static int tiocsctty(struct tty_struct *tty, int arg)
3000{
24ec839c 3001 int ret = 0;
ab521dc0 3002 if (current->signal->leader && (task_session(current) == tty->session))
24ec839c
PZ
3003 return ret;
3004
3005 mutex_lock(&tty_mutex);
1da177e4
LT
3006 /*
3007 * The process must be a session leader and
3008 * not have a controlling tty already.
3009 */
24ec839c
PZ
3010 if (!current->signal->leader || current->signal->tty) {
3011 ret = -EPERM;
3012 goto unlock;
3013 }
3014
ab521dc0 3015 if (tty->session) {
1da177e4
LT
3016 /*
3017 * This tty is already the controlling
3018 * tty for another session group!
3019 */
3020 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
3021 /*
3022 * Steal it away
3023 */
1da177e4 3024 read_lock(&tasklist_lock);
24ec839c 3025 session_clear_tty(tty->session);
1da177e4 3026 read_unlock(&tasklist_lock);
24ec839c
PZ
3027 } else {
3028 ret = -EPERM;
3029 goto unlock;
3030 }
1da177e4 3031 }
24ec839c
PZ
3032 proc_set_tty(current, tty);
3033unlock:
28298232 3034 mutex_unlock(&tty_mutex);
24ec839c 3035 return ret;
1da177e4
LT
3036}
3037
af9b897e
AC
3038/**
3039 * tiocgpgrp - get process group
3040 * @tty: tty passed by user
3041 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3042 * @p: returned pid
3043 *
3044 * Obtain the process group of the tty. If there is no process group
3045 * return an error.
3046 *
24ec839c 3047 * Locking: none. Reference to current->signal->tty is safe.
af9b897e
AC
3048 */
3049
1da177e4
LT
3050static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3051{
3052 /*
3053 * (tty == real_tty) is a cheap way of
3054 * testing if the tty is NOT a master pty.
3055 */
3056 if (tty == real_tty && current->signal->tty != real_tty)
3057 return -ENOTTY;
ab521dc0 3058 return put_user(pid_nr(real_tty->pgrp), p);
1da177e4
LT
3059}
3060
af9b897e
AC
3061/**
3062 * tiocspgrp - attempt to set process group
3063 * @tty: tty passed by user
3064 * @real_tty: tty side device matching tty passed by user
3065 * @p: pid pointer
3066 *
3067 * Set the process group of the tty to the session passed. Only
3068 * permitted where the tty session is our session.
3069 *
3070 * Locking: None
af9b897e
AC
3071 */
3072
1da177e4
LT
3073static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3074{
04a2e6a5
EB
3075 struct pid *pgrp;
3076 pid_t pgrp_nr;
1da177e4
LT
3077 int retval = tty_check_change(real_tty);
3078
3079 if (retval == -EIO)
3080 return -ENOTTY;
3081 if (retval)
3082 return retval;
3083 if (!current->signal->tty ||
3084 (current->signal->tty != real_tty) ||
ab521dc0 3085 (real_tty->session != task_session(current)))
1da177e4 3086 return -ENOTTY;
04a2e6a5 3087 if (get_user(pgrp_nr, p))
1da177e4 3088 return -EFAULT;
04a2e6a5 3089 if (pgrp_nr < 0)
1da177e4 3090 return -EINVAL;
04a2e6a5
EB
3091 rcu_read_lock();
3092 pgrp = find_pid(pgrp_nr);
3093 retval = -ESRCH;
3094 if (!pgrp)
3095 goto out_unlock;
3096 retval = -EPERM;
3097 if (session_of_pgrp(pgrp) != task_session(current))
3098 goto out_unlock;
3099 retval = 0;
ab521dc0
EB
3100 put_pid(real_tty->pgrp);
3101 real_tty->pgrp = get_pid(pgrp);
04a2e6a5
EB
3102out_unlock:
3103 rcu_read_unlock();
3104 return retval;
1da177e4
LT
3105}
3106
af9b897e
AC
3107/**
3108 * tiocgsid - get session id
3109 * @tty: tty passed by user
3110 * @real_tty: tty side of the tty pased by the user if a pty else the tty
3111 * @p: pointer to returned session id
3112 *
3113 * Obtain the session id of the tty. If there is no session
3114 * return an error.
3115 *
24ec839c 3116 * Locking: none. Reference to current->signal->tty is safe.
af9b897e
AC
3117 */
3118
1da177e4
LT
3119static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3120{
3121 /*
3122 * (tty == real_tty) is a cheap way of
3123 * testing if the tty is NOT a master pty.
3124 */
3125 if (tty == real_tty && current->signal->tty != real_tty)
3126 return -ENOTTY;
ab521dc0 3127 if (!real_tty->session)
1da177e4 3128 return -ENOTTY;
ab521dc0 3129 return put_user(pid_nr(real_tty->session), p);
1da177e4
LT
3130}
3131
af9b897e
AC
3132/**
3133 * tiocsetd - set line discipline
3134 * @tty: tty device
3135 * @p: pointer to user data
3136 *
3137 * Set the line discipline according to user request.
3138 *
3139 * Locking: see tty_set_ldisc, this function is just a helper
3140 */
3141
1da177e4
LT
3142static int tiocsetd(struct tty_struct *tty, int __user *p)
3143{
3144 int ldisc;
3145
3146 if (get_user(ldisc, p))
3147 return -EFAULT;
3148 return tty_set_ldisc(tty, ldisc);
3149}
3150
af9b897e
AC
3151/**
3152 * send_break - performed time break
3153 * @tty: device to break on
3154 * @duration: timeout in mS
3155 *
3156 * Perform a timed break on hardware that lacks its own driver level
3157 * timed break functionality.
3158 *
3159 * Locking:
28298232 3160 * atomic_write_lock serializes
af9b897e 3161 *
af9b897e
AC
3162 */
3163
b20f3ae5 3164static int send_break(struct tty_struct *tty, unsigned int duration)
1da177e4 3165{
28298232
AC
3166 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3167 return -EINTR;
1da177e4
LT
3168 tty->driver->break_ctl(tty, -1);
3169 if (!signal_pending(current)) {
b20f3ae5 3170 msleep_interruptible(duration);
1da177e4
LT
3171 }
3172 tty->driver->break_ctl(tty, 0);
28298232 3173 mutex_unlock(&tty->atomic_write_lock);
1da177e4
LT
3174 if (signal_pending(current))
3175 return -EINTR;
3176 return 0;
3177}
3178
af9b897e
AC
3179/**
3180 * tiocmget - get modem status
3181 * @tty: tty device
3182 * @file: user file pointer
3183 * @p: pointer to result
3184 *
3185 * Obtain the modem status bits from the tty driver if the feature
3186 * is supported. Return -EINVAL if it is not available.
3187 *
3188 * Locking: none (up to the driver)
3189 */
3190
3191static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
1da177e4
LT
3192{
3193 int retval = -EINVAL;
3194
3195 if (tty->driver->tiocmget) {
3196 retval = tty->driver->tiocmget(tty, file);
3197
3198 if (retval >= 0)
3199 retval = put_user(retval, p);
3200 }
3201 return retval;
3202}
3203
af9b897e
AC
3204/**
3205 * tiocmset - set modem status
3206 * @tty: tty device
3207 * @file: user file pointer
3208 * @cmd: command - clear bits, set bits or set all
3209 * @p: pointer to desired bits
3210 *
3211 * Set the modem status bits from the tty driver if the feature
3212 * is supported. Return -EINVAL if it is not available.
3213 *
3214 * Locking: none (up to the driver)
3215 */
3216
3217static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
1da177e4
LT
3218 unsigned __user *p)
3219{
3220 int retval = -EINVAL;
3221
3222 if (tty->driver->tiocmset) {
3223 unsigned int set, clear, val;
3224
3225 retval = get_user(val, p);
3226 if (retval)
3227 return retval;
3228
3229 set = clear = 0;
3230 switch (cmd) {
3231 case TIOCMBIS:
3232 set = val;
3233 break;
3234 case TIOCMBIC:
3235 clear = val;
3236 break;
3237 case TIOCMSET:
3238 set = val;
3239 clear = ~val;
3240 break;
3241 }
3242
3243 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3244 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3245
3246 retval = tty->driver->tiocmset(tty, file, set, clear);
3247 }
3248 return retval;
3249}
3250
3251/*
3252 * Split this up, as gcc can choke on it otherwise..
3253 */
3254int tty_ioctl(struct inode * inode, struct file * file,
3255 unsigned int cmd, unsigned long arg)
3256{
3257 struct tty_struct *tty, *real_tty;
3258 void __user *p = (void __user *)arg;
3259 int retval;
3260 struct tty_ldisc *ld;
3261
3262 tty = (struct tty_struct *)file->private_data;
3263 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3264 return -EINVAL;
3265
28298232
AC
3266 /* CHECKME: is this safe as one end closes ? */
3267
1da177e4
LT
3268 real_tty = tty;
3269 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3270 tty->driver->subtype == PTY_TYPE_MASTER)
3271 real_tty = tty->link;
3272
3273 /*
3274 * Break handling by driver
3275 */
3276 if (!tty->driver->break_ctl) {
3277 switch(cmd) {
3278 case TIOCSBRK:
3279 case TIOCCBRK:
3280 if (tty->driver->ioctl)
3281 return tty->driver->ioctl(tty, file, cmd, arg);
3282 return -EINVAL;
3283
3284 /* These two ioctl's always return success; even if */
3285 /* the driver doesn't support them. */
3286 case TCSBRK:
3287 case TCSBRKP:
3288 if (!tty->driver->ioctl)
3289 return 0;
3290 retval = tty->driver->ioctl(tty, file, cmd, arg);
3291 if (retval == -ENOIOCTLCMD)
3292 retval = 0;
3293 return retval;
3294 }
3295 }
3296
3297 /*
3298 * Factor out some common prep work
3299 */
3300 switch (cmd) {
3301 case TIOCSETD:
3302 case TIOCSBRK:
3303 case TIOCCBRK:
3304 case TCSBRK:
3305 case TCSBRKP:
3306 retval = tty_check_change(tty);
3307 if (retval)
3308 return retval;
3309 if (cmd != TIOCCBRK) {
3310 tty_wait_until_sent(tty, 0);
3311 if (signal_pending(current))
3312 return -EINTR;
3313 }
3314 break;
3315 }
3316
3317 switch (cmd) {
3318 case TIOCSTI:
3319 return tiocsti(tty, p);
3320 case TIOCGWINSZ:
3321 return tiocgwinsz(tty, p);
3322 case TIOCSWINSZ:
3323 return tiocswinsz(tty, real_tty, p);
3324 case TIOCCONS:
3325 return real_tty!=tty ? -EINVAL : tioccons(file);
3326 case FIONBIO:
3327 return fionbio(file, p);
3328 case TIOCEXCL:
3329 set_bit(TTY_EXCLUSIVE, &tty->flags);
3330 return 0;
3331 case TIOCNXCL:
3332 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3333 return 0;
3334 case TIOCNOTTY:
3335 if (current->signal->tty != tty)
3336 return -ENOTTY;
98a27ba4 3337 no_tty();
1da177e4
LT
3338 return 0;
3339 case TIOCSCTTY:
3340 return tiocsctty(tty, arg);
3341 case TIOCGPGRP:
3342 return tiocgpgrp(tty, real_tty, p);
3343 case TIOCSPGRP:
3344 return tiocspgrp(tty, real_tty, p);
3345 case TIOCGSID:
3346 return tiocgsid(tty, real_tty, p);
3347 case TIOCGETD:
3348 /* FIXME: check this is ok */
3349 return put_user(tty->ldisc.num, (int __user *)p);
3350 case TIOCSETD:
3351 return tiocsetd(tty, p);
3352#ifdef CONFIG_VT
3353 case TIOCLINUX:
3354 return tioclinux(tty, arg);
3355#endif
3356 /*
3357 * Break handling
3358 */
3359 case TIOCSBRK: /* Turn break on, unconditionally */
3360 tty->driver->break_ctl(tty, -1);
3361 return 0;
3362
3363 case TIOCCBRK: /* Turn break off, unconditionally */
3364 tty->driver->break_ctl(tty, 0);
3365 return 0;
3366 case TCSBRK: /* SVID version: non-zero arg --> no break */
283fef59
PF
3367 /* non-zero arg means wait for all output data
3368 * to be sent (performed above) but don't send break.
3369 * This is used by the tcdrain() termios function.
1da177e4
LT
3370 */
3371 if (!arg)
b20f3ae5 3372 return send_break(tty, 250);
1da177e4
LT
3373 return 0;
3374 case TCSBRKP: /* support for POSIX tcsendbreak() */
b20f3ae5 3375 return send_break(tty, arg ? arg*100 : 250);
1da177e4
LT
3376
3377 case TIOCMGET:
3378 return tty_tiocmget(tty, file, p);
3379
3380 case TIOCMSET:
3381 case TIOCMBIC:
3382 case TIOCMBIS:
3383 return tty_tiocmset(tty, file, cmd, p);
c5c34d48
PF
3384 case TCFLSH:
3385 switch (arg) {
3386 case TCIFLUSH:
3387 case TCIOFLUSH:
3388 /* flush tty buffer and allow ldisc to process ioctl */
3389 tty_buffer_flush(tty);
3390 break;
3391 }
3392 break;
1da177e4
LT
3393 }
3394 if (tty->driver->ioctl) {
3395 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3396 if (retval != -ENOIOCTLCMD)
3397 return retval;
3398 }
3399 ld = tty_ldisc_ref_wait(tty);
3400 retval = -EINVAL;
3401 if (ld->ioctl) {
3402 retval = ld->ioctl(tty, file, cmd, arg);
3403 if (retval == -ENOIOCTLCMD)
3404 retval = -EINVAL;
3405 }
3406 tty_ldisc_deref(ld);
3407 return retval;
3408}
3409
e10cc1df
PF
3410#ifdef CONFIG_COMPAT
3411static long tty_compat_ioctl(struct file * file, unsigned int cmd,
3412 unsigned long arg)
3413{
3414 struct inode *inode = file->f_dentry->d_inode;
3415 struct tty_struct *tty = file->private_data;
3416 struct tty_ldisc *ld;
3417 int retval = -ENOIOCTLCMD;
3418
3419 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3420 return -EINVAL;
3421
3422 if (tty->driver->compat_ioctl) {
3423 retval = (tty->driver->compat_ioctl)(tty, file, cmd, arg);
3424 if (retval != -ENOIOCTLCMD)
3425 return retval;
3426 }
3427
3428 ld = tty_ldisc_ref_wait(tty);
3429 if (ld->compat_ioctl)
3430 retval = ld->compat_ioctl(tty, file, cmd, arg);
3431 tty_ldisc_deref(ld);
3432
3433 return retval;
3434}
3435#endif
1da177e4
LT
3436
3437/*
3438 * This implements the "Secure Attention Key" --- the idea is to
3439 * prevent trojan horses by killing all processes associated with this
3440 * tty when the user hits the "Secure Attention Key". Required for
3441 * super-paranoid applications --- see the Orange Book for more details.
3442 *
3443 * This code could be nicer; ideally it should send a HUP, wait a few
3444 * seconds, then send a INT, and then a KILL signal. But you then
3445 * have to coordinate with the init process, since all processes associated
3446 * with the current tty must be dead before the new getty is allowed
3447 * to spawn.
3448 *
3449 * Now, if it would be correct ;-/ The current code has a nasty hole -
3450 * it doesn't catch files in flight. We may send the descriptor to ourselves
3451 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3452 *
3453 * Nasty bug: do_SAK is being called in interrupt context. This can
3454 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3455 */
8b6312f4 3456void __do_SAK(struct tty_struct *tty)
1da177e4
LT
3457{
3458#ifdef TTY_SOFT_SAK
3459 tty_hangup(tty);
3460#else
652486fb 3461 struct task_struct *g, *p;
ab521dc0 3462 struct pid *session;
1da177e4
LT
3463 int i;
3464 struct file *filp;
badf1662 3465 struct fdtable *fdt;
1da177e4
LT
3466
3467 if (!tty)
3468 return;
24ec839c 3469 session = tty->session;
1da177e4 3470
b3f13deb 3471 tty_ldisc_flush(tty);
1da177e4
LT
3472
3473 if (tty->driver->flush_buffer)
3474 tty->driver->flush_buffer(tty);
3475
3476 read_lock(&tasklist_lock);
652486fb 3477 /* Kill the entire session */
ab521dc0 3478 do_each_pid_task(session, PIDTYPE_SID, p) {
652486fb 3479 printk(KERN_NOTICE "SAK: killed process %d"
937949d9 3480 " (%s): process_session(p)==tty->session\n",
652486fb
EB
3481 p->pid, p->comm);
3482 send_sig(SIGKILL, p, 1);
ab521dc0 3483 } while_each_pid_task(session, PIDTYPE_SID, p);
652486fb
EB
3484 /* Now kill any processes that happen to have the
3485 * tty open.
3486 */
3487 do_each_thread(g, p) {
3488 if (p->signal->tty == tty) {
1da177e4 3489 printk(KERN_NOTICE "SAK: killed process %d"
937949d9 3490 " (%s): process_session(p)==tty->session\n",
1da177e4
LT
3491 p->pid, p->comm);
3492 send_sig(SIGKILL, p, 1);
3493 continue;
3494 }
3495 task_lock(p);
3496 if (p->files) {
ca99c1da
DS
3497 /*
3498 * We don't take a ref to the file, so we must
3499 * hold ->file_lock instead.
3500 */
3501 spin_lock(&p->files->file_lock);
badf1662
DS
3502 fdt = files_fdtable(p->files);
3503 for (i=0; i < fdt->max_fds; i++) {
1da177e4
LT
3504 filp = fcheck_files(p->files, i);
3505 if (!filp)
3506 continue;
3507 if (filp->f_op->read == tty_read &&
3508 filp->private_data == tty) {
3509 printk(KERN_NOTICE "SAK: killed process %d"
3510 " (%s): fd#%d opened to the tty\n",
3511 p->pid, p->comm, i);
20ac9437 3512 force_sig(SIGKILL, p);
1da177e4
LT
3513 break;
3514 }
3515 }
ca99c1da 3516 spin_unlock(&p->files->file_lock);
1da177e4
LT
3517 }
3518 task_unlock(p);
652486fb 3519 } while_each_thread(g, p);
1da177e4
LT
3520 read_unlock(&tasklist_lock);
3521#endif
3522}
3523
8b6312f4
EB
3524static void do_SAK_work(struct work_struct *work)
3525{
3526 struct tty_struct *tty =
3527 container_of(work, struct tty_struct, SAK_work);
3528 __do_SAK(tty);
3529}
3530
1da177e4
LT
3531/*
3532 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3533 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3534 * the values which we write to it will be identical to the values which it
3535 * already has. --akpm
3536 */
3537void do_SAK(struct tty_struct *tty)
3538{
3539 if (!tty)
3540 return;
1da177e4
LT
3541 schedule_work(&tty->SAK_work);
3542}
3543
3544EXPORT_SYMBOL(do_SAK);
3545
af9b897e
AC
3546/**
3547 * flush_to_ldisc
65f27f38 3548 * @work: tty structure passed from work queue.
af9b897e
AC
3549 *
3550 * This routine is called out of the software interrupt to flush data
3551 * from the buffer chain to the line discipline.
3552 *
3553 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3554 * while invoking the line discipline receive_buf method. The
3555 * receive_buf method is single threaded for each tty instance.
1da177e4
LT
3556 */
3557
65f27f38 3558static void flush_to_ldisc(struct work_struct *work)
1da177e4 3559{
65f27f38
DH
3560 struct tty_struct *tty =
3561 container_of(work, struct tty_struct, buf.work.work);
1da177e4
LT
3562 unsigned long flags;
3563 struct tty_ldisc *disc;
2c3bb20f 3564 struct tty_buffer *tbuf, *head;
8977d929
PF
3565 char *char_buf;
3566 unsigned char *flag_buf;
1da177e4
LT
3567
3568 disc = tty_ldisc_ref(tty);
3569 if (disc == NULL) /* !TTY_LDISC */
3570 return;
3571
808249ce 3572 spin_lock_irqsave(&tty->buf.lock, flags);
2c3bb20f
PF
3573 head = tty->buf.head;
3574 if (head != NULL) {
3575 tty->buf.head = NULL;
3576 for (;;) {
3577 int count = head->commit - head->read;
3578 if (!count) {
3579 if (head->next == NULL)
3580 break;
3581 tbuf = head;
3582 head = head->next;
3583 tty_buffer_free(tty, tbuf);
3584 continue;
3585 }
3586 if (!tty->receive_room) {
3587 schedule_delayed_work(&tty->buf.work, 1);
3588 break;
3589 }
3590 if (count > tty->receive_room)
3591 count = tty->receive_room;
3592 char_buf = head->char_buf_ptr + head->read;
3593 flag_buf = head->flag_buf_ptr + head->read;
3594 head->read += count;
8977d929
PF
3595 spin_unlock_irqrestore(&tty->buf.lock, flags);
3596 disc->receive_buf(tty, char_buf, flag_buf, count);
3597 spin_lock_irqsave(&tty->buf.lock, flags);
3598 }
2c3bb20f 3599 tty->buf.head = head;
33f0f88f 3600 }
808249ce 3601 spin_unlock_irqrestore(&tty->buf.lock, flags);
817d6d3b 3602
1da177e4
LT
3603 tty_ldisc_deref(disc);
3604}
3605
1da177e4
LT
3606/**
3607 * tty_flip_buffer_push - terminal
3608 * @tty: tty to push
3609 *
3610 * Queue a push of the terminal flip buffers to the line discipline. This
3611 * function must not be called from IRQ context if tty->low_latency is set.
3612 *
3613 * In the event of the queue being busy for flipping the work will be
3614 * held off and retried later.
af9b897e
AC
3615 *
3616 * Locking: tty buffer lock. Driver locks in low latency mode.
1da177e4
LT
3617 */
3618
3619void tty_flip_buffer_push(struct tty_struct *tty)
3620{
808249ce
PF
3621 unsigned long flags;
3622 spin_lock_irqsave(&tty->buf.lock, flags);
33b37a33 3623 if (tty->buf.tail != NULL)
8977d929 3624 tty->buf.tail->commit = tty->buf.tail->used;
808249ce
PF
3625 spin_unlock_irqrestore(&tty->buf.lock, flags);
3626
1da177e4 3627 if (tty->low_latency)
65f27f38 3628 flush_to_ldisc(&tty->buf.work.work);
1da177e4 3629 else
33f0f88f 3630 schedule_delayed_work(&tty->buf.work, 1);
1da177e4
LT
3631}
3632
3633EXPORT_SYMBOL(tty_flip_buffer_push);
3634
33f0f88f 3635
af9b897e
AC
3636/**
3637 * initialize_tty_struct
3638 * @tty: tty to initialize
3639 *
3640 * This subroutine initializes a tty structure that has been newly
3641 * allocated.
3642 *
3643 * Locking: none - tty in question must not be exposed at this point
1da177e4 3644 */
af9b897e 3645
1da177e4
LT
3646static void initialize_tty_struct(struct tty_struct *tty)
3647{
3648 memset(tty, 0, sizeof(struct tty_struct));
3649 tty->magic = TTY_MAGIC;
3650 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
ab521dc0
EB
3651 tty->session = NULL;
3652 tty->pgrp = NULL;
1da177e4 3653 tty->overrun_time = jiffies;
33f0f88f
AC
3654 tty->buf.head = tty->buf.tail = NULL;
3655 tty_buffer_init(tty);
65f27f38 3656 INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
33f0f88f 3657 init_MUTEX(&tty->buf.pty_sem);
5785c95b 3658 mutex_init(&tty->termios_mutex);
1da177e4
LT
3659 init_waitqueue_head(&tty->write_wait);
3660 init_waitqueue_head(&tty->read_wait);
65f27f38 3661 INIT_WORK(&tty->hangup_work, do_tty_hangup);
70522e12
IM
3662 mutex_init(&tty->atomic_read_lock);
3663 mutex_init(&tty->atomic_write_lock);
1da177e4
LT
3664 spin_lock_init(&tty->read_lock);
3665 INIT_LIST_HEAD(&tty->tty_files);
7f1f86a0 3666 INIT_WORK(&tty->SAK_work, do_SAK_work);
1da177e4
LT
3667}
3668
3669/*
3670 * The default put_char routine if the driver did not define one.
3671 */
af9b897e 3672
1da177e4
LT
3673static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3674{
3675 tty->driver->write(tty, &ch, 1);
3676}
3677
7fe845d1 3678static struct class *tty_class;
1da177e4
LT
3679
3680/**
af9b897e
AC
3681 * tty_register_device - register a tty device
3682 * @driver: the tty driver that describes the tty device
3683 * @index: the index in the tty driver for this tty device
3684 * @device: a struct device that is associated with this tty device.
3685 * This field is optional, if there is no known struct device
3686 * for this tty device it can be set to NULL safely.
1da177e4 3687 *
01107d34
GKH
3688 * Returns a pointer to the struct device for this tty device
3689 * (or ERR_PTR(-EFOO) on error).
1cdcb6b4 3690 *
af9b897e
AC
3691 * This call is required to be made to register an individual tty device
3692 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3693 * that bit is not set, this function should not be called by a tty
3694 * driver.
3695 *
3696 * Locking: ??
1da177e4 3697 */
af9b897e 3698
01107d34
GKH
3699struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3700 struct device *device)
1da177e4
LT
3701{
3702 char name[64];
3703 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3704
3705 if (index >= driver->num) {
3706 printk(KERN_ERR "Attempt to register invalid tty line number "
3707 " (%d).\n", index);
1cdcb6b4 3708 return ERR_PTR(-EINVAL);
1da177e4
LT
3709 }
3710
1da177e4
LT
3711 if (driver->type == TTY_DRIVER_TYPE_PTY)
3712 pty_line_name(driver, index, name);
3713 else
3714 tty_line_name(driver, index, name);
1cdcb6b4 3715
01107d34 3716 return device_create(tty_class, device, dev, name);
1da177e4
LT
3717}
3718
3719/**
af9b897e
AC
3720 * tty_unregister_device - unregister a tty device
3721 * @driver: the tty driver that describes the tty device
3722 * @index: the index in the tty driver for this tty device
1da177e4 3723 *
af9b897e
AC
3724 * If a tty device is registered with a call to tty_register_device() then
3725 * this function must be called when the tty device is gone.
3726 *
3727 * Locking: ??
1da177e4 3728 */
af9b897e 3729
1da177e4
LT
3730void tty_unregister_device(struct tty_driver *driver, unsigned index)
3731{
01107d34 3732 device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
1da177e4
LT
3733}
3734
3735EXPORT_SYMBOL(tty_register_device);
3736EXPORT_SYMBOL(tty_unregister_device);
3737
3738struct tty_driver *alloc_tty_driver(int lines)
3739{
3740 struct tty_driver *driver;
3741
3742 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3743 if (driver) {
3744 memset(driver, 0, sizeof(struct tty_driver));
3745 driver->magic = TTY_DRIVER_MAGIC;
3746 driver->num = lines;
3747 /* later we'll move allocation of tables here */
3748 }
3749 return driver;
3750}
3751
3752void put_tty_driver(struct tty_driver *driver)
3753{
3754 kfree(driver);
3755}
3756
b68e31d0
JD
3757void tty_set_operations(struct tty_driver *driver,
3758 const struct tty_operations *op)
1da177e4
LT
3759{
3760 driver->open = op->open;
3761 driver->close = op->close;
3762 driver->write = op->write;
3763 driver->put_char = op->put_char;
3764 driver->flush_chars = op->flush_chars;
3765 driver->write_room = op->write_room;
3766 driver->chars_in_buffer = op->chars_in_buffer;
3767 driver->ioctl = op->ioctl;
e10cc1df 3768 driver->compat_ioctl = op->compat_ioctl;
1da177e4
LT
3769 driver->set_termios = op->set_termios;
3770 driver->throttle = op->throttle;
3771 driver->unthrottle = op->unthrottle;
3772 driver->stop = op->stop;
3773 driver->start = op->start;
3774 driver->hangup = op->hangup;
3775 driver->break_ctl = op->break_ctl;
3776 driver->flush_buffer = op->flush_buffer;
3777 driver->set_ldisc = op->set_ldisc;
3778 driver->wait_until_sent = op->wait_until_sent;
3779 driver->send_xchar = op->send_xchar;
3780 driver->read_proc = op->read_proc;
3781 driver->write_proc = op->write_proc;
3782 driver->tiocmget = op->tiocmget;
3783 driver->tiocmset = op->tiocmset;
3784}
3785
3786
3787EXPORT_SYMBOL(alloc_tty_driver);
3788EXPORT_SYMBOL(put_tty_driver);
3789EXPORT_SYMBOL(tty_set_operations);
3790
3791/*
3792 * Called by a tty driver to register itself.
3793 */
3794int tty_register_driver(struct tty_driver *driver)
3795{
3796 int error;
3797 int i;
3798 dev_t dev;
3799 void **p = NULL;
3800
3801 if (driver->flags & TTY_DRIVER_INSTALLED)
3802 return 0;
3803
543691a6
AW
3804 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
3805 p = kzalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
1da177e4
LT
3806 if (!p)
3807 return -ENOMEM;
1da177e4
LT
3808 }
3809
3810 if (!driver->major) {
3811 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
e5717c48 3812 driver->name);
1da177e4
LT
3813 if (!error) {
3814 driver->major = MAJOR(dev);
3815 driver->minor_start = MINOR(dev);
3816 }
3817 } else {
3818 dev = MKDEV(driver->major, driver->minor_start);
e5717c48 3819 error = register_chrdev_region(dev, driver->num, driver->name);
1da177e4
LT
3820 }
3821 if (error < 0) {
3822 kfree(p);
3823 return error;
3824 }
3825
3826 if (p) {
3827 driver->ttys = (struct tty_struct **)p;
edc6afc5
AC
3828 driver->termios = (struct ktermios **)(p + driver->num);
3829 driver->termios_locked = (struct ktermios **)(p + driver->num * 2);
1da177e4
LT
3830 } else {
3831 driver->ttys = NULL;
3832 driver->termios = NULL;
3833 driver->termios_locked = NULL;
3834 }
3835
3836 cdev_init(&driver->cdev, &tty_fops);
3837 driver->cdev.owner = driver->owner;
3838 error = cdev_add(&driver->cdev, dev, driver->num);
3839 if (error) {
1da177e4
LT
3840 unregister_chrdev_region(dev, driver->num);
3841 driver->ttys = NULL;
3842 driver->termios = driver->termios_locked = NULL;
3843 kfree(p);
3844 return error;
3845 }
3846
3847 if (!driver->put_char)
3848 driver->put_char = tty_default_put_char;
3849
ca509f69 3850 mutex_lock(&tty_mutex);
1da177e4 3851 list_add(&driver->tty_drivers, &tty_drivers);
ca509f69 3852 mutex_unlock(&tty_mutex);
1da177e4 3853
331b8319 3854 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
1da177e4
LT
3855 for(i = 0; i < driver->num; i++)
3856 tty_register_device(driver, i, NULL);
3857 }
3858 proc_tty_register_driver(driver);
3859 return 0;
3860}
3861
3862EXPORT_SYMBOL(tty_register_driver);
3863
3864/*
3865 * Called by a tty driver to unregister itself.
3866 */
3867int tty_unregister_driver(struct tty_driver *driver)
3868{
3869 int i;
edc6afc5 3870 struct ktermios *tp;
1da177e4
LT
3871 void *p;
3872
3873 if (driver->refcount)
3874 return -EBUSY;
3875
3876 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3877 driver->num);
ca509f69 3878 mutex_lock(&tty_mutex);
1da177e4 3879 list_del(&driver->tty_drivers);
ca509f69 3880 mutex_unlock(&tty_mutex);
1da177e4
LT
3881
3882 /*
3883 * Free the termios and termios_locked structures because
3884 * we don't want to get memory leaks when modular tty
3885 * drivers are removed from the kernel.
3886 */
3887 for (i = 0; i < driver->num; i++) {
3888 tp = driver->termios[i];
3889 if (tp) {
3890 driver->termios[i] = NULL;
3891 kfree(tp);
3892 }
3893 tp = driver->termios_locked[i];
3894 if (tp) {
3895 driver->termios_locked[i] = NULL;
3896 kfree(tp);
3897 }
331b8319 3898 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
1da177e4
LT
3899 tty_unregister_device(driver, i);
3900 }
3901 p = driver->ttys;
3902 proc_tty_unregister_driver(driver);
3903 driver->ttys = NULL;
3904 driver->termios = driver->termios_locked = NULL;
3905 kfree(p);
3906 cdev_del(&driver->cdev);
3907 return 0;
3908}
1da177e4
LT
3909EXPORT_SYMBOL(tty_unregister_driver);
3910
24ec839c
PZ
3911dev_t tty_devnum(struct tty_struct *tty)
3912{
3913 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3914}
3915EXPORT_SYMBOL(tty_devnum);
3916
3917void proc_clear_tty(struct task_struct *p)
3918{
3919 spin_lock_irq(&p->sighand->siglock);
3920 p->signal->tty = NULL;
3921 spin_unlock_irq(&p->sighand->siglock);
3922}
7cac4ce5 3923EXPORT_SYMBOL(proc_clear_tty);
24ec839c 3924
2a65f1d9 3925static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
24ec839c
PZ
3926{
3927 if (tty) {
d9c1e9a8
EB
3928 /* We should not have a session or pgrp to here but.... */
3929 put_pid(tty->session);
3930 put_pid(tty->pgrp);
ab521dc0
EB
3931 tty->session = get_pid(task_session(tsk));
3932 tty->pgrp = get_pid(task_pgrp(tsk));
24ec839c 3933 }
2a65f1d9 3934 put_pid(tsk->signal->tty_old_pgrp);
24ec839c 3935 tsk->signal->tty = tty;
ab521dc0 3936 tsk->signal->tty_old_pgrp = NULL;
24ec839c
PZ
3937}
3938
98a27ba4 3939static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
24ec839c
PZ
3940{
3941 spin_lock_irq(&tsk->sighand->siglock);
2a65f1d9 3942 __proc_set_tty(tsk, tty);
24ec839c
PZ
3943 spin_unlock_irq(&tsk->sighand->siglock);
3944}
3945
3946struct tty_struct *get_current_tty(void)
3947{
3948 struct tty_struct *tty;
3949 WARN_ON_ONCE(!mutex_is_locked(&tty_mutex));
3950 tty = current->signal->tty;
3951 /*
3952 * session->tty can be changed/cleared from under us, make sure we
3953 * issue the load. The obtained pointer, when not NULL, is valid as
3954 * long as we hold tty_mutex.
3955 */
3956 barrier();
3957 return tty;
3958}
a311f743 3959EXPORT_SYMBOL_GPL(get_current_tty);
1da177e4
LT
3960
3961/*
3962 * Initialize the console device. This is called *early*, so
3963 * we can't necessarily depend on lots of kernel help here.
3964 * Just do some early initializations, and do the complex setup
3965 * later.
3966 */
3967void __init console_init(void)
3968{
3969 initcall_t *call;
3970
3971 /* Setup the default TTY line discipline. */
3972 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3973
3974 /*
3975 * set up the console device so that later boot sequences can
3976 * inform about problems etc..
3977 */
1da177e4
LT
3978 call = __con_initcall_start;
3979 while (call < __con_initcall_end) {
3980 (*call)();
3981 call++;
3982 }
3983}
3984
3985#ifdef CONFIG_VT
3986extern int vty_init(void);
3987#endif
3988
3989static int __init tty_class_init(void)
3990{
7fe845d1 3991 tty_class = class_create(THIS_MODULE, "tty");
1da177e4
LT
3992 if (IS_ERR(tty_class))
3993 return PTR_ERR(tty_class);
3994 return 0;
3995}
3996
3997postcore_initcall(tty_class_init);
3998
3999/* 3/2004 jmc: why do these devices exist? */
4000
4001static struct cdev tty_cdev, console_cdev;
4002#ifdef CONFIG_UNIX98_PTYS
4003static struct cdev ptmx_cdev;
4004#endif
4005#ifdef CONFIG_VT
4006static struct cdev vc0_cdev;
4007#endif
4008
4009/*
4010 * Ok, now we can initialize the rest of the tty devices and can count
4011 * on memory allocations, interrupts etc..
4012 */
4013static int __init tty_init(void)
4014{
4015 cdev_init(&tty_cdev, &tty_fops);
4016 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
4017 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
4018 panic("Couldn't register /dev/tty driver\n");
01107d34 4019 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
1da177e4
LT
4020
4021 cdev_init(&console_cdev, &console_fops);
4022 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
4023 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
4024 panic("Couldn't register /dev/console driver\n");
01107d34 4025 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
1da177e4
LT
4026
4027#ifdef CONFIG_UNIX98_PTYS
4028 cdev_init(&ptmx_cdev, &ptmx_fops);
4029 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
4030 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
4031 panic("Couldn't register /dev/ptmx driver\n");
01107d34 4032 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
1da177e4
LT
4033#endif
4034
4035#ifdef CONFIG_VT
4036 cdev_init(&vc0_cdev, &console_fops);
4037 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
4038 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
4039 panic("Couldn't register /dev/tty0 driver\n");
01107d34 4040 device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
1da177e4
LT
4041
4042 vty_init();
4043#endif
4044 return 0;
4045}
4046module_init(tty_init);