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