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