blob: 18085a20df23942b05e7684d0639aa9261f31d79 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/types.h>
69#include <linux/major.h>
70#include <linux/errno.h>
71#include <linux/signal.h>
72#include <linux/fcntl.h>
73#include <linux/sched.h>
74#include <linux/interrupt.h>
75#include <linux/tty.h>
76#include <linux/tty_driver.h>
77#include <linux/tty_flip.h>
78#include <linux/devpts_fs.h>
79#include <linux/file.h>
80#include <linux/console.h>
81#include <linux/timer.h>
82#include <linux/ctype.h>
83#include <linux/kd.h>
84#include <linux/mm.h>
85#include <linux/string.h>
86#include <linux/slab.h>
87#include <linux/poll.h>
88#include <linux/proc_fs.h>
89#include <linux/init.h>
90#include <linux/module.h>
91#include <linux/smp_lock.h>
92#include <linux/device.h>
93#include <linux/idr.h>
94#include <linux/wait.h>
95#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070096#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98#include <asm/uaccess.h>
99#include <asm/system.h>
100
101#include <linux/kbd_kern.h>
102#include <linux/vt_kern.h>
103#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105#include <linux/kmod.h>
106
107#undef TTY_DEBUG_HANGUP
108
109#define TTY_PARANOIA_CHECK 1
110#define CHECK_TTY_COUNT 1
111
112struct termios tty_std_termios = { /* for the benefit of tty drivers */
113 .c_iflag = ICRNL | IXON,
114 .c_oflag = OPOST | ONLCR,
115 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
116 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
117 ECHOCTL | ECHOKE | IEXTEN,
118 .c_cc = INIT_C_CC
119};
120
121EXPORT_SYMBOL(tty_std_termios);
122
123/* This list gets poked at by procfs and various bits of boot up code. This
124 could do with some rationalisation such as pulling the tty proc function
125 into this file */
126
127LIST_HEAD(tty_drivers); /* linked list of tty drivers */
128
129/* Semaphore to protect creating and releasing a tty. This is shared with
130 vt.c for deeply disgusting hack reasons */
Ingo Molnar70522e12006-03-23 03:00:31 -0800131DEFINE_MUTEX(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
133#ifdef CONFIG_UNIX98_PTYS
134extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
135extern int pty_limit; /* Config limit on Unix98 ptys */
136static DEFINE_IDR(allocated_ptys);
137static DECLARE_MUTEX(allocated_ptys_lock);
138static int ptmx_open(struct inode *, struct file *);
139#endif
140
141extern void disable_early_printk(void);
142
143static void initialize_tty_struct(struct tty_struct *tty);
144
145static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
146static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
147ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
148static unsigned int tty_poll(struct file *, poll_table *);
149static int tty_open(struct inode *, struct file *);
150static int tty_release(struct inode *, struct file *);
151int tty_ioctl(struct inode * inode, struct file * file,
152 unsigned int cmd, unsigned long arg);
153static int tty_fasync(int fd, struct file * filp, int on);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154static void release_mem(struct tty_struct *tty, int idx);
155
Alan Coxaf9b8972006-08-27 01:24:01 -0700156/**
157 * alloc_tty_struct - allocate a tty object
158 *
159 * Return a new empty tty structure. The data fields have not
160 * been initialized in any way but has been zeroed
161 *
162 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700163 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165static struct tty_struct *alloc_tty_struct(void)
166{
Alan Cox1266b1e2006-09-29 02:00:40 -0700167 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168}
169
Alan Cox33f0f882006-01-09 20:54:13 -0800170static void tty_buffer_free_all(struct tty_struct *);
171
Alan Coxaf9b8972006-08-27 01:24:01 -0700172/**
173 * free_tty_struct - free a disused tty
174 * @tty: tty struct to free
175 *
176 * Free the write buffers, tty queue and tty memory itself.
177 *
178 * Locking: none. Must be called after tty is definitely unused
179 */
180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181static inline void free_tty_struct(struct tty_struct *tty)
182{
183 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800184 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 kfree(tty);
186}
187
188#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
189
Alan Coxaf9b8972006-08-27 01:24:01 -0700190/**
191 * tty_name - return tty naming
192 * @tty: tty structure
193 * @buf: buffer for output
194 *
195 * Convert a tty structure into a name. The name reflects the kernel
196 * naming policy and if udev is in use may not reflect user space
197 *
198 * Locking: none
199 */
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201char *tty_name(struct tty_struct *tty, char *buf)
202{
203 if (!tty) /* Hmm. NULL pointer. That's fun. */
204 strcpy(buf, "NULL tty");
205 else
206 strcpy(buf, tty->name);
207 return buf;
208}
209
210EXPORT_SYMBOL(tty_name);
211
Andrew Mortond769a662005-05-05 16:15:50 -0700212int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 const char *routine)
214{
215#ifdef TTY_PARANOIA_CHECK
216 if (!tty) {
217 printk(KERN_WARNING
218 "null TTY for (%d:%d) in %s\n",
219 imajor(inode), iminor(inode), routine);
220 return 1;
221 }
222 if (tty->magic != TTY_MAGIC) {
223 printk(KERN_WARNING
224 "bad magic number for tty struct (%d:%d) in %s\n",
225 imajor(inode), iminor(inode), routine);
226 return 1;
227 }
228#endif
229 return 0;
230}
231
232static int check_tty_count(struct tty_struct *tty, const char *routine)
233{
234#ifdef CHECK_TTY_COUNT
235 struct list_head *p;
236 int count = 0;
237
238 file_list_lock();
239 list_for_each(p, &tty->tty_files) {
240 count++;
241 }
242 file_list_unlock();
243 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
244 tty->driver->subtype == PTY_TYPE_SLAVE &&
245 tty->link && tty->link->count)
246 count++;
247 if (tty->count != count) {
248 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
249 "!= #fd's(%d) in %s\n",
250 tty->name, tty->count, count, routine);
251 return count;
252 }
253#endif
254 return 0;
255}
256
257/*
Alan Cox33f0f882006-01-09 20:54:13 -0800258 * Tty buffer allocation management
259 */
260
Alan Coxaf9b8972006-08-27 01:24:01 -0700261
262/**
263 * tty_buffer_free_all - free buffers used by a tty
264 * @tty: tty to free from
265 *
266 * Remove all the buffers pending on a tty whether queued with data
267 * or in the free ring. Must be called when the tty is no longer in use
268 *
269 * Locking: none
270 */
271
Alan Cox01da5fd2006-08-27 01:24:02 -0700272
273/**
274 * tty_buffer_free_all - free buffers used by a tty
275 * @tty: tty to free from
276 *
277 * Remove all the buffers pending on a tty whether queued with data
278 * or in the free ring. Must be called when the tty is no longer in use
279 *
280 * Locking: none
281 */
282
Alan Cox33f0f882006-01-09 20:54:13 -0800283static void tty_buffer_free_all(struct tty_struct *tty)
284{
285 struct tty_buffer *thead;
286 while((thead = tty->buf.head) != NULL) {
287 tty->buf.head = thead->next;
288 kfree(thead);
289 }
290 while((thead = tty->buf.free) != NULL) {
291 tty->buf.free = thead->next;
292 kfree(thead);
293 }
294 tty->buf.tail = NULL;
Alan Cox01da5fd2006-08-27 01:24:02 -0700295 tty->buf.memory_used = 0;
Alan Cox33f0f882006-01-09 20:54:13 -0800296}
297
Alan Cox01da5fd2006-08-27 01:24:02 -0700298/**
299 * tty_buffer_init - prepare a tty buffer structure
300 * @tty: tty to initialise
301 *
302 * Set up the initial state of the buffer management for a tty device.
303 * Must be called before the other tty buffer functions are used.
304 *
305 * Locking: none
306 */
307
Alan Cox33f0f882006-01-09 20:54:13 -0800308static void tty_buffer_init(struct tty_struct *tty)
309{
Paul Fulghum808249c2006-02-03 03:04:41 -0800310 spin_lock_init(&tty->buf.lock);
Alan Cox33f0f882006-01-09 20:54:13 -0800311 tty->buf.head = NULL;
312 tty->buf.tail = NULL;
313 tty->buf.free = NULL;
Alan Cox01da5fd2006-08-27 01:24:02 -0700314 tty->buf.memory_used = 0;
Alan Cox33f0f882006-01-09 20:54:13 -0800315}
316
Alan Cox01da5fd2006-08-27 01:24:02 -0700317/**
318 * tty_buffer_alloc - allocate a tty buffer
319 * @tty: tty device
320 * @size: desired size (characters)
321 *
322 * Allocate a new tty buffer to hold the desired number of characters.
323 * Return NULL if out of memory or the allocation would exceed the
324 * per device queue
325 *
326 * Locking: Caller must hold tty->buf.lock
327 */
328
329static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
Alan Cox33f0f882006-01-09 20:54:13 -0800330{
Alan Cox01da5fd2006-08-27 01:24:02 -0700331 struct tty_buffer *p;
332
333 if (tty->buf.memory_used + size > 65536)
334 return NULL;
335 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
Alan Cox33f0f882006-01-09 20:54:13 -0800336 if(p == NULL)
337 return NULL;
338 p->used = 0;
339 p->size = size;
340 p->next = NULL;
Paul Fulghum8977d922006-02-10 01:51:14 -0800341 p->commit = 0;
342 p->read = 0;
Alan Cox33f0f882006-01-09 20:54:13 -0800343 p->char_buf_ptr = (char *)(p->data);
344 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
Alan Cox01da5fd2006-08-27 01:24:02 -0700345 tty->buf.memory_used += size;
Alan Cox33f0f882006-01-09 20:54:13 -0800346 return p;
347}
348
Alan Cox01da5fd2006-08-27 01:24:02 -0700349/**
350 * tty_buffer_free - free a tty buffer
351 * @tty: tty owning the buffer
352 * @b: the buffer to free
353 *
354 * Free a tty buffer, or add it to the free list according to our
355 * internal strategy
356 *
357 * Locking: Caller must hold tty->buf.lock
358 */
Alan Cox33f0f882006-01-09 20:54:13 -0800359
360static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
361{
362 /* Dumb strategy for now - should keep some stats */
Alan Cox01da5fd2006-08-27 01:24:02 -0700363 tty->buf.memory_used -= b->size;
364 WARN_ON(tty->buf.memory_used < 0);
365
Alan Cox33f0f882006-01-09 20:54:13 -0800366 if(b->size >= 512)
367 kfree(b);
368 else {
369 b->next = tty->buf.free;
370 tty->buf.free = b;
371 }
372}
373
Alan Cox01da5fd2006-08-27 01:24:02 -0700374/**
375 * tty_buffer_find - find a free tty buffer
376 * @tty: tty owning the buffer
377 * @size: characters wanted
378 *
379 * Locate an existing suitable tty buffer or if we are lacking one then
380 * allocate a new one. We round our buffers off in 256 character chunks
381 * to get better allocation behaviour.
382 *
383 * Locking: Caller must hold tty->buf.lock
384 */
385
Alan Cox33f0f882006-01-09 20:54:13 -0800386static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
387{
388 struct tty_buffer **tbh = &tty->buf.free;
389 while((*tbh) != NULL) {
390 struct tty_buffer *t = *tbh;
391 if(t->size >= size) {
392 *tbh = t->next;
393 t->next = NULL;
394 t->used = 0;
Paul Fulghum8977d922006-02-10 01:51:14 -0800395 t->commit = 0;
396 t->read = 0;
Alan Cox01da5fd2006-08-27 01:24:02 -0700397 tty->buf.memory_used += t->size;
Alan Cox33f0f882006-01-09 20:54:13 -0800398 return t;
399 }
400 tbh = &((*tbh)->next);
401 }
402 /* Round the buffer size out */
403 size = (size + 0xFF) & ~ 0xFF;
Alan Cox01da5fd2006-08-27 01:24:02 -0700404 return tty_buffer_alloc(tty, size);
Alan Cox33f0f882006-01-09 20:54:13 -0800405 /* Should possibly check if this fails for the largest buffer we
406 have queued and recycle that ? */
407}
408
Alan Cox01da5fd2006-08-27 01:24:02 -0700409/**
410 * tty_buffer_request_room - grow tty buffer if needed
411 * @tty: tty structure
412 * @size: size desired
413 *
414 * Make at least size bytes of linear space available for the tty
415 * buffer. If we fail return the size we managed to find.
416 *
417 * Locking: Takes tty->buf.lock
418 */
Alan Cox33f0f882006-01-09 20:54:13 -0800419int tty_buffer_request_room(struct tty_struct *tty, size_t size)
420{
Paul Fulghum808249c2006-02-03 03:04:41 -0800421 struct tty_buffer *b, *n;
422 int left;
423 unsigned long flags;
424
425 spin_lock_irqsave(&tty->buf.lock, flags);
Alan Cox33f0f882006-01-09 20:54:13 -0800426
427 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
428 remove this conditional if its worth it. This would be invisible
429 to the callers */
Paul Fulghum33b37a32006-06-28 04:26:49 -0700430 if ((b = tty->buf.tail) != NULL)
Alan Cox33f0f882006-01-09 20:54:13 -0800431 left = b->size - b->used;
Paul Fulghum33b37a32006-06-28 04:26:49 -0700432 else
Paul Fulghum808249c2006-02-03 03:04:41 -0800433 left = 0;
434
435 if (left < size) {
436 /* This is the slow path - looking for new buffers to use */
437 if ((n = tty_buffer_find(tty, size)) != NULL) {
438 if (b != NULL) {
439 b->next = n;
Paul Fulghum8977d922006-02-10 01:51:14 -0800440 b->commit = b->used;
Paul Fulghum808249c2006-02-03 03:04:41 -0800441 } else
442 tty->buf.head = n;
443 tty->buf.tail = n;
Paul Fulghum808249c2006-02-03 03:04:41 -0800444 } else
445 size = left;
446 }
447
448 spin_unlock_irqrestore(&tty->buf.lock, flags);
Alan Cox33f0f882006-01-09 20:54:13 -0800449 return size;
450}
Alan Cox33f0f882006-01-09 20:54:13 -0800451EXPORT_SYMBOL_GPL(tty_buffer_request_room);
452
Alan Coxaf9b8972006-08-27 01:24:01 -0700453/**
454 * tty_insert_flip_string - Add characters to the tty buffer
455 * @tty: tty structure
456 * @chars: characters
457 * @size: size
458 *
459 * Queue a series of bytes to the tty buffering. All the characters
460 * passed are marked as without error. Returns the number added.
461 *
462 * Locking: Called functions may take tty->buf.lock
463 */
464
Andrew Mortone1a25092006-04-10 22:54:05 -0700465int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
466 size_t size)
Alan Cox33f0f882006-01-09 20:54:13 -0800467{
468 int copied = 0;
469 do {
470 int space = tty_buffer_request_room(tty, size - copied);
471 struct tty_buffer *tb = tty->buf.tail;
472 /* If there is no space then tb may be NULL */
473 if(unlikely(space == 0))
474 break;
475 memcpy(tb->char_buf_ptr + tb->used, chars, space);
476 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
477 tb->used += space;
478 copied += space;
479 chars += space;
Alexey Dobriyan527063b2006-09-29 01:59:50 -0700480 /* There is a small chance that we need to split the data over
481 several buffers. If this is the case we must loop */
482 } while (unlikely(size > copied));
Alan Cox33f0f882006-01-09 20:54:13 -0800483 return copied;
484}
Andrew Mortonee37df72006-03-31 02:30:35 -0800485EXPORT_SYMBOL(tty_insert_flip_string);
Alan Cox33f0f882006-01-09 20:54:13 -0800486
Alan Coxaf9b8972006-08-27 01:24:01 -0700487/**
488 * tty_insert_flip_string_flags - Add characters to the tty buffer
489 * @tty: tty structure
490 * @chars: characters
491 * @flags: flag bytes
492 * @size: size
493 *
494 * Queue a series of bytes to the tty buffering. For each character
495 * the flags array indicates the status of the character. Returns the
496 * number added.
497 *
498 * Locking: Called functions may take tty->buf.lock
499 */
500
Andrew Mortone1a25092006-04-10 22:54:05 -0700501int tty_insert_flip_string_flags(struct tty_struct *tty,
502 const unsigned char *chars, const char *flags, size_t size)
Alan Cox33f0f882006-01-09 20:54:13 -0800503{
504 int copied = 0;
505 do {
506 int space = tty_buffer_request_room(tty, size - copied);
507 struct tty_buffer *tb = tty->buf.tail;
508 /* If there is no space then tb may be NULL */
509 if(unlikely(space == 0))
510 break;
511 memcpy(tb->char_buf_ptr + tb->used, chars, space);
512 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
513 tb->used += space;
514 copied += space;
515 chars += space;
516 flags += space;
Alexey Dobriyan527063b2006-09-29 01:59:50 -0700517 /* There is a small chance that we need to split the data over
518 several buffers. If this is the case we must loop */
519 } while (unlikely(size > copied));
Alan Cox33f0f882006-01-09 20:54:13 -0800520 return copied;
521}
Tobias Powalowskiff4547f2006-05-22 22:35:28 -0700522EXPORT_SYMBOL(tty_insert_flip_string_flags);
Alan Cox33f0f882006-01-09 20:54:13 -0800523
Alan Coxaf9b8972006-08-27 01:24:01 -0700524/**
525 * tty_schedule_flip - push characters to ldisc
526 * @tty: tty to push from
527 *
528 * Takes any pending buffers and transfers their ownership to the
529 * ldisc side of the queue. It then schedules those characters for
530 * processing by the line discipline.
531 *
532 * Locking: Takes tty->buf.lock
533 */
534
Andrew Mortone1a25092006-04-10 22:54:05 -0700535void tty_schedule_flip(struct tty_struct *tty)
536{
537 unsigned long flags;
538 spin_lock_irqsave(&tty->buf.lock, flags);
Paul Fulghum33b37a32006-06-28 04:26:49 -0700539 if (tty->buf.tail != NULL)
Andrew Mortone1a25092006-04-10 22:54:05 -0700540 tty->buf.tail->commit = tty->buf.tail->used;
Andrew Mortone1a25092006-04-10 22:54:05 -0700541 spin_unlock_irqrestore(&tty->buf.lock, flags);
542 schedule_delayed_work(&tty->buf.work, 1);
543}
544EXPORT_SYMBOL(tty_schedule_flip);
Alan Cox33f0f882006-01-09 20:54:13 -0800545
Alan Coxaf9b8972006-08-27 01:24:01 -0700546/**
547 * tty_prepare_flip_string - make room for characters
548 * @tty: tty
549 * @chars: return pointer for character write area
550 * @size: desired size
551 *
Alan Cox33f0f882006-01-09 20:54:13 -0800552 * Prepare a block of space in the buffer for data. Returns the length
553 * available and buffer pointer to the space which is now allocated and
554 * accounted for as ready for normal characters. This is used for drivers
555 * that need their own block copy routines into the buffer. There is no
556 * guarantee the buffer is a DMA target!
Alan Coxaf9b8972006-08-27 01:24:01 -0700557 *
558 * Locking: May call functions taking tty->buf.lock
Alan Cox33f0f882006-01-09 20:54:13 -0800559 */
560
561int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
562{
563 int space = tty_buffer_request_room(tty, size);
Paul Fulghum808249c2006-02-03 03:04:41 -0800564 if (likely(space)) {
565 struct tty_buffer *tb = tty->buf.tail;
566 *chars = tb->char_buf_ptr + tb->used;
567 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
568 tb->used += space;
569 }
Alan Cox33f0f882006-01-09 20:54:13 -0800570 return space;
571}
572
573EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
574
Alan Coxaf9b8972006-08-27 01:24:01 -0700575/**
576 * tty_prepare_flip_string_flags - make room for characters
577 * @tty: tty
578 * @chars: return pointer for character write area
579 * @flags: return pointer for status flag write area
580 * @size: desired size
581 *
Alan Cox33f0f882006-01-09 20:54:13 -0800582 * Prepare a block of space in the buffer for data. Returns the length
583 * available and buffer pointer to the space which is now allocated and
584 * accounted for as ready for characters. This is used for drivers
585 * that need their own block copy routines into the buffer. There is no
586 * guarantee the buffer is a DMA target!
Alan Coxaf9b8972006-08-27 01:24:01 -0700587 *
588 * Locking: May call functions taking tty->buf.lock
Alan Cox33f0f882006-01-09 20:54:13 -0800589 */
590
591int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
592{
593 int space = tty_buffer_request_room(tty, size);
Paul Fulghum808249c2006-02-03 03:04:41 -0800594 if (likely(space)) {
595 struct tty_buffer *tb = tty->buf.tail;
596 *chars = tb->char_buf_ptr + tb->used;
597 *flags = tb->flag_buf_ptr + tb->used;
598 tb->used += space;
599 }
Alan Cox33f0f882006-01-09 20:54:13 -0800600 return space;
601}
602
603EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
604
605
606
Alan Coxaf9b8972006-08-27 01:24:01 -0700607/**
608 * tty_set_termios_ldisc - set ldisc field
609 * @tty: tty structure
610 * @num: line discipline number
611 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 * This is probably overkill for real world processors but
613 * they are not on hot paths so a little discipline won't do
614 * any harm.
Alan Coxaf9b8972006-08-27 01:24:01 -0700615 *
616 * Locking: takes termios_sem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 */
618
619static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
620{
621 down(&tty->termios_sem);
622 tty->termios->c_line = num;
623 up(&tty->termios_sem);
624}
625
626/*
627 * This guards the refcounted line discipline lists. The lock
628 * must be taken with irqs off because there are hangup path
629 * callers who will do ldisc lookups and cannot sleep.
630 */
631
632static DEFINE_SPINLOCK(tty_ldisc_lock);
633static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
Alexey Dobriyanbfb07592005-06-23 00:10:32 -0700634static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Alan Coxaf9b8972006-08-27 01:24:01 -0700636/**
637 * tty_register_ldisc - install a line discipline
638 * @disc: ldisc number
639 * @new_ldisc: pointer to the ldisc object
640 *
641 * Installs a new line discipline into the kernel. The discipline
642 * is set up as unreferenced and then made available to the kernel
643 * from this point onwards.
644 *
645 * Locking:
646 * takes tty_ldisc_lock to guard against ldisc races
647 */
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
650{
651 unsigned long flags;
652 int ret = 0;
653
654 if (disc < N_TTY || disc >= NR_LDISCS)
655 return -EINVAL;
656
657 spin_lock_irqsave(&tty_ldisc_lock, flags);
Alexey Dobriyanbfb07592005-06-23 00:10:32 -0700658 tty_ldiscs[disc] = *new_ldisc;
659 tty_ldiscs[disc].num = disc;
660 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
661 tty_ldiscs[disc].refcount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
663
664 return ret;
665}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666EXPORT_SYMBOL(tty_register_ldisc);
667
Alan Coxaf9b8972006-08-27 01:24:01 -0700668/**
669 * tty_unregister_ldisc - unload a line discipline
670 * @disc: ldisc number
671 * @new_ldisc: pointer to the ldisc object
672 *
673 * Remove a line discipline from the kernel providing it is not
674 * currently in use.
675 *
676 * Locking:
677 * takes tty_ldisc_lock to guard against ldisc races
678 */
679
Alexey Dobriyanbfb07592005-06-23 00:10:32 -0700680int tty_unregister_ldisc(int disc)
681{
682 unsigned long flags;
683 int ret = 0;
684
685 if (disc < N_TTY || disc >= NR_LDISCS)
686 return -EINVAL;
687
688 spin_lock_irqsave(&tty_ldisc_lock, flags);
689 if (tty_ldiscs[disc].refcount)
690 ret = -EBUSY;
691 else
692 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
693 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
694
695 return ret;
696}
697EXPORT_SYMBOL(tty_unregister_ldisc);
698
Alan Coxaf9b8972006-08-27 01:24:01 -0700699/**
700 * tty_ldisc_get - take a reference to an ldisc
701 * @disc: ldisc number
702 *
703 * Takes a reference to a line discipline. Deals with refcounts and
704 * module locking counts. Returns NULL if the discipline is not available.
705 * Returns a pointer to the discipline and bumps the ref count if it is
706 * available
707 *
708 * Locking:
709 * takes tty_ldisc_lock to guard against ldisc races
710 */
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712struct tty_ldisc *tty_ldisc_get(int disc)
713{
714 unsigned long flags;
715 struct tty_ldisc *ld;
716
717 if (disc < N_TTY || disc >= NR_LDISCS)
718 return NULL;
719
720 spin_lock_irqsave(&tty_ldisc_lock, flags);
721
722 ld = &tty_ldiscs[disc];
723 /* Check the entry is defined */
724 if(ld->flags & LDISC_FLAG_DEFINED)
725 {
726 /* If the module is being unloaded we can't use it */
727 if (!try_module_get(ld->owner))
728 ld = NULL;
729 else /* lock it */
730 ld->refcount++;
731 }
732 else
733 ld = NULL;
734 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
735 return ld;
736}
737
738EXPORT_SYMBOL_GPL(tty_ldisc_get);
739
Alan Coxaf9b8972006-08-27 01:24:01 -0700740/**
741 * tty_ldisc_put - drop ldisc reference
742 * @disc: ldisc number
743 *
744 * Drop a reference to a line discipline. Manage refcounts and
745 * module usage counts
746 *
747 * Locking:
748 * takes tty_ldisc_lock to guard against ldisc races
749 */
750
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751void tty_ldisc_put(int disc)
752{
753 struct tty_ldisc *ld;
754 unsigned long flags;
755
Eric Sesterhenn56ee4822006-03-26 18:17:21 +0200756 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
758 spin_lock_irqsave(&tty_ldisc_lock, flags);
759 ld = &tty_ldiscs[disc];
Eric Sesterhenn56ee4822006-03-26 18:17:21 +0200760 BUG_ON(ld->refcount == 0);
761 ld->refcount--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 module_put(ld->owner);
763 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
764}
765
766EXPORT_SYMBOL_GPL(tty_ldisc_put);
767
Alan Coxaf9b8972006-08-27 01:24:01 -0700768/**
769 * tty_ldisc_assign - set ldisc on a tty
770 * @tty: tty to assign
771 * @ld: line discipline
772 *
773 * Install an instance of a line discipline into a tty structure. The
774 * ldisc must have a reference count above zero to ensure it remains/
775 * The tty instance refcount starts at zero.
776 *
777 * Locking:
778 * Caller must hold references
779 */
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
782{
783 tty->ldisc = *ld;
784 tty->ldisc.refcount = 0;
785}
786
787/**
788 * tty_ldisc_try - internal helper
789 * @tty: the tty
790 *
791 * Make a single attempt to grab and bump the refcount on
792 * the tty ldisc. Return 0 on failure or 1 on success. This is
793 * used to implement both the waiting and non waiting versions
794 * of tty_ldisc_ref
Alan Coxaf9b8972006-08-27 01:24:01 -0700795 *
796 * Locking: takes tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 */
798
799static int tty_ldisc_try(struct tty_struct *tty)
800{
801 unsigned long flags;
802 struct tty_ldisc *ld;
803 int ret = 0;
804
805 spin_lock_irqsave(&tty_ldisc_lock, flags);
806 ld = &tty->ldisc;
807 if(test_bit(TTY_LDISC, &tty->flags))
808 {
809 ld->refcount++;
810 ret = 1;
811 }
812 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
813 return ret;
814}
815
816/**
817 * tty_ldisc_ref_wait - wait for the tty ldisc
818 * @tty: tty device
819 *
820 * Dereference the line discipline for the terminal and take a
821 * reference to it. If the line discipline is in flux then
822 * wait patiently until it changes.
823 *
824 * Note: Must not be called from an IRQ/timer context. The caller
825 * must also be careful not to hold other locks that will deadlock
826 * against a discipline change, such as an existing ldisc reference
827 * (which we check for)
Alan Coxaf9b8972006-08-27 01:24:01 -0700828 *
829 * Locking: call functions take tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 */
831
832struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
833{
834 /* wait_event is a macro */
835 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
836 if(tty->ldisc.refcount == 0)
837 printk(KERN_ERR "tty_ldisc_ref_wait\n");
838 return &tty->ldisc;
839}
840
841EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
842
843/**
844 * tty_ldisc_ref - get the tty ldisc
845 * @tty: tty device
846 *
847 * Dereference the line discipline for the terminal and take a
848 * reference to it. If the line discipline is in flux then
849 * return NULL. Can be called from IRQ and timer functions.
Alan Coxaf9b8972006-08-27 01:24:01 -0700850 *
851 * Locking: called functions take tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 */
853
854struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
855{
856 if(tty_ldisc_try(tty))
857 return &tty->ldisc;
858 return NULL;
859}
860
861EXPORT_SYMBOL_GPL(tty_ldisc_ref);
862
863/**
864 * tty_ldisc_deref - free a tty ldisc reference
865 * @ld: reference to free up
866 *
867 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
868 * be called in IRQ context.
Alan Coxaf9b8972006-08-27 01:24:01 -0700869 *
870 * Locking: takes tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 */
872
873void tty_ldisc_deref(struct tty_ldisc *ld)
874{
875 unsigned long flags;
876
Eric Sesterhenn56ee4822006-03-26 18:17:21 +0200877 BUG_ON(ld == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
879 spin_lock_irqsave(&tty_ldisc_lock, flags);
880 if(ld->refcount == 0)
881 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
882 else
883 ld->refcount--;
884 if(ld->refcount == 0)
885 wake_up(&tty_ldisc_wait);
886 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
887}
888
889EXPORT_SYMBOL_GPL(tty_ldisc_deref);
890
891/**
892 * tty_ldisc_enable - allow ldisc use
893 * @tty: terminal to activate ldisc on
894 *
895 * Set the TTY_LDISC flag when the line discipline can be called
896 * again. Do neccessary wakeups for existing sleepers.
897 *
898 * Note: nobody should set this bit except via this function. Clearing
899 * directly is allowed.
900 */
901
902static void tty_ldisc_enable(struct tty_struct *tty)
903{
904 set_bit(TTY_LDISC, &tty->flags);
905 wake_up(&tty_ldisc_wait);
906}
907
908/**
909 * tty_set_ldisc - set line discipline
910 * @tty: the terminal to set
911 * @ldisc: the line discipline
912 *
913 * Set the discipline of a tty line. Must be called from a process
914 * context.
Alan Coxaf9b8972006-08-27 01:24:01 -0700915 *
916 * Locking: takes tty_ldisc_lock.
917 * called functions take termios_sem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 */
919
920static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
921{
Jason Baronff55fe22005-09-09 13:01:57 -0700922 int retval = 0;
923 struct tty_ldisc o_ldisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 char buf[64];
925 int work;
926 unsigned long flags;
927 struct tty_ldisc *ld;
Jason Baronff55fe22005-09-09 13:01:57 -0700928 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
931 return -EINVAL;
932
933restart:
934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 ld = tty_ldisc_get(ldisc);
936 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
937 /* Cyrus Durgin <cider@speakeasy.org> */
938 if (ld == NULL) {
939 request_module("tty-ldisc-%d", ldisc);
940 ld = tty_ldisc_get(ldisc);
941 }
942 if (ld == NULL)
943 return -EINVAL;
944
Alan Cox33f0f882006-01-09 20:54:13 -0800945 /*
946 * No more input please, we are switching. The new ldisc
947 * will update this value in the ldisc open function
948 */
949
950 tty->receive_room = 0;
951
952 /*
953 * Problem: What do we do if this blocks ?
954 */
955
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 tty_wait_until_sent(tty, 0);
957
Jason Baronff55fe22005-09-09 13:01:57 -0700958 if (tty->ldisc.num == ldisc) {
959 tty_ldisc_put(ldisc);
960 return 0;
961 }
962
963 o_ldisc = tty->ldisc;
964 o_tty = tty->link;
965
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 /*
967 * Make sure we don't change while someone holds a
968 * reference to the line discipline. The TTY_LDISC bit
969 * prevents anyone taking a reference once it is clear.
970 * We need the lock to avoid racing reference takers.
971 */
Jason Baronff55fe22005-09-09 13:01:57 -0700972
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 spin_lock_irqsave(&tty_ldisc_lock, flags);
Jason Baronff55fe22005-09-09 13:01:57 -0700974 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
975 if(tty->ldisc.refcount) {
976 /* Free the new ldisc we grabbed. Must drop the lock
977 first. */
978 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
979 tty_ldisc_put(ldisc);
980 /*
981 * There are several reasons we may be busy, including
982 * random momentary I/O traffic. We must therefore
983 * retry. We could distinguish between blocking ops
984 * and retries if we made tty_ldisc_wait() smarter. That
985 * is up for discussion.
986 */
987 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
988 return -ERESTARTSYS;
989 goto restart;
990 }
991 if(o_tty && o_tty->ldisc.refcount) {
992 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
993 tty_ldisc_put(ldisc);
994 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
995 return -ERESTARTSYS;
996 goto restart;
997 }
998 }
999
1000 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
1001
1002 if (!test_bit(TTY_LDISC, &tty->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1004 tty_ldisc_put(ldisc);
Jason Baronff55fe22005-09-09 13:01:57 -07001005 ld = tty_ldisc_ref_wait(tty);
1006 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 goto restart;
1008 }
Jason Baronff55fe22005-09-09 13:01:57 -07001009
1010 clear_bit(TTY_LDISC, &tty->flags);
Paul Fulghum817d6d32006-06-28 04:26:47 -07001011 if (o_tty)
Jason Baronff55fe22005-09-09 13:01:57 -07001012 clear_bit(TTY_LDISC, &o_tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
Jason Baronff55fe22005-09-09 13:01:57 -07001014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 /*
1016 * From this point on we know nobody has an ldisc
1017 * usage reference, nor can they obtain one until
1018 * we say so later on.
1019 */
Jason Baronff55fe22005-09-09 13:01:57 -07001020
Alan Cox33f0f882006-01-09 20:54:13 -08001021 work = cancel_delayed_work(&tty->buf.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 /*
Alan Cox33f0f882006-01-09 20:54:13 -08001023 * Wait for ->hangup_work and ->buf.work handlers to terminate
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 */
1025
1026 flush_scheduled_work();
1027 /* Shutdown the current discipline. */
1028 if (tty->ldisc.close)
1029 (tty->ldisc.close)(tty);
1030
1031 /* Now set up the new line discipline. */
1032 tty_ldisc_assign(tty, ld);
1033 tty_set_termios_ldisc(tty, ldisc);
1034 if (tty->ldisc.open)
1035 retval = (tty->ldisc.open)(tty);
1036 if (retval < 0) {
1037 tty_ldisc_put(ldisc);
1038 /* There is an outstanding reference here so this is safe */
1039 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1040 tty_set_termios_ldisc(tty, tty->ldisc.num);
1041 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1042 tty_ldisc_put(o_ldisc.num);
1043 /* This driver is always present */
1044 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1045 tty_set_termios_ldisc(tty, N_TTY);
1046 if (tty->ldisc.open) {
1047 int r = tty->ldisc.open(tty);
1048
1049 if (r < 0)
1050 panic("Couldn't open N_TTY ldisc for "
1051 "%s --- error %d.",
1052 tty_name(tty, buf), r);
1053 }
1054 }
1055 }
1056 /* At this point we hold a reference to the new ldisc and a
1057 a reference to the old ldisc. If we ended up flipping back
1058 to the existing ldisc we have two references to it */
1059
1060 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1061 tty->driver->set_ldisc(tty);
1062
1063 tty_ldisc_put(o_ldisc.num);
1064
1065 /*
1066 * Allow ldisc referencing to occur as soon as the driver
1067 * ldisc callback completes.
1068 */
1069
1070 tty_ldisc_enable(tty);
Jason Baronff55fe22005-09-09 13:01:57 -07001071 if (o_tty)
1072 tty_ldisc_enable(o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
1074 /* Restart it in case no characters kick it off. Safe if
1075 already running */
Jason Baronff55fe22005-09-09 13:01:57 -07001076 if (work)
Alan Cox33f0f882006-01-09 20:54:13 -08001077 schedule_delayed_work(&tty->buf.work, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 return retval;
1079}
1080
Alan Coxaf9b8972006-08-27 01:24:01 -07001081/**
1082 * get_tty_driver - find device of a tty
1083 * @dev_t: device identifier
1084 * @index: returns the index of the tty
1085 *
1086 * This routine returns a tty driver structure, given a device number
1087 * and also passes back the index number.
1088 *
1089 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092static struct tty_driver *get_tty_driver(dev_t device, int *index)
1093{
1094 struct tty_driver *p;
1095
1096 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1097 dev_t base = MKDEV(p->major, p->minor_start);
1098 if (device < base || device >= base + p->num)
1099 continue;
1100 *index = device - base;
1101 return p;
1102 }
1103 return NULL;
1104}
1105
Alan Coxaf9b8972006-08-27 01:24:01 -07001106/**
1107 * tty_check_change - check for POSIX terminal changes
1108 * @tty: tty to check
1109 *
1110 * If we try to write to, or set the state of, a terminal and we're
1111 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1112 * ignored, go ahead and perform the operation. (POSIX 7.2)
1113 *
1114 * Locking: none
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117int tty_check_change(struct tty_struct * tty)
1118{
1119 if (current->signal->tty != tty)
1120 return 0;
1121 if (tty->pgrp <= 0) {
1122 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1123 return 0;
1124 }
1125 if (process_group(current) == tty->pgrp)
1126 return 0;
1127 if (is_ignored(SIGTTOU))
1128 return 0;
1129 if (is_orphaned_pgrp(process_group(current)))
1130 return -EIO;
1131 (void) kill_pg(process_group(current), SIGTTOU, 1);
1132 return -ERESTARTSYS;
1133}
1134
1135EXPORT_SYMBOL(tty_check_change);
1136
1137static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1138 size_t count, loff_t *ppos)
1139{
1140 return 0;
1141}
1142
1143static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1144 size_t count, loff_t *ppos)
1145{
1146 return -EIO;
1147}
1148
1149/* No kernel lock held - none needed ;) */
1150static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1151{
1152 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1153}
1154
1155static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1156 unsigned int cmd, unsigned long arg)
1157{
1158 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1159}
1160
Arjan van de Ven62322d22006-07-03 00:24:21 -07001161static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 .llseek = no_llseek,
1163 .read = tty_read,
1164 .write = tty_write,
1165 .poll = tty_poll,
1166 .ioctl = tty_ioctl,
1167 .open = tty_open,
1168 .release = tty_release,
1169 .fasync = tty_fasync,
1170};
1171
1172#ifdef CONFIG_UNIX98_PTYS
Arjan van de Ven62322d22006-07-03 00:24:21 -07001173static const struct file_operations ptmx_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 .llseek = no_llseek,
1175 .read = tty_read,
1176 .write = tty_write,
1177 .poll = tty_poll,
1178 .ioctl = tty_ioctl,
1179 .open = ptmx_open,
1180 .release = tty_release,
1181 .fasync = tty_fasync,
1182};
1183#endif
1184
Arjan van de Ven62322d22006-07-03 00:24:21 -07001185static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 .llseek = no_llseek,
1187 .read = tty_read,
1188 .write = redirected_tty_write,
1189 .poll = tty_poll,
1190 .ioctl = tty_ioctl,
1191 .open = tty_open,
1192 .release = tty_release,
1193 .fasync = tty_fasync,
1194};
1195
Arjan van de Ven62322d22006-07-03 00:24:21 -07001196static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 .llseek = no_llseek,
1198 .read = hung_up_tty_read,
1199 .write = hung_up_tty_write,
1200 .poll = hung_up_tty_poll,
1201 .ioctl = hung_up_tty_ioctl,
1202 .release = tty_release,
1203};
1204
1205static DEFINE_SPINLOCK(redirect_lock);
1206static struct file *redirect;
1207
1208/**
1209 * tty_wakeup - request more data
1210 * @tty: terminal
1211 *
1212 * Internal and external helper for wakeups of tty. This function
1213 * informs the line discipline if present that the driver is ready
1214 * to receive more output data.
1215 */
1216
1217void tty_wakeup(struct tty_struct *tty)
1218{
1219 struct tty_ldisc *ld;
1220
1221 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1222 ld = tty_ldisc_ref(tty);
1223 if(ld) {
1224 if(ld->write_wakeup)
1225 ld->write_wakeup(tty);
1226 tty_ldisc_deref(ld);
1227 }
1228 }
1229 wake_up_interruptible(&tty->write_wait);
1230}
1231
1232EXPORT_SYMBOL_GPL(tty_wakeup);
1233
1234/**
1235 * tty_ldisc_flush - flush line discipline queue
1236 * @tty: tty
1237 *
1238 * Flush the line discipline queue (if any) for this tty. If there
1239 * is no line discipline active this is a no-op.
1240 */
1241
1242void tty_ldisc_flush(struct tty_struct *tty)
1243{
1244 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1245 if(ld) {
1246 if(ld->flush_buffer)
1247 ld->flush_buffer(tty);
1248 tty_ldisc_deref(ld);
1249 }
1250}
1251
1252EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1253
Alan Coxaf9b8972006-08-27 01:24:01 -07001254/**
1255 * do_tty_hangup - actual handler for hangup events
1256 * @data: tty device
1257 *
1258 * This can be called by the "eventd" kernel thread. That is process
1259 * synchronous but doesn't hold any locks, so we need to make sure we
1260 * have the appropriate locks for what we're doing.
1261 *
1262 * The hangup event clears any pending redirections onto the hung up
1263 * device. It ensures future writes will error and it does the needed
1264 * line discipline hangup and signal delivery. The tty object itself
1265 * remains intact.
1266 *
1267 * Locking:
1268 * BKL
1269 * redirect lock for undoing redirection
1270 * file list lock for manipulating list of ttys
1271 * tty_ldisc_lock from called functions
1272 * termios_sem resetting termios data
1273 * tasklist_lock to walk task list for hangup event
1274 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 */
1276static void do_tty_hangup(void *data)
1277{
1278 struct tty_struct *tty = (struct tty_struct *) data;
1279 struct file * cons_filp = NULL;
1280 struct file *filp, *f = NULL;
1281 struct task_struct *p;
1282 struct tty_ldisc *ld;
1283 int closecount = 0, n;
1284
1285 if (!tty)
1286 return;
1287
1288 /* inuse_filps is protected by the single kernel lock */
1289 lock_kernel();
1290
1291 spin_lock(&redirect_lock);
1292 if (redirect && redirect->private_data == tty) {
1293 f = redirect;
1294 redirect = NULL;
1295 }
1296 spin_unlock(&redirect_lock);
1297
1298 check_tty_count(tty, "do_tty_hangup");
1299 file_list_lock();
1300 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Eric Dumazet2f512012005-10-30 15:02:16 -08001301 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 if (filp->f_op->write == redirected_tty_write)
1303 cons_filp = filp;
1304 if (filp->f_op->write != tty_write)
1305 continue;
1306 closecount++;
1307 tty_fasync(-1, filp, 0); /* can't block */
1308 filp->f_op = &hung_up_tty_fops;
1309 }
1310 file_list_unlock();
1311
1312 /* FIXME! What are the locking issues here? This may me overdoing things..
1313 * this question is especially important now that we've removed the irqlock. */
1314
1315 ld = tty_ldisc_ref(tty);
1316 if(ld != NULL) /* We may have no line discipline at this point */
1317 {
1318 if (ld->flush_buffer)
1319 ld->flush_buffer(tty);
1320 if (tty->driver->flush_buffer)
1321 tty->driver->flush_buffer(tty);
1322 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1323 ld->write_wakeup)
1324 ld->write_wakeup(tty);
1325 if (ld->hangup)
1326 ld->hangup(tty);
1327 }
1328
1329 /* FIXME: Once we trust the LDISC code better we can wait here for
1330 ldisc completion and fix the driver call race */
1331
1332 wake_up_interruptible(&tty->write_wait);
1333 wake_up_interruptible(&tty->read_wait);
1334
1335 /*
1336 * Shutdown the current line discipline, and reset it to
1337 * N_TTY.
1338 */
1339 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1340 {
1341 down(&tty->termios_sem);
1342 *tty->termios = tty->driver->init_termios;
1343 up(&tty->termios_sem);
1344 }
1345
1346 /* Defer ldisc switch */
1347 /* tty_deferred_ldisc_switch(N_TTY);
1348
1349 This should get done automatically when the port closes and
1350 tty_release is called */
1351
1352 read_lock(&tasklist_lock);
1353 if (tty->session > 0) {
1354 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1355 if (p->signal->tty == tty)
1356 p->signal->tty = NULL;
1357 if (!p->signal->leader)
1358 continue;
Eric W. Biedermanf96a7952006-03-28 16:11:01 -08001359 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1360 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 if (tty->pgrp > 0)
1362 p->signal->tty_old_pgrp = tty->pgrp;
1363 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1364 }
1365 read_unlock(&tasklist_lock);
1366
1367 tty->flags = 0;
1368 tty->session = 0;
1369 tty->pgrp = -1;
1370 tty->ctrl_status = 0;
1371 /*
1372 * If one of the devices matches a console pointer, we
1373 * cannot just call hangup() because that will cause
1374 * tty->count and state->count to go out of sync.
1375 * So we just call close() the right number of times.
1376 */
1377 if (cons_filp) {
1378 if (tty->driver->close)
1379 for (n = 0; n < closecount; n++)
1380 tty->driver->close(tty, cons_filp);
1381 } else if (tty->driver->hangup)
1382 (tty->driver->hangup)(tty);
1383
1384 /* We don't want to have driver/ldisc interactions beyond
1385 the ones we did here. The driver layer expects no
1386 calls after ->hangup() from the ldisc side. However we
1387 can't yet guarantee all that */
1388
1389 set_bit(TTY_HUPPED, &tty->flags);
1390 if (ld) {
1391 tty_ldisc_enable(tty);
1392 tty_ldisc_deref(ld);
1393 }
1394 unlock_kernel();
1395 if (f)
1396 fput(f);
1397}
1398
Alan Coxaf9b8972006-08-27 01:24:01 -07001399/**
1400 * tty_hangup - trigger a hangup event
1401 * @tty: tty to hangup
1402 *
1403 * A carrier loss (virtual or otherwise) has occurred on this like
1404 * schedule a hangup sequence to run after this event.
1405 */
1406
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407void tty_hangup(struct tty_struct * tty)
1408{
1409#ifdef TTY_DEBUG_HANGUP
1410 char buf[64];
1411
1412 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1413#endif
1414 schedule_work(&tty->hangup_work);
1415}
1416
1417EXPORT_SYMBOL(tty_hangup);
1418
Alan Coxaf9b8972006-08-27 01:24:01 -07001419/**
1420 * tty_vhangup - process vhangup
1421 * @tty: tty to hangup
1422 *
1423 * The user has asked via system call for the terminal to be hung up.
1424 * We do this synchronously so that when the syscall returns the process
1425 * is complete. That guarantee is neccessary for security reasons.
1426 */
1427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428void tty_vhangup(struct tty_struct * tty)
1429{
1430#ifdef TTY_DEBUG_HANGUP
1431 char buf[64];
1432
1433 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1434#endif
1435 do_tty_hangup((void *) tty);
1436}
1437EXPORT_SYMBOL(tty_vhangup);
1438
Alan Coxaf9b8972006-08-27 01:24:01 -07001439/**
1440 * tty_hung_up_p - was tty hung up
1441 * @filp: file pointer of tty
1442 *
1443 * Return true if the tty has been subject to a vhangup or a carrier
1444 * loss
1445 */
1446
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447int tty_hung_up_p(struct file * filp)
1448{
1449 return (filp->f_op == &hung_up_tty_fops);
1450}
1451
1452EXPORT_SYMBOL(tty_hung_up_p);
1453
Alan Coxaf9b8972006-08-27 01:24:01 -07001454/**
1455 * disassociate_ctty - disconnect controlling tty
1456 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001458 * This function is typically called only by the session leader, when
1459 * it wants to disassociate itself from its controlling tty.
1460 *
1461 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1463 * (2) Clears the tty from being controlling the session
1464 * (3) Clears the controlling tty for all processes in the
1465 * session group.
1466 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001467 * The argument on_exit is set to 1 if called when a process is
1468 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1469 *
1470 * Locking: tty_mutex is taken to protect current->signal->tty
1471 * BKL is taken for hysterical raisins
1472 * Tasklist lock is taken (under tty_mutex) to walk process
1473 * lists for the session.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001475
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476void disassociate_ctty(int on_exit)
1477{
1478 struct tty_struct *tty;
1479 struct task_struct *p;
1480 int tty_pgrp = -1;
1481
1482 lock_kernel();
1483
Ingo Molnar70522e12006-03-23 03:00:31 -08001484 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 tty = current->signal->tty;
1486 if (tty) {
1487 tty_pgrp = tty->pgrp;
Ingo Molnar70522e12006-03-23 03:00:31 -08001488 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1490 tty_vhangup(tty);
1491 } else {
1492 if (current->signal->tty_old_pgrp) {
1493 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1494 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1495 }
Ingo Molnar70522e12006-03-23 03:00:31 -08001496 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 unlock_kernel();
1498 return;
1499 }
1500 if (tty_pgrp > 0) {
1501 kill_pg(tty_pgrp, SIGHUP, on_exit);
1502 if (!on_exit)
1503 kill_pg(tty_pgrp, SIGCONT, on_exit);
1504 }
1505
1506 /* Must lock changes to tty_old_pgrp */
Ingo Molnar70522e12006-03-23 03:00:31 -08001507 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 current->signal->tty_old_pgrp = 0;
1509 tty->session = 0;
1510 tty->pgrp = -1;
1511
1512 /* Now clear signal->tty under the lock */
1513 read_lock(&tasklist_lock);
1514 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1515 p->signal->tty = NULL;
1516 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1517 read_unlock(&tasklist_lock);
Ingo Molnar70522e12006-03-23 03:00:31 -08001518 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 unlock_kernel();
1520}
1521
Alan Coxaf9b8972006-08-27 01:24:01 -07001522
1523/**
1524 * stop_tty - propogate flow control
1525 * @tty: tty to stop
1526 *
1527 * Perform flow control to the driver. For PTY/TTY pairs we
1528 * must also propogate the TIOCKPKT status. May be called
1529 * on an already stopped device and will not re-call the driver
1530 * method.
1531 *
1532 * This functionality is used by both the line disciplines for
1533 * halting incoming flow and by the driver. It may therefore be
1534 * called from any context, may be under the tty atomic_write_lock
1535 * but not always.
1536 *
1537 * Locking:
1538 * Broken. Relies on BKL which is unsafe here.
1539 */
1540
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541void stop_tty(struct tty_struct *tty)
1542{
1543 if (tty->stopped)
1544 return;
1545 tty->stopped = 1;
1546 if (tty->link && tty->link->packet) {
1547 tty->ctrl_status &= ~TIOCPKT_START;
1548 tty->ctrl_status |= TIOCPKT_STOP;
1549 wake_up_interruptible(&tty->link->read_wait);
1550 }
1551 if (tty->driver->stop)
1552 (tty->driver->stop)(tty);
1553}
1554
1555EXPORT_SYMBOL(stop_tty);
1556
Alan Coxaf9b8972006-08-27 01:24:01 -07001557/**
1558 * start_tty - propogate flow control
1559 * @tty: tty to start
1560 *
1561 * Start a tty that has been stopped if at all possible. Perform
1562 * any neccessary wakeups and propogate the TIOCPKT status. If this
1563 * is the tty was previous stopped and is being started then the
1564 * driver start method is invoked and the line discipline woken.
1565 *
1566 * Locking:
1567 * Broken. Relies on BKL which is unsafe here.
1568 */
1569
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570void start_tty(struct tty_struct *tty)
1571{
1572 if (!tty->stopped || tty->flow_stopped)
1573 return;
1574 tty->stopped = 0;
1575 if (tty->link && tty->link->packet) {
1576 tty->ctrl_status &= ~TIOCPKT_STOP;
1577 tty->ctrl_status |= TIOCPKT_START;
1578 wake_up_interruptible(&tty->link->read_wait);
1579 }
1580 if (tty->driver->start)
1581 (tty->driver->start)(tty);
1582
1583 /* If we have a running line discipline it may need kicking */
1584 tty_wakeup(tty);
1585 wake_up_interruptible(&tty->write_wait);
1586}
1587
1588EXPORT_SYMBOL(start_tty);
1589
Alan Coxaf9b8972006-08-27 01:24:01 -07001590/**
1591 * tty_read - read method for tty device files
1592 * @file: pointer to tty file
1593 * @buf: user buffer
1594 * @count: size of user buffer
1595 * @ppos: unused
1596 *
1597 * Perform the read system call function on this terminal device. Checks
1598 * for hung up devices before calling the line discipline method.
1599 *
1600 * Locking:
1601 * Locks the line discipline internally while needed
1602 * For historical reasons the line discipline read method is
1603 * invoked under the BKL. This will go away in time so do not rely on it
1604 * in new code. Multiple read calls may be outstanding in parallel.
1605 */
1606
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1608 loff_t *ppos)
1609{
1610 int i;
1611 struct tty_struct * tty;
1612 struct inode *inode;
1613 struct tty_ldisc *ld;
1614
1615 tty = (struct tty_struct *)file->private_data;
1616 inode = file->f_dentry->d_inode;
1617 if (tty_paranoia_check(tty, inode, "tty_read"))
1618 return -EIO;
1619 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1620 return -EIO;
1621
1622 /* We want to wait for the line discipline to sort out in this
1623 situation */
1624 ld = tty_ldisc_ref_wait(tty);
1625 lock_kernel();
1626 if (ld->read)
1627 i = (ld->read)(tty,file,buf,count);
1628 else
1629 i = -EIO;
1630 tty_ldisc_deref(ld);
1631 unlock_kernel();
1632 if (i > 0)
1633 inode->i_atime = current_fs_time(inode->i_sb);
1634 return i;
1635}
1636
1637/*
1638 * Split writes up in sane blocksizes to avoid
1639 * denial-of-service type attacks
1640 */
1641static inline ssize_t do_tty_write(
1642 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1643 struct tty_struct *tty,
1644 struct file *file,
1645 const char __user *buf,
1646 size_t count)
1647{
1648 ssize_t ret = 0, written = 0;
1649 unsigned int chunk;
1650
Alan Coxaf9b8972006-08-27 01:24:01 -07001651 /* FIXME: O_NDELAY ... */
Ingo Molnar70522e12006-03-23 03:00:31 -08001652 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 return -ERESTARTSYS;
1654 }
1655
1656 /*
1657 * We chunk up writes into a temporary buffer. This
1658 * simplifies low-level drivers immensely, since they
1659 * don't have locking issues and user mode accesses.
1660 *
1661 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1662 * big chunk-size..
1663 *
1664 * The default chunk-size is 2kB, because the NTTY
1665 * layer has problems with bigger chunks. It will
1666 * claim to be able to handle more characters than
1667 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001668 *
1669 * FIXME: This can probably go away now except that 64K chunks
1670 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 */
1672 chunk = 2048;
1673 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1674 chunk = 65536;
1675 if (count < chunk)
1676 chunk = count;
1677
Ingo Molnar70522e12006-03-23 03:00:31 -08001678 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 if (tty->write_cnt < chunk) {
1680 unsigned char *buf;
1681
1682 if (chunk < 1024)
1683 chunk = 1024;
1684
1685 buf = kmalloc(chunk, GFP_KERNEL);
1686 if (!buf) {
Ingo Molnar70522e12006-03-23 03:00:31 -08001687 mutex_unlock(&tty->atomic_write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 return -ENOMEM;
1689 }
1690 kfree(tty->write_buf);
1691 tty->write_cnt = chunk;
1692 tty->write_buf = buf;
1693 }
1694
1695 /* Do the write .. */
1696 for (;;) {
1697 size_t size = count;
1698 if (size > chunk)
1699 size = chunk;
1700 ret = -EFAULT;
1701 if (copy_from_user(tty->write_buf, buf, size))
1702 break;
1703 lock_kernel();
1704 ret = write(tty, file, tty->write_buf, size);
1705 unlock_kernel();
1706 if (ret <= 0)
1707 break;
1708 written += ret;
1709 buf += ret;
1710 count -= ret;
1711 if (!count)
1712 break;
1713 ret = -ERESTARTSYS;
1714 if (signal_pending(current))
1715 break;
1716 cond_resched();
1717 }
1718 if (written) {
1719 struct inode *inode = file->f_dentry->d_inode;
1720 inode->i_mtime = current_fs_time(inode->i_sb);
1721 ret = written;
1722 }
Ingo Molnar70522e12006-03-23 03:00:31 -08001723 mutex_unlock(&tty->atomic_write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 return ret;
1725}
1726
1727
Alan Coxaf9b8972006-08-27 01:24:01 -07001728/**
1729 * tty_write - write method for tty device file
1730 * @file: tty file pointer
1731 * @buf: user data to write
1732 * @count: bytes to write
1733 * @ppos: unused
1734 *
1735 * Write data to a tty device via the line discipline.
1736 *
1737 * Locking:
1738 * Locks the line discipline as required
1739 * Writes to the tty driver are serialized by the atomic_write_lock
1740 * and are then processed in chunks to the device. The line discipline
1741 * write method will not be involked in parallel for each device
1742 * The line discipline write method is called under the big
1743 * kernel lock for historical reasons. New code should not rely on this.
1744 */
1745
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1747 loff_t *ppos)
1748{
1749 struct tty_struct * tty;
1750 struct inode *inode = file->f_dentry->d_inode;
1751 ssize_t ret;
1752 struct tty_ldisc *ld;
1753
1754 tty = (struct tty_struct *)file->private_data;
1755 if (tty_paranoia_check(tty, inode, "tty_write"))
1756 return -EIO;
1757 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1758 return -EIO;
1759
1760 ld = tty_ldisc_ref_wait(tty);
1761 if (!ld->write)
1762 ret = -EIO;
1763 else
1764 ret = do_tty_write(ld->write, tty, file, buf, count);
1765 tty_ldisc_deref(ld);
1766 return ret;
1767}
1768
1769ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1770 loff_t *ppos)
1771{
1772 struct file *p = NULL;
1773
1774 spin_lock(&redirect_lock);
1775 if (redirect) {
1776 get_file(redirect);
1777 p = redirect;
1778 }
1779 spin_unlock(&redirect_lock);
1780
1781 if (p) {
1782 ssize_t res;
1783 res = vfs_write(p, buf, count, &p->f_pos);
1784 fput(p);
1785 return res;
1786 }
1787
1788 return tty_write(file, buf, count, ppos);
1789}
1790
1791static char ptychar[] = "pqrstuvwxyzabcde";
1792
Alan Coxaf9b8972006-08-27 01:24:01 -07001793/**
1794 * pty_line_name - generate name for a pty
1795 * @driver: the tty driver in use
1796 * @index: the minor number
1797 * @p: output buffer of at least 6 bytes
1798 *
1799 * Generate a name from a driver reference and write it to the output
1800 * buffer.
1801 *
1802 * Locking: None
1803 */
1804static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805{
1806 int i = index + driver->name_base;
1807 /* ->name is initialized to "ttyp", but "tty" is expected */
1808 sprintf(p, "%s%c%x",
1809 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1810 ptychar[i >> 4 & 0xf], i & 0xf);
1811}
1812
Alan Coxaf9b8972006-08-27 01:24:01 -07001813/**
1814 * pty_line_name - generate name for a tty
1815 * @driver: the tty driver in use
1816 * @index: the minor number
1817 * @p: output buffer of at least 7 bytes
1818 *
1819 * Generate a name from a driver reference and write it to the output
1820 * buffer.
1821 *
1822 * Locking: None
1823 */
1824static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825{
1826 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1827}
1828
Alan Coxaf9b8972006-08-27 01:24:01 -07001829/**
1830 * init_dev - initialise a tty device
1831 * @driver: tty driver we are opening a device on
1832 * @idx: device index
1833 * @tty: returned tty structure
1834 *
1835 * Prepare a tty device. This may not be a "new" clean device but
1836 * could also be an active device. The pty drivers require special
1837 * handling because of this.
1838 *
1839 * Locking:
1840 * The function is called under the tty_mutex, which
1841 * protects us from the tty struct or driver itself going away.
1842 *
1843 * On exit the tty device has the line discipline attached and
1844 * a reference count of 1. If a pair was created for pty/tty use
1845 * and the other was a pty master then it too has a reference count of 1.
1846 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001848 * failed open. The new code protects the open with a mutex, so it's
1849 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 * relaxed for the (most common) case of reopening a tty.
1851 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001852
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853static int init_dev(struct tty_driver *driver, int idx,
1854 struct tty_struct **ret_tty)
1855{
1856 struct tty_struct *tty, *o_tty;
1857 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1858 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
Alan Coxaf9b8972006-08-27 01:24:01 -07001859 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860
1861 /* check whether we're reopening an existing tty */
1862 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1863 tty = devpts_get_tty(idx);
1864 if (tty && driver->subtype == PTY_TYPE_MASTER)
1865 tty = tty->link;
1866 } else {
1867 tty = driver->ttys[idx];
1868 }
1869 if (tty) goto fast_track;
1870
1871 /*
1872 * First time open is complex, especially for PTY devices.
1873 * This code guarantees that either everything succeeds and the
1874 * TTY is ready for operation, or else the table slots are vacated
1875 * and the allocated memory released. (Except that the termios
1876 * and locked termios may be retained.)
1877 */
1878
1879 if (!try_module_get(driver->owner)) {
1880 retval = -ENODEV;
1881 goto end_init;
1882 }
1883
1884 o_tty = NULL;
1885 tp = o_tp = NULL;
1886 ltp = o_ltp = NULL;
1887
1888 tty = alloc_tty_struct();
1889 if(!tty)
1890 goto fail_no_mem;
1891 initialize_tty_struct(tty);
1892 tty->driver = driver;
1893 tty->index = idx;
1894 tty_line_name(driver, idx, tty->name);
1895
1896 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1897 tp_loc = &tty->termios;
1898 ltp_loc = &tty->termios_locked;
1899 } else {
1900 tp_loc = &driver->termios[idx];
1901 ltp_loc = &driver->termios_locked[idx];
1902 }
1903
1904 if (!*tp_loc) {
1905 tp = (struct termios *) kmalloc(sizeof(struct termios),
1906 GFP_KERNEL);
1907 if (!tp)
1908 goto free_mem_out;
1909 *tp = driver->init_termios;
1910 }
1911
1912 if (!*ltp_loc) {
1913 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1914 GFP_KERNEL);
1915 if (!ltp)
1916 goto free_mem_out;
1917 memset(ltp, 0, sizeof(struct termios));
1918 }
1919
1920 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1921 o_tty = alloc_tty_struct();
1922 if (!o_tty)
1923 goto free_mem_out;
1924 initialize_tty_struct(o_tty);
1925 o_tty->driver = driver->other;
1926 o_tty->index = idx;
1927 tty_line_name(driver->other, idx, o_tty->name);
1928
1929 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1930 o_tp_loc = &o_tty->termios;
1931 o_ltp_loc = &o_tty->termios_locked;
1932 } else {
1933 o_tp_loc = &driver->other->termios[idx];
1934 o_ltp_loc = &driver->other->termios_locked[idx];
1935 }
1936
1937 if (!*o_tp_loc) {
1938 o_tp = (struct termios *)
1939 kmalloc(sizeof(struct termios), GFP_KERNEL);
1940 if (!o_tp)
1941 goto free_mem_out;
1942 *o_tp = driver->other->init_termios;
1943 }
1944
1945 if (!*o_ltp_loc) {
1946 o_ltp = (struct termios *)
1947 kmalloc(sizeof(struct termios), GFP_KERNEL);
1948 if (!o_ltp)
1949 goto free_mem_out;
1950 memset(o_ltp, 0, sizeof(struct termios));
1951 }
1952
1953 /*
1954 * Everything allocated ... set up the o_tty structure.
1955 */
1956 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1957 driver->other->ttys[idx] = o_tty;
1958 }
1959 if (!*o_tp_loc)
1960 *o_tp_loc = o_tp;
1961 if (!*o_ltp_loc)
1962 *o_ltp_loc = o_ltp;
1963 o_tty->termios = *o_tp_loc;
1964 o_tty->termios_locked = *o_ltp_loc;
1965 driver->other->refcount++;
1966 if (driver->subtype == PTY_TYPE_MASTER)
1967 o_tty->count++;
1968
1969 /* Establish the links in both directions */
1970 tty->link = o_tty;
1971 o_tty->link = tty;
1972 }
1973
1974 /*
1975 * All structures have been allocated, so now we install them.
1976 * Failures after this point use release_mem to clean up, so
1977 * there's no need to null out the local pointers.
1978 */
1979 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1980 driver->ttys[idx] = tty;
1981 }
1982
1983 if (!*tp_loc)
1984 *tp_loc = tp;
1985 if (!*ltp_loc)
1986 *ltp_loc = ltp;
1987 tty->termios = *tp_loc;
1988 tty->termios_locked = *ltp_loc;
1989 driver->refcount++;
1990 tty->count++;
1991
1992 /*
1993 * Structures all installed ... call the ldisc open routines.
1994 * If we fail here just call release_mem to clean up. No need
1995 * to decrement the use counts, as release_mem doesn't care.
1996 */
1997
1998 if (tty->ldisc.open) {
1999 retval = (tty->ldisc.open)(tty);
2000 if (retval)
2001 goto release_mem_out;
2002 }
2003 if (o_tty && o_tty->ldisc.open) {
2004 retval = (o_tty->ldisc.open)(o_tty);
2005 if (retval) {
2006 if (tty->ldisc.close)
2007 (tty->ldisc.close)(tty);
2008 goto release_mem_out;
2009 }
2010 tty_ldisc_enable(o_tty);
2011 }
2012 tty_ldisc_enable(tty);
2013 goto success;
2014
2015 /*
2016 * This fast open can be used if the tty is already open.
2017 * No memory is allocated, and the only failures are from
2018 * attempting to open a closing tty or attempting multiple
2019 * opens on a pty master.
2020 */
2021fast_track:
2022 if (test_bit(TTY_CLOSING, &tty->flags)) {
2023 retval = -EIO;
2024 goto end_init;
2025 }
2026 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2027 driver->subtype == PTY_TYPE_MASTER) {
2028 /*
2029 * special case for PTY masters: only one open permitted,
2030 * and the slave side open count is incremented as well.
2031 */
2032 if (tty->count) {
2033 retval = -EIO;
2034 goto end_init;
2035 }
2036 tty->link->count++;
2037 }
2038 tty->count++;
2039 tty->driver = driver; /* N.B. why do this every time?? */
2040
2041 /* FIXME */
2042 if(!test_bit(TTY_LDISC, &tty->flags))
2043 printk(KERN_ERR "init_dev but no ldisc\n");
2044success:
2045 *ret_tty = tty;
2046
Ingo Molnar70522e12006-03-23 03:00:31 -08002047 /* All paths come through here to release the mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048end_init:
2049 return retval;
2050
2051 /* Release locally allocated memory ... nothing placed in slots */
2052free_mem_out:
Jesper Juhl735d5662005-11-07 01:01:29 -08002053 kfree(o_tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 if (o_tty)
2055 free_tty_struct(o_tty);
Jesper Juhl735d5662005-11-07 01:01:29 -08002056 kfree(ltp);
2057 kfree(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 free_tty_struct(tty);
2059
2060fail_no_mem:
2061 module_put(driver->owner);
2062 retval = -ENOMEM;
2063 goto end_init;
2064
2065 /* call the tty release_mem routine to clean out this slot */
2066release_mem_out:
2067 printk(KERN_INFO "init_dev: ldisc open failed, "
2068 "clearing slot %d\n", idx);
2069 release_mem(tty, idx);
2070 goto end_init;
2071}
2072
Alan Coxaf9b8972006-08-27 01:24:01 -07002073/**
2074 * release_mem - release tty structure memory
2075 *
2076 * Releases memory associated with a tty structure, and clears out the
2077 * driver table slots. This function is called when a device is no longer
2078 * in use. It also gets called when setup of a device fails.
2079 *
2080 * Locking:
2081 * tty_mutex - sometimes only
2082 * takes the file list lock internally when working on the list
2083 * of ttys that the driver keeps.
2084 * FIXME: should we require tty_mutex is held here ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002086
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087static void release_mem(struct tty_struct *tty, int idx)
2088{
2089 struct tty_struct *o_tty;
2090 struct termios *tp;
2091 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2092
2093 if ((o_tty = tty->link) != NULL) {
2094 if (!devpts)
2095 o_tty->driver->ttys[idx] = NULL;
2096 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2097 tp = o_tty->termios;
2098 if (!devpts)
2099 o_tty->driver->termios[idx] = NULL;
2100 kfree(tp);
2101
2102 tp = o_tty->termios_locked;
2103 if (!devpts)
2104 o_tty->driver->termios_locked[idx] = NULL;
2105 kfree(tp);
2106 }
2107 o_tty->magic = 0;
2108 o_tty->driver->refcount--;
2109 file_list_lock();
2110 list_del_init(&o_tty->tty_files);
2111 file_list_unlock();
2112 free_tty_struct(o_tty);
2113 }
2114
2115 if (!devpts)
2116 tty->driver->ttys[idx] = NULL;
2117 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2118 tp = tty->termios;
2119 if (!devpts)
2120 tty->driver->termios[idx] = NULL;
2121 kfree(tp);
2122
2123 tp = tty->termios_locked;
2124 if (!devpts)
2125 tty->driver->termios_locked[idx] = NULL;
2126 kfree(tp);
2127 }
2128
2129 tty->magic = 0;
2130 tty->driver->refcount--;
2131 file_list_lock();
2132 list_del_init(&tty->tty_files);
2133 file_list_unlock();
2134 module_put(tty->driver->owner);
2135 free_tty_struct(tty);
2136}
2137
2138/*
2139 * Even releasing the tty structures is a tricky business.. We have
2140 * to be very careful that the structures are all released at the
2141 * same time, as interrupts might otherwise get the wrong pointers.
2142 *
2143 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2144 * lead to double frees or releasing memory still in use.
2145 */
2146static void release_dev(struct file * filp)
2147{
2148 struct tty_struct *tty, *o_tty;
2149 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07002150 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 int idx;
2152 char buf[64];
2153 unsigned long flags;
2154
2155 tty = (struct tty_struct *)filp->private_data;
2156 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2157 return;
2158
2159 check_tty_count(tty, "release_dev");
2160
2161 tty_fasync(-1, filp, 0);
2162
2163 idx = tty->index;
2164 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2165 tty->driver->subtype == PTY_TYPE_MASTER);
2166 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 o_tty = tty->link;
2168
2169#ifdef TTY_PARANOIA_CHECK
2170 if (idx < 0 || idx >= tty->driver->num) {
2171 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2172 "free (%s)\n", tty->name);
2173 return;
2174 }
2175 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2176 if (tty != tty->driver->ttys[idx]) {
2177 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2178 "for (%s)\n", idx, tty->name);
2179 return;
2180 }
2181 if (tty->termios != tty->driver->termios[idx]) {
2182 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2183 "for (%s)\n",
2184 idx, tty->name);
2185 return;
2186 }
2187 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2188 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2189 "termios_locked for (%s)\n",
2190 idx, tty->name);
2191 return;
2192 }
2193 }
2194#endif
2195
2196#ifdef TTY_DEBUG_HANGUP
2197 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2198 tty_name(tty, buf), tty->count);
2199#endif
2200
2201#ifdef TTY_PARANOIA_CHECK
2202 if (tty->driver->other &&
2203 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2204 if (o_tty != tty->driver->other->ttys[idx]) {
2205 printk(KERN_DEBUG "release_dev: other->table[%d] "
2206 "not o_tty for (%s)\n",
2207 idx, tty->name);
2208 return;
2209 }
2210 if (o_tty->termios != tty->driver->other->termios[idx]) {
2211 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2212 "not o_termios for (%s)\n",
2213 idx, tty->name);
2214 return;
2215 }
2216 if (o_tty->termios_locked !=
2217 tty->driver->other->termios_locked[idx]) {
2218 printk(KERN_DEBUG "release_dev: other->termios_locked["
2219 "%d] not o_termios_locked for (%s)\n",
2220 idx, tty->name);
2221 return;
2222 }
2223 if (o_tty->link != tty) {
2224 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2225 return;
2226 }
2227 }
2228#endif
2229 if (tty->driver->close)
2230 tty->driver->close(tty, filp);
2231
2232 /*
2233 * Sanity check: if tty->count is going to zero, there shouldn't be
2234 * any waiters on tty->read_wait or tty->write_wait. We test the
2235 * wait queues and kick everyone out _before_ actually starting to
2236 * close. This ensures that we won't block while releasing the tty
2237 * structure.
2238 *
2239 * The test for the o_tty closing is necessary, since the master and
2240 * slave sides may close in any order. If the slave side closes out
2241 * first, its count will be one, since the master side holds an open.
2242 * Thus this test wouldn't be triggered at the time the slave closes,
2243 * so we do it now.
2244 *
2245 * Note that it's possible for the tty to be opened again while we're
2246 * flushing out waiters. By recalculating the closing flags before
2247 * each iteration we avoid any problems.
2248 */
2249 while (1) {
2250 /* Guard against races with tty->count changes elsewhere and
2251 opens on /dev/tty */
2252
Ingo Molnar70522e12006-03-23 03:00:31 -08002253 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 tty_closing = tty->count <= 1;
2255 o_tty_closing = o_tty &&
2256 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 do_sleep = 0;
2258
2259 if (tty_closing) {
2260 if (waitqueue_active(&tty->read_wait)) {
2261 wake_up(&tty->read_wait);
2262 do_sleep++;
2263 }
2264 if (waitqueue_active(&tty->write_wait)) {
2265 wake_up(&tty->write_wait);
2266 do_sleep++;
2267 }
2268 }
2269 if (o_tty_closing) {
2270 if (waitqueue_active(&o_tty->read_wait)) {
2271 wake_up(&o_tty->read_wait);
2272 do_sleep++;
2273 }
2274 if (waitqueue_active(&o_tty->write_wait)) {
2275 wake_up(&o_tty->write_wait);
2276 do_sleep++;
2277 }
2278 }
2279 if (!do_sleep)
2280 break;
2281
2282 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2283 "active!\n", tty_name(tty, buf));
Ingo Molnar70522e12006-03-23 03:00:31 -08002284 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 schedule();
2286 }
2287
2288 /*
2289 * The closing flags are now consistent with the open counts on
2290 * both sides, and we've completed the last operation that could
2291 * block, so it's safe to proceed with closing.
2292 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 if (pty_master) {
2294 if (--o_tty->count < 0) {
2295 printk(KERN_WARNING "release_dev: bad pty slave count "
2296 "(%d) for %s\n",
2297 o_tty->count, tty_name(o_tty, buf));
2298 o_tty->count = 0;
2299 }
2300 }
2301 if (--tty->count < 0) {
2302 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2303 tty->count, tty_name(tty, buf));
2304 tty->count = 0;
2305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306
2307 /*
2308 * We've decremented tty->count, so we need to remove this file
2309 * descriptor off the tty->tty_files list; this serves two
2310 * purposes:
2311 * - check_tty_count sees the correct number of file descriptors
2312 * associated with this tty.
2313 * - do_tty_hangup no longer sees this file descriptor as
2314 * something that needs to be handled for hangups.
2315 */
2316 file_kill(filp);
2317 filp->private_data = NULL;
2318
2319 /*
2320 * Perform some housekeeping before deciding whether to return.
2321 *
2322 * Set the TTY_CLOSING flag if this was the last open. In the
2323 * case of a pty we may have to wait around for the other side
2324 * to close, and TTY_CLOSING makes sure we can't be reopened.
2325 */
2326 if(tty_closing)
2327 set_bit(TTY_CLOSING, &tty->flags);
2328 if(o_tty_closing)
2329 set_bit(TTY_CLOSING, &o_tty->flags);
2330
2331 /*
2332 * If _either_ side is closing, make sure there aren't any
2333 * processes that still think tty or o_tty is their controlling
2334 * tty.
2335 */
2336 if (tty_closing || o_tty_closing) {
2337 struct task_struct *p;
2338
2339 read_lock(&tasklist_lock);
2340 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2341 p->signal->tty = NULL;
2342 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2343 if (o_tty)
2344 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
2345 p->signal->tty = NULL;
2346 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
2347 read_unlock(&tasklist_lock);
2348 }
2349
Ingo Molnar70522e12006-03-23 03:00:31 -08002350 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08002351
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 /* check whether both sides are closing ... */
2353 if (!tty_closing || (o_tty && !o_tty_closing))
2354 return;
2355
2356#ifdef TTY_DEBUG_HANGUP
2357 printk(KERN_DEBUG "freeing tty structure...");
2358#endif
2359 /*
2360 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2361 * kill any delayed work. As this is the final close it does not
2362 * race with the set_ldisc code path.
2363 */
2364 clear_bit(TTY_LDISC, &tty->flags);
Alan Cox33f0f882006-01-09 20:54:13 -08002365 cancel_delayed_work(&tty->buf.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366
2367 /*
Alan Cox33f0f882006-01-09 20:54:13 -08002368 * Wait for ->hangup_work and ->buf.work handlers to terminate
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 */
2370
2371 flush_scheduled_work();
2372
2373 /*
2374 * Wait for any short term users (we know they are just driver
2375 * side waiters as the file is closing so user count on the file
2376 * side is zero.
2377 */
2378 spin_lock_irqsave(&tty_ldisc_lock, flags);
2379 while(tty->ldisc.refcount)
2380 {
2381 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2382 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2383 spin_lock_irqsave(&tty_ldisc_lock, flags);
2384 }
2385 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2386 /*
2387 * Shutdown the current line discipline, and reset it to N_TTY.
2388 * N.B. why reset ldisc when we're releasing the memory??
2389 *
2390 * FIXME: this MUST get fixed for the new reflocking
2391 */
2392 if (tty->ldisc.close)
2393 (tty->ldisc.close)(tty);
2394 tty_ldisc_put(tty->ldisc.num);
2395
2396 /*
2397 * Switch the line discipline back
2398 */
2399 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2400 tty_set_termios_ldisc(tty,N_TTY);
2401 if (o_tty) {
2402 /* FIXME: could o_tty be in setldisc here ? */
2403 clear_bit(TTY_LDISC, &o_tty->flags);
2404 if (o_tty->ldisc.close)
2405 (o_tty->ldisc.close)(o_tty);
2406 tty_ldisc_put(o_tty->ldisc.num);
2407 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2408 tty_set_termios_ldisc(o_tty,N_TTY);
2409 }
2410 /*
2411 * The release_mem function takes care of the details of clearing
2412 * the slots and preserving the termios structure.
2413 */
2414 release_mem(tty, idx);
2415
2416#ifdef CONFIG_UNIX98_PTYS
2417 /* Make this pty number available for reallocation */
2418 if (devpts) {
2419 down(&allocated_ptys_lock);
2420 idr_remove(&allocated_ptys, idx);
2421 up(&allocated_ptys_lock);
2422 }
2423#endif
2424
2425}
2426
Alan Coxaf9b8972006-08-27 01:24:01 -07002427/**
2428 * tty_open - open a tty device
2429 * @inode: inode of device file
2430 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002432 * tty_open and tty_release keep up the tty count that contains the
2433 * number of opens done on a tty. We cannot use the inode-count, as
2434 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002436 * Open-counting is needed for pty masters, as well as for keeping
2437 * track of serial lines: DTR is dropped when the last close happens.
2438 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2439 *
2440 * The termios state of a pty is reset on first open so that
2441 * settings don't persist across reuse.
2442 *
2443 * Locking: tty_mutex protects current->signal->tty, get_tty_driver and
2444 * init_dev work. tty->count should protect the rest.
2445 * task_lock is held to update task details for sessions
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002447
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448static int tty_open(struct inode * inode, struct file * filp)
2449{
2450 struct tty_struct *tty;
2451 int noctty, retval;
2452 struct tty_driver *driver;
2453 int index;
2454 dev_t device = inode->i_rdev;
2455 unsigned short saved_flags = filp->f_flags;
2456
2457 nonseekable_open(inode, filp);
2458
2459retry_open:
2460 noctty = filp->f_flags & O_NOCTTY;
2461 index = -1;
2462 retval = 0;
2463
Ingo Molnar70522e12006-03-23 03:00:31 -08002464 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465
2466 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2467 if (!current->signal->tty) {
Ingo Molnar70522e12006-03-23 03:00:31 -08002468 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 return -ENXIO;
2470 }
2471 driver = current->signal->tty->driver;
2472 index = current->signal->tty->index;
2473 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2474 /* noctty = 1; */
2475 goto got_driver;
2476 }
2477#ifdef CONFIG_VT
2478 if (device == MKDEV(TTY_MAJOR,0)) {
2479 extern struct tty_driver *console_driver;
2480 driver = console_driver;
2481 index = fg_console;
2482 noctty = 1;
2483 goto got_driver;
2484 }
2485#endif
2486 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2487 driver = console_device(&index);
2488 if (driver) {
2489 /* Don't let /dev/console block */
2490 filp->f_flags |= O_NONBLOCK;
2491 noctty = 1;
2492 goto got_driver;
2493 }
Ingo Molnar70522e12006-03-23 03:00:31 -08002494 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 return -ENODEV;
2496 }
2497
2498 driver = get_tty_driver(device, &index);
2499 if (!driver) {
Ingo Molnar70522e12006-03-23 03:00:31 -08002500 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 return -ENODEV;
2502 }
2503got_driver:
2504 retval = init_dev(driver, index, &tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08002505 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506 if (retval)
2507 return retval;
2508
2509 filp->private_data = tty;
2510 file_move(filp, &tty->tty_files);
2511 check_tty_count(tty, "tty_open");
2512 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2513 tty->driver->subtype == PTY_TYPE_MASTER)
2514 noctty = 1;
2515#ifdef TTY_DEBUG_HANGUP
2516 printk(KERN_DEBUG "opening %s...", tty->name);
2517#endif
2518 if (!retval) {
2519 if (tty->driver->open)
2520 retval = tty->driver->open(tty, filp);
2521 else
2522 retval = -ENODEV;
2523 }
2524 filp->f_flags = saved_flags;
2525
2526 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2527 retval = -EBUSY;
2528
2529 if (retval) {
2530#ifdef TTY_DEBUG_HANGUP
2531 printk(KERN_DEBUG "error %d in opening %s...", retval,
2532 tty->name);
2533#endif
2534 release_dev(filp);
2535 if (retval != -ERESTARTSYS)
2536 return retval;
2537 if (signal_pending(current))
2538 return retval;
2539 schedule();
2540 /*
2541 * Need to reset f_op in case a hangup happened.
2542 */
2543 if (filp->f_op == &hung_up_tty_fops)
2544 filp->f_op = &tty_fops;
2545 goto retry_open;
2546 }
2547 if (!noctty &&
2548 current->signal->leader &&
2549 !current->signal->tty &&
2550 tty->session == 0) {
2551 task_lock(current);
2552 current->signal->tty = tty;
2553 task_unlock(current);
2554 current->signal->tty_old_pgrp = 0;
2555 tty->session = current->signal->session;
2556 tty->pgrp = process_group(current);
2557 }
2558 return 0;
2559}
2560
2561#ifdef CONFIG_UNIX98_PTYS
Alan Coxaf9b8972006-08-27 01:24:01 -07002562/**
2563 * ptmx_open - open a unix 98 pty master
2564 * @inode: inode of device file
2565 * @filp: file pointer to tty
2566 *
2567 * Allocate a unix98 pty master device from the ptmx driver.
2568 *
2569 * Locking: tty_mutex protects theinit_dev work. tty->count should
2570 protect the rest.
2571 * allocated_ptys_lock handles the list of free pty numbers
2572 */
2573
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574static int ptmx_open(struct inode * inode, struct file * filp)
2575{
2576 struct tty_struct *tty;
2577 int retval;
2578 int index;
2579 int idr_ret;
2580
2581 nonseekable_open(inode, filp);
2582
2583 /* find a device that is not in use. */
2584 down(&allocated_ptys_lock);
2585 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2586 up(&allocated_ptys_lock);
2587 return -ENOMEM;
2588 }
2589 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2590 if (idr_ret < 0) {
2591 up(&allocated_ptys_lock);
2592 if (idr_ret == -EAGAIN)
2593 return -ENOMEM;
2594 return -EIO;
2595 }
2596 if (index >= pty_limit) {
2597 idr_remove(&allocated_ptys, index);
2598 up(&allocated_ptys_lock);
2599 return -EIO;
2600 }
2601 up(&allocated_ptys_lock);
2602
Ingo Molnar70522e12006-03-23 03:00:31 -08002603 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 retval = init_dev(ptm_driver, index, &tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08002605 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606
2607 if (retval)
2608 goto out;
2609
2610 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2611 filp->private_data = tty;
2612 file_move(filp, &tty->tty_files);
2613
2614 retval = -ENOMEM;
2615 if (devpts_pty_new(tty->link))
2616 goto out1;
2617
2618 check_tty_count(tty, "tty_open");
2619 retval = ptm_driver->open(tty, filp);
2620 if (!retval)
2621 return 0;
2622out1:
2623 release_dev(filp);
Paul Fulghum9453a5a2006-04-10 22:54:18 -07002624 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625out:
2626 down(&allocated_ptys_lock);
2627 idr_remove(&allocated_ptys, index);
2628 up(&allocated_ptys_lock);
2629 return retval;
2630}
2631#endif
2632
Alan Coxaf9b8972006-08-27 01:24:01 -07002633/**
2634 * tty_release - vfs callback for close
2635 * @inode: inode of tty
2636 * @filp: file pointer for handle to tty
2637 *
2638 * Called the last time each file handle is closed that references
2639 * this tty. There may however be several such references.
2640 *
2641 * Locking:
2642 * Takes bkl. See release_dev
2643 */
2644
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645static int tty_release(struct inode * inode, struct file * filp)
2646{
2647 lock_kernel();
2648 release_dev(filp);
2649 unlock_kernel();
2650 return 0;
2651}
2652
Alan Coxaf9b8972006-08-27 01:24:01 -07002653/**
2654 * tty_poll - check tty status
2655 * @filp: file being polled
2656 * @wait: poll wait structures to update
2657 *
2658 * Call the line discipline polling method to obtain the poll
2659 * status of the device.
2660 *
2661 * Locking: locks called line discipline but ldisc poll method
2662 * may be re-entered freely by other callers.
2663 */
2664
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665static unsigned int tty_poll(struct file * filp, poll_table * wait)
2666{
2667 struct tty_struct * tty;
2668 struct tty_ldisc *ld;
2669 int ret = 0;
2670
2671 tty = (struct tty_struct *)filp->private_data;
2672 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2673 return 0;
2674
2675 ld = tty_ldisc_ref_wait(tty);
2676 if (ld->poll)
2677 ret = (ld->poll)(tty, filp, wait);
2678 tty_ldisc_deref(ld);
2679 return ret;
2680}
2681
2682static int tty_fasync(int fd, struct file * filp, int on)
2683{
2684 struct tty_struct * tty;
2685 int retval;
2686
2687 tty = (struct tty_struct *)filp->private_data;
2688 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2689 return 0;
2690
2691 retval = fasync_helper(fd, filp, on, &tty->fasync);
2692 if (retval <= 0)
2693 return retval;
2694
2695 if (on) {
2696 if (!waitqueue_active(&tty->read_wait))
2697 tty->minimum_to_wake = 1;
2698 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2699 if (retval)
2700 return retval;
2701 } else {
2702 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2703 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2704 }
2705 return 0;
2706}
2707
Alan Coxaf9b8972006-08-27 01:24:01 -07002708/**
2709 * tiocsti - fake input character
2710 * @tty: tty to fake input into
2711 * @p: pointer to character
2712 *
2713 * Fake input to a tty device. Does the neccessary locking and
2714 * input management.
2715 *
2716 * FIXME: does not honour flow control ??
2717 *
2718 * Locking:
2719 * Called functions take tty_ldisc_lock
2720 * current->signal->tty check is safe without locks
2721 */
2722
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723static int tiocsti(struct tty_struct *tty, char __user *p)
2724{
2725 char ch, mbz = 0;
2726 struct tty_ldisc *ld;
2727
2728 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2729 return -EPERM;
2730 if (get_user(ch, p))
2731 return -EFAULT;
2732 ld = tty_ldisc_ref_wait(tty);
2733 ld->receive_buf(tty, &ch, &mbz, 1);
2734 tty_ldisc_deref(ld);
2735 return 0;
2736}
2737
Alan Coxaf9b8972006-08-27 01:24:01 -07002738/**
2739 * tiocgwinsz - implement window query ioctl
2740 * @tty; tty
2741 * @arg: user buffer for result
2742 *
2743 * Copies the kernel idea of the window size into the user buffer. No
2744 * locking is done.
2745 *
2746 * FIXME: Returning random values racing a window size set is wrong
2747 * should lock here against that
2748 */
2749
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2751{
2752 if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2753 return -EFAULT;
2754 return 0;
2755}
2756
Alan Coxaf9b8972006-08-27 01:24:01 -07002757/**
2758 * tiocswinsz - implement window size set ioctl
2759 * @tty; tty
2760 * @arg: user buffer for result
2761 *
2762 * Copies the user idea of the window size to the kernel. Traditionally
2763 * this is just advisory information but for the Linux console it
2764 * actually has driver level meaning and triggers a VC resize.
2765 *
2766 * Locking:
Alan Coxca9bda02006-09-29 02:00:03 -07002767 * Called function use the console_sem is used to ensure we do
2768 * not try and resize the console twice at once.
2769 * The tty->termios_sem is used to ensure we don't double
2770 * resize and get confused. Lock order - tty->termios.sem before
2771 * console sem
Alan Coxaf9b8972006-08-27 01:24:01 -07002772 */
2773
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2775 struct winsize __user * arg)
2776{
2777 struct winsize tmp_ws;
2778
2779 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2780 return -EFAULT;
Alan Coxca9bda02006-09-29 02:00:03 -07002781
2782 down(&tty->termios_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
Alan Coxca9bda02006-09-29 02:00:03 -07002784 goto done;
2785
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786#ifdef CONFIG_VT
2787 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
Alan Coxca9bda02006-09-29 02:00:03 -07002788 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row)) {
2789 up(&tty->termios_sem);
2790 return -ENXIO;
2791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 }
2793#endif
2794 if (tty->pgrp > 0)
2795 kill_pg(tty->pgrp, SIGWINCH, 1);
2796 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2797 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2798 tty->winsize = tmp_ws;
2799 real_tty->winsize = tmp_ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002800done:
2801 up(&tty->termios_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802 return 0;
2803}
2804
Alan Coxaf9b8972006-08-27 01:24:01 -07002805/**
2806 * tioccons - allow admin to move logical console
2807 * @file: the file to become console
2808 *
2809 * Allow the adminstrator to move the redirected console device
2810 *
2811 * Locking: uses redirect_lock to guard the redirect information
2812 */
2813
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814static int tioccons(struct file *file)
2815{
2816 if (!capable(CAP_SYS_ADMIN))
2817 return -EPERM;
2818 if (file->f_op->write == redirected_tty_write) {
2819 struct file *f;
2820 spin_lock(&redirect_lock);
2821 f = redirect;
2822 redirect = NULL;
2823 spin_unlock(&redirect_lock);
2824 if (f)
2825 fput(f);
2826 return 0;
2827 }
2828 spin_lock(&redirect_lock);
2829 if (redirect) {
2830 spin_unlock(&redirect_lock);
2831 return -EBUSY;
2832 }
2833 get_file(file);
2834 redirect = file;
2835 spin_unlock(&redirect_lock);
2836 return 0;
2837}
2838
Alan Coxaf9b8972006-08-27 01:24:01 -07002839/**
2840 * fionbio - non blocking ioctl
2841 * @file: file to set blocking value
2842 * @p: user parameter
2843 *
2844 * Historical tty interfaces had a blocking control ioctl before
2845 * the generic functionality existed. This piece of history is preserved
2846 * in the expected tty API of posix OS's.
2847 *
2848 * Locking: none, the open fle handle ensures it won't go away.
2849 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850
2851static int fionbio(struct file *file, int __user *p)
2852{
2853 int nonblock;
2854
2855 if (get_user(nonblock, p))
2856 return -EFAULT;
2857
2858 if (nonblock)
2859 file->f_flags |= O_NONBLOCK;
2860 else
2861 file->f_flags &= ~O_NONBLOCK;
2862 return 0;
2863}
2864
Alan Coxaf9b8972006-08-27 01:24:01 -07002865/**
2866 * tiocsctty - set controlling tty
2867 * @tty: tty structure
2868 * @arg: user argument
2869 *
2870 * This ioctl is used to manage job control. It permits a session
2871 * leader to set this tty as the controlling tty for the session.
2872 *
2873 * Locking:
2874 * Takes tasklist lock internally to walk sessions
2875 * Takes task_lock() when updating signal->tty
2876 *
2877 * FIXME: tty_mutex is needed to protect signal->tty references.
2878 * FIXME: why task_lock on the signal->tty reference ??
2879 *
2880 */
2881
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882static int tiocsctty(struct tty_struct *tty, int arg)
2883{
Ingo Molnar36c8b582006-07-03 00:25:41 -07002884 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885
2886 if (current->signal->leader &&
2887 (current->signal->session == tty->session))
2888 return 0;
2889 /*
2890 * The process must be a session leader and
2891 * not have a controlling tty already.
2892 */
2893 if (!current->signal->leader || current->signal->tty)
2894 return -EPERM;
2895 if (tty->session > 0) {
2896 /*
2897 * This tty is already the controlling
2898 * tty for another session group!
2899 */
2900 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2901 /*
2902 * Steal it away
2903 */
2904
2905 read_lock(&tasklist_lock);
2906 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2907 p->signal->tty = NULL;
2908 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2909 read_unlock(&tasklist_lock);
2910 } else
2911 return -EPERM;
2912 }
2913 task_lock(current);
2914 current->signal->tty = tty;
2915 task_unlock(current);
2916 current->signal->tty_old_pgrp = 0;
2917 tty->session = current->signal->session;
2918 tty->pgrp = process_group(current);
2919 return 0;
2920}
2921
Alan Coxaf9b8972006-08-27 01:24:01 -07002922/**
2923 * tiocgpgrp - get process group
2924 * @tty: tty passed by user
2925 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2926 * @p: returned pid
2927 *
2928 * Obtain the process group of the tty. If there is no process group
2929 * return an error.
2930 *
2931 * Locking: none. Reference to ->signal->tty is safe.
2932 */
2933
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2935{
2936 /*
2937 * (tty == real_tty) is a cheap way of
2938 * testing if the tty is NOT a master pty.
2939 */
2940 if (tty == real_tty && current->signal->tty != real_tty)
2941 return -ENOTTY;
2942 return put_user(real_tty->pgrp, p);
2943}
2944
Alan Coxaf9b8972006-08-27 01:24:01 -07002945/**
2946 * tiocspgrp - attempt to set process group
2947 * @tty: tty passed by user
2948 * @real_tty: tty side device matching tty passed by user
2949 * @p: pid pointer
2950 *
2951 * Set the process group of the tty to the session passed. Only
2952 * permitted where the tty session is our session.
2953 *
2954 * Locking: None
2955 *
2956 * FIXME: current->signal->tty referencing is unsafe.
2957 */
2958
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2960{
2961 pid_t pgrp;
2962 int retval = tty_check_change(real_tty);
2963
2964 if (retval == -EIO)
2965 return -ENOTTY;
2966 if (retval)
2967 return retval;
2968 if (!current->signal->tty ||
2969 (current->signal->tty != real_tty) ||
2970 (real_tty->session != current->signal->session))
2971 return -ENOTTY;
2972 if (get_user(pgrp, p))
2973 return -EFAULT;
2974 if (pgrp < 0)
2975 return -EINVAL;
2976 if (session_of_pgrp(pgrp) != current->signal->session)
2977 return -EPERM;
2978 real_tty->pgrp = pgrp;
2979 return 0;
2980}
2981
Alan Coxaf9b8972006-08-27 01:24:01 -07002982/**
2983 * tiocgsid - get session id
2984 * @tty: tty passed by user
2985 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2986 * @p: pointer to returned session id
2987 *
2988 * Obtain the session id of the tty. If there is no session
2989 * return an error.
2990 *
2991 * Locking: none. Reference to ->signal->tty is safe.
2992 */
2993
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2995{
2996 /*
2997 * (tty == real_tty) is a cheap way of
2998 * testing if the tty is NOT a master pty.
2999 */
3000 if (tty == real_tty && current->signal->tty != real_tty)
3001 return -ENOTTY;
3002 if (real_tty->session <= 0)
3003 return -ENOTTY;
3004 return put_user(real_tty->session, p);
3005}
3006
Alan Coxaf9b8972006-08-27 01:24:01 -07003007/**
3008 * tiocsetd - set line discipline
3009 * @tty: tty device
3010 * @p: pointer to user data
3011 *
3012 * Set the line discipline according to user request.
3013 *
3014 * Locking: see tty_set_ldisc, this function is just a helper
3015 */
3016
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017static int tiocsetd(struct tty_struct *tty, int __user *p)
3018{
3019 int ldisc;
3020
3021 if (get_user(ldisc, p))
3022 return -EFAULT;
3023 return tty_set_ldisc(tty, ldisc);
3024}
3025
Alan Coxaf9b8972006-08-27 01:24:01 -07003026/**
3027 * send_break - performed time break
3028 * @tty: device to break on
3029 * @duration: timeout in mS
3030 *
3031 * Perform a timed break on hardware that lacks its own driver level
3032 * timed break functionality.
3033 *
3034 * Locking:
3035 * None
3036 *
3037 * FIXME:
3038 * What if two overlap
3039 */
3040
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003041static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042{
3043 tty->driver->break_ctl(tty, -1);
3044 if (!signal_pending(current)) {
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003045 msleep_interruptible(duration);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046 }
3047 tty->driver->break_ctl(tty, 0);
3048 if (signal_pending(current))
3049 return -EINTR;
3050 return 0;
3051}
3052
Alan Coxaf9b8972006-08-27 01:24:01 -07003053/**
3054 * tiocmget - get modem status
3055 * @tty: tty device
3056 * @file: user file pointer
3057 * @p: pointer to result
3058 *
3059 * Obtain the modem status bits from the tty driver if the feature
3060 * is supported. Return -EINVAL if it is not available.
3061 *
3062 * Locking: none (up to the driver)
3063 */
3064
3065static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066{
3067 int retval = -EINVAL;
3068
3069 if (tty->driver->tiocmget) {
3070 retval = tty->driver->tiocmget(tty, file);
3071
3072 if (retval >= 0)
3073 retval = put_user(retval, p);
3074 }
3075 return retval;
3076}
3077
Alan Coxaf9b8972006-08-27 01:24:01 -07003078/**
3079 * tiocmset - set modem status
3080 * @tty: tty device
3081 * @file: user file pointer
3082 * @cmd: command - clear bits, set bits or set all
3083 * @p: pointer to desired bits
3084 *
3085 * Set the modem status bits from the tty driver if the feature
3086 * is supported. Return -EINVAL if it is not available.
3087 *
3088 * Locking: none (up to the driver)
3089 */
3090
3091static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 unsigned __user *p)
3093{
3094 int retval = -EINVAL;
3095
3096 if (tty->driver->tiocmset) {
3097 unsigned int set, clear, val;
3098
3099 retval = get_user(val, p);
3100 if (retval)
3101 return retval;
3102
3103 set = clear = 0;
3104 switch (cmd) {
3105 case TIOCMBIS:
3106 set = val;
3107 break;
3108 case TIOCMBIC:
3109 clear = val;
3110 break;
3111 case TIOCMSET:
3112 set = val;
3113 clear = ~val;
3114 break;
3115 }
3116
3117 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3118 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3119
3120 retval = tty->driver->tiocmset(tty, file, set, clear);
3121 }
3122 return retval;
3123}
3124
3125/*
3126 * Split this up, as gcc can choke on it otherwise..
3127 */
3128int tty_ioctl(struct inode * inode, struct file * file,
3129 unsigned int cmd, unsigned long arg)
3130{
3131 struct tty_struct *tty, *real_tty;
3132 void __user *p = (void __user *)arg;
3133 int retval;
3134 struct tty_ldisc *ld;
3135
3136 tty = (struct tty_struct *)file->private_data;
3137 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3138 return -EINVAL;
3139
3140 real_tty = tty;
3141 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3142 tty->driver->subtype == PTY_TYPE_MASTER)
3143 real_tty = tty->link;
3144
3145 /*
3146 * Break handling by driver
3147 */
3148 if (!tty->driver->break_ctl) {
3149 switch(cmd) {
3150 case TIOCSBRK:
3151 case TIOCCBRK:
3152 if (tty->driver->ioctl)
3153 return tty->driver->ioctl(tty, file, cmd, arg);
3154 return -EINVAL;
3155
3156 /* These two ioctl's always return success; even if */
3157 /* the driver doesn't support them. */
3158 case TCSBRK:
3159 case TCSBRKP:
3160 if (!tty->driver->ioctl)
3161 return 0;
3162 retval = tty->driver->ioctl(tty, file, cmd, arg);
3163 if (retval == -ENOIOCTLCMD)
3164 retval = 0;
3165 return retval;
3166 }
3167 }
3168
3169 /*
3170 * Factor out some common prep work
3171 */
3172 switch (cmd) {
3173 case TIOCSETD:
3174 case TIOCSBRK:
3175 case TIOCCBRK:
3176 case TCSBRK:
3177 case TCSBRKP:
3178 retval = tty_check_change(tty);
3179 if (retval)
3180 return retval;
3181 if (cmd != TIOCCBRK) {
3182 tty_wait_until_sent(tty, 0);
3183 if (signal_pending(current))
3184 return -EINTR;
3185 }
3186 break;
3187 }
3188
3189 switch (cmd) {
3190 case TIOCSTI:
3191 return tiocsti(tty, p);
3192 case TIOCGWINSZ:
3193 return tiocgwinsz(tty, p);
3194 case TIOCSWINSZ:
3195 return tiocswinsz(tty, real_tty, p);
3196 case TIOCCONS:
3197 return real_tty!=tty ? -EINVAL : tioccons(file);
3198 case FIONBIO:
3199 return fionbio(file, p);
3200 case TIOCEXCL:
3201 set_bit(TTY_EXCLUSIVE, &tty->flags);
3202 return 0;
3203 case TIOCNXCL:
3204 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3205 return 0;
3206 case TIOCNOTTY:
Alan Coxaf9b8972006-08-27 01:24:01 -07003207 /* FIXME: taks lock or tty_mutex ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 if (current->signal->tty != tty)
3209 return -ENOTTY;
3210 if (current->signal->leader)
3211 disassociate_ctty(0);
3212 task_lock(current);
3213 current->signal->tty = NULL;
3214 task_unlock(current);
3215 return 0;
3216 case TIOCSCTTY:
3217 return tiocsctty(tty, arg);
3218 case TIOCGPGRP:
3219 return tiocgpgrp(tty, real_tty, p);
3220 case TIOCSPGRP:
3221 return tiocspgrp(tty, real_tty, p);
3222 case TIOCGSID:
3223 return tiocgsid(tty, real_tty, p);
3224 case TIOCGETD:
3225 /* FIXME: check this is ok */
3226 return put_user(tty->ldisc.num, (int __user *)p);
3227 case TIOCSETD:
3228 return tiocsetd(tty, p);
3229#ifdef CONFIG_VT
3230 case TIOCLINUX:
3231 return tioclinux(tty, arg);
3232#endif
3233 /*
3234 * Break handling
3235 */
3236 case TIOCSBRK: /* Turn break on, unconditionally */
3237 tty->driver->break_ctl(tty, -1);
3238 return 0;
3239
3240 case TIOCCBRK: /* Turn break off, unconditionally */
3241 tty->driver->break_ctl(tty, 0);
3242 return 0;
3243 case TCSBRK: /* SVID version: non-zero arg --> no break */
Paul Fulghum283fef52006-06-27 02:54:00 -07003244 /* non-zero arg means wait for all output data
3245 * to be sent (performed above) but don't send break.
3246 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 */
3248 if (!arg)
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003249 return send_break(tty, 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003250 return 0;
3251 case TCSBRKP: /* support for POSIX tcsendbreak() */
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003252 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253
3254 case TIOCMGET:
3255 return tty_tiocmget(tty, file, p);
3256
3257 case TIOCMSET:
3258 case TIOCMBIC:
3259 case TIOCMBIS:
3260 return tty_tiocmset(tty, file, cmd, p);
3261 }
3262 if (tty->driver->ioctl) {
3263 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3264 if (retval != -ENOIOCTLCMD)
3265 return retval;
3266 }
3267 ld = tty_ldisc_ref_wait(tty);
3268 retval = -EINVAL;
3269 if (ld->ioctl) {
3270 retval = ld->ioctl(tty, file, cmd, arg);
3271 if (retval == -ENOIOCTLCMD)
3272 retval = -EINVAL;
3273 }
3274 tty_ldisc_deref(ld);
3275 return retval;
3276}
3277
3278
3279/*
3280 * This implements the "Secure Attention Key" --- the idea is to
3281 * prevent trojan horses by killing all processes associated with this
3282 * tty when the user hits the "Secure Attention Key". Required for
3283 * super-paranoid applications --- see the Orange Book for more details.
3284 *
3285 * This code could be nicer; ideally it should send a HUP, wait a few
3286 * seconds, then send a INT, and then a KILL signal. But you then
3287 * have to coordinate with the init process, since all processes associated
3288 * with the current tty must be dead before the new getty is allowed
3289 * to spawn.
3290 *
3291 * Now, if it would be correct ;-/ The current code has a nasty hole -
3292 * it doesn't catch files in flight. We may send the descriptor to ourselves
3293 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3294 *
3295 * Nasty bug: do_SAK is being called in interrupt context. This can
3296 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3297 */
3298static void __do_SAK(void *arg)
3299{
3300#ifdef TTY_SOFT_SAK
3301 tty_hangup(tty);
3302#else
3303 struct tty_struct *tty = arg;
Eric W. Biederman652486f2006-03-28 16:11:02 -08003304 struct task_struct *g, *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 int session;
3306 int i;
3307 struct file *filp;
3308 struct tty_ldisc *disc;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07003309 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310
3311 if (!tty)
3312 return;
3313 session = tty->session;
3314
3315 /* We don't want an ldisc switch during this */
3316 disc = tty_ldisc_ref(tty);
3317 if (disc && disc->flush_buffer)
3318 disc->flush_buffer(tty);
3319 tty_ldisc_deref(disc);
3320
3321 if (tty->driver->flush_buffer)
3322 tty->driver->flush_buffer(tty);
3323
3324 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003325 /* Kill the entire session */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326 do_each_task_pid(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08003327 printk(KERN_NOTICE "SAK: killed process %d"
3328 " (%s): p->signal->session==tty->session\n",
3329 p->pid, p->comm);
3330 send_sig(SIGKILL, p, 1);
3331 } while_each_task_pid(session, PIDTYPE_SID, p);
3332 /* Now kill any processes that happen to have the
3333 * tty open.
3334 */
3335 do_each_thread(g, p) {
3336 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337 printk(KERN_NOTICE "SAK: killed process %d"
3338 " (%s): p->signal->session==tty->session\n",
3339 p->pid, p->comm);
3340 send_sig(SIGKILL, p, 1);
3341 continue;
3342 }
3343 task_lock(p);
3344 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07003345 /*
3346 * We don't take a ref to the file, so we must
3347 * hold ->file_lock instead.
3348 */
3349 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07003350 fdt = files_fdtable(p->files);
3351 for (i=0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352 filp = fcheck_files(p->files, i);
3353 if (!filp)
3354 continue;
3355 if (filp->f_op->read == tty_read &&
3356 filp->private_data == tty) {
3357 printk(KERN_NOTICE "SAK: killed process %d"
3358 " (%s): fd#%d opened to the tty\n",
3359 p->pid, p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06003360 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361 break;
3362 }
3363 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07003364 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003365 }
3366 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003367 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003368 read_unlock(&tasklist_lock);
3369#endif
3370}
3371
3372/*
3373 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3374 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3375 * the values which we write to it will be identical to the values which it
3376 * already has. --akpm
3377 */
3378void do_SAK(struct tty_struct *tty)
3379{
3380 if (!tty)
3381 return;
3382 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
3383 schedule_work(&tty->SAK_work);
3384}
3385
3386EXPORT_SYMBOL(do_SAK);
3387
Alan Coxaf9b8972006-08-27 01:24:01 -07003388/**
3389 * flush_to_ldisc
3390 * @private_: tty structure passed from work queue.
3391 *
3392 * This routine is called out of the software interrupt to flush data
3393 * from the buffer chain to the line discipline.
3394 *
3395 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3396 * while invoking the line discipline receive_buf method. The
3397 * receive_buf method is single threaded for each tty instance.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 */
3399
3400static void flush_to_ldisc(void *private_)
3401{
3402 struct tty_struct *tty = (struct tty_struct *) private_;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403 unsigned long flags;
3404 struct tty_ldisc *disc;
Paul Fulghum2c3bb202006-06-28 04:26:48 -07003405 struct tty_buffer *tbuf, *head;
Paul Fulghum8977d922006-02-10 01:51:14 -08003406 char *char_buf;
3407 unsigned char *flag_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003408
3409 disc = tty_ldisc_ref(tty);
3410 if (disc == NULL) /* !TTY_LDISC */
3411 return;
3412
Paul Fulghum808249c2006-02-03 03:04:41 -08003413 spin_lock_irqsave(&tty->buf.lock, flags);
Paul Fulghum2c3bb202006-06-28 04:26:48 -07003414 head = tty->buf.head;
3415 if (head != NULL) {
3416 tty->buf.head = NULL;
3417 for (;;) {
3418 int count = head->commit - head->read;
3419 if (!count) {
3420 if (head->next == NULL)
3421 break;
3422 tbuf = head;
3423 head = head->next;
3424 tty_buffer_free(tty, tbuf);
3425 continue;
3426 }
3427 if (!tty->receive_room) {
3428 schedule_delayed_work(&tty->buf.work, 1);
3429 break;
3430 }
3431 if (count > tty->receive_room)
3432 count = tty->receive_room;
3433 char_buf = head->char_buf_ptr + head->read;
3434 flag_buf = head->flag_buf_ptr + head->read;
3435 head->read += count;
Paul Fulghum8977d922006-02-10 01:51:14 -08003436 spin_unlock_irqrestore(&tty->buf.lock, flags);
3437 disc->receive_buf(tty, char_buf, flag_buf, count);
3438 spin_lock_irqsave(&tty->buf.lock, flags);
3439 }
Paul Fulghum2c3bb202006-06-28 04:26:48 -07003440 tty->buf.head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003441 }
Paul Fulghum808249c2006-02-03 03:04:41 -08003442 spin_unlock_irqrestore(&tty->buf.lock, flags);
Paul Fulghum817d6d32006-06-28 04:26:47 -07003443
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 tty_ldisc_deref(disc);
3445}
3446
3447/*
3448 * Routine which returns the baud rate of the tty
3449 *
3450 * Note that the baud_table needs to be kept in sync with the
3451 * include/asm/termbits.h file.
3452 */
3453static int baud_table[] = {
3454 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3455 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3456#ifdef __sparc__
3457 76800, 153600, 307200, 614400, 921600
3458#else
3459 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3460 2500000, 3000000, 3500000, 4000000
3461#endif
3462};
3463
3464static int n_baud_table = ARRAY_SIZE(baud_table);
3465
3466/**
3467 * tty_termios_baud_rate
3468 * @termios: termios structure
3469 *
3470 * Convert termios baud rate data into a speed. This should be called
3471 * with the termios lock held if this termios is a terminal termios
3472 * structure. May change the termios data.
Alan Coxaf9b8972006-08-27 01:24:01 -07003473 *
3474 * Locking: none
Linus Torvalds1da177e2005-04-16 15:20:36 -07003475 */
3476
3477int tty_termios_baud_rate(struct termios *termios)
3478{
3479 unsigned int cbaud;
3480
3481 cbaud = termios->c_cflag & CBAUD;
3482
3483 if (cbaud & CBAUDEX) {
3484 cbaud &= ~CBAUDEX;
3485
3486 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3487 termios->c_cflag &= ~CBAUDEX;
3488 else
3489 cbaud += 15;
3490 }
3491 return baud_table[cbaud];
3492}
3493
3494EXPORT_SYMBOL(tty_termios_baud_rate);
3495
3496/**
3497 * tty_get_baud_rate - get tty bit rates
3498 * @tty: tty to query
3499 *
3500 * Returns the baud rate as an integer for this terminal. The
3501 * termios lock must be held by the caller and the terminal bit
3502 * flags may be updated.
Alan Coxaf9b8972006-08-27 01:24:01 -07003503 *
3504 * Locking: none
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 */
3506
3507int tty_get_baud_rate(struct tty_struct *tty)
3508{
3509 int baud = tty_termios_baud_rate(tty->termios);
3510
3511 if (baud == 38400 && tty->alt_speed) {
3512 if (!tty->warned) {
3513 printk(KERN_WARNING "Use of setserial/setrocket to "
3514 "set SPD_* flags is deprecated\n");
3515 tty->warned = 1;
3516 }
3517 baud = tty->alt_speed;
3518 }
3519
3520 return baud;
3521}
3522
3523EXPORT_SYMBOL(tty_get_baud_rate);
3524
3525/**
3526 * tty_flip_buffer_push - terminal
3527 * @tty: tty to push
3528 *
3529 * Queue a push of the terminal flip buffers to the line discipline. This
3530 * function must not be called from IRQ context if tty->low_latency is set.
3531 *
3532 * In the event of the queue being busy for flipping the work will be
3533 * held off and retried later.
Alan Coxaf9b8972006-08-27 01:24:01 -07003534 *
3535 * Locking: tty buffer lock. Driver locks in low latency mode.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536 */
3537
3538void tty_flip_buffer_push(struct tty_struct *tty)
3539{
Paul Fulghum808249c2006-02-03 03:04:41 -08003540 unsigned long flags;
3541 spin_lock_irqsave(&tty->buf.lock, flags);
Paul Fulghum33b37a32006-06-28 04:26:49 -07003542 if (tty->buf.tail != NULL)
Paul Fulghum8977d922006-02-10 01:51:14 -08003543 tty->buf.tail->commit = tty->buf.tail->used;
Paul Fulghum808249c2006-02-03 03:04:41 -08003544 spin_unlock_irqrestore(&tty->buf.lock, flags);
3545
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 if (tty->low_latency)
3547 flush_to_ldisc((void *) tty);
3548 else
Alan Cox33f0f882006-01-09 20:54:13 -08003549 schedule_delayed_work(&tty->buf.work, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003550}
3551
3552EXPORT_SYMBOL(tty_flip_buffer_push);
3553
Alan Cox33f0f882006-01-09 20:54:13 -08003554
Alan Coxaf9b8972006-08-27 01:24:01 -07003555/**
3556 * initialize_tty_struct
3557 * @tty: tty to initialize
3558 *
3559 * This subroutine initializes a tty structure that has been newly
3560 * allocated.
3561 *
3562 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07003563 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003564
Linus Torvalds1da177e2005-04-16 15:20:36 -07003565static void initialize_tty_struct(struct tty_struct *tty)
3566{
3567 memset(tty, 0, sizeof(struct tty_struct));
3568 tty->magic = TTY_MAGIC;
3569 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3570 tty->pgrp = -1;
3571 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08003572 tty->buf.head = tty->buf.tail = NULL;
3573 tty_buffer_init(tty);
3574 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
3575 init_MUTEX(&tty->buf.pty_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003576 init_MUTEX(&tty->termios_sem);
3577 init_waitqueue_head(&tty->write_wait);
3578 init_waitqueue_head(&tty->read_wait);
3579 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08003580 mutex_init(&tty->atomic_read_lock);
3581 mutex_init(&tty->atomic_write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 spin_lock_init(&tty->read_lock);
3583 INIT_LIST_HEAD(&tty->tty_files);
3584 INIT_WORK(&tty->SAK_work, NULL, NULL);
3585}
3586
3587/*
3588 * The default put_char routine if the driver did not define one.
3589 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003590
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3592{
3593 tty->driver->write(tty, &ch, 1);
3594}
3595
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003596static struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003597
3598/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003599 * tty_register_device - register a tty device
3600 * @driver: the tty driver that describes the tty device
3601 * @index: the index in the tty driver for this tty device
3602 * @device: a struct device that is associated with this tty device.
3603 * This field is optional, if there is no known struct device
3604 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003605 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003606 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003607 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003608 * This call is required to be made to register an individual tty device
3609 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3610 * that bit is not set, this function should not be called by a tty
3611 * driver.
3612 *
3613 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003614 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003615
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003616struct class_device *tty_register_device(struct tty_driver *driver,
3617 unsigned index, struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003618{
3619 char name[64];
3620 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3621
3622 if (index >= driver->num) {
3623 printk(KERN_ERR "Attempt to register invalid tty line number "
3624 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003625 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003626 }
3627
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628 if (driver->type == TTY_DRIVER_TYPE_PTY)
3629 pty_line_name(driver, index, name);
3630 else
3631 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003632
3633 return class_device_create(tty_class, NULL, dev, device, "%s", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003634}
3635
3636/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003637 * tty_unregister_device - unregister a tty device
3638 * @driver: the tty driver that describes the tty device
3639 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003641 * If a tty device is registered with a call to tty_register_device() then
3642 * this function must be called when the tty device is gone.
3643 *
3644 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003645 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003646
Linus Torvalds1da177e2005-04-16 15:20:36 -07003647void tty_unregister_device(struct tty_driver *driver, unsigned index)
3648{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003649 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650}
3651
3652EXPORT_SYMBOL(tty_register_device);
3653EXPORT_SYMBOL(tty_unregister_device);
3654
3655struct tty_driver *alloc_tty_driver(int lines)
3656{
3657 struct tty_driver *driver;
3658
3659 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3660 if (driver) {
3661 memset(driver, 0, sizeof(struct tty_driver));
3662 driver->magic = TTY_DRIVER_MAGIC;
3663 driver->num = lines;
3664 /* later we'll move allocation of tables here */
3665 }
3666 return driver;
3667}
3668
3669void put_tty_driver(struct tty_driver *driver)
3670{
3671 kfree(driver);
3672}
3673
3674void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
3675{
3676 driver->open = op->open;
3677 driver->close = op->close;
3678 driver->write = op->write;
3679 driver->put_char = op->put_char;
3680 driver->flush_chars = op->flush_chars;
3681 driver->write_room = op->write_room;
3682 driver->chars_in_buffer = op->chars_in_buffer;
3683 driver->ioctl = op->ioctl;
3684 driver->set_termios = op->set_termios;
3685 driver->throttle = op->throttle;
3686 driver->unthrottle = op->unthrottle;
3687 driver->stop = op->stop;
3688 driver->start = op->start;
3689 driver->hangup = op->hangup;
3690 driver->break_ctl = op->break_ctl;
3691 driver->flush_buffer = op->flush_buffer;
3692 driver->set_ldisc = op->set_ldisc;
3693 driver->wait_until_sent = op->wait_until_sent;
3694 driver->send_xchar = op->send_xchar;
3695 driver->read_proc = op->read_proc;
3696 driver->write_proc = op->write_proc;
3697 driver->tiocmget = op->tiocmget;
3698 driver->tiocmset = op->tiocmset;
3699}
3700
3701
3702EXPORT_SYMBOL(alloc_tty_driver);
3703EXPORT_SYMBOL(put_tty_driver);
3704EXPORT_SYMBOL(tty_set_operations);
3705
3706/*
3707 * Called by a tty driver to register itself.
3708 */
3709int tty_register_driver(struct tty_driver *driver)
3710{
3711 int error;
3712 int i;
3713 dev_t dev;
3714 void **p = NULL;
3715
3716 if (driver->flags & TTY_DRIVER_INSTALLED)
3717 return 0;
3718
3719 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3720 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3721 if (!p)
3722 return -ENOMEM;
3723 memset(p, 0, driver->num * 3 * sizeof(void *));
3724 }
3725
3726 if (!driver->major) {
3727 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3728 (char*)driver->name);
3729 if (!error) {
3730 driver->major = MAJOR(dev);
3731 driver->minor_start = MINOR(dev);
3732 }
3733 } else {
3734 dev = MKDEV(driver->major, driver->minor_start);
3735 error = register_chrdev_region(dev, driver->num,
3736 (char*)driver->name);
3737 }
3738 if (error < 0) {
3739 kfree(p);
3740 return error;
3741 }
3742
3743 if (p) {
3744 driver->ttys = (struct tty_struct **)p;
3745 driver->termios = (struct termios **)(p + driver->num);
3746 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3747 } else {
3748 driver->ttys = NULL;
3749 driver->termios = NULL;
3750 driver->termios_locked = NULL;
3751 }
3752
3753 cdev_init(&driver->cdev, &tty_fops);
3754 driver->cdev.owner = driver->owner;
3755 error = cdev_add(&driver->cdev, dev, driver->num);
3756 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003757 unregister_chrdev_region(dev, driver->num);
3758 driver->ttys = NULL;
3759 driver->termios = driver->termios_locked = NULL;
3760 kfree(p);
3761 return error;
3762 }
3763
3764 if (!driver->put_char)
3765 driver->put_char = tty_default_put_char;
3766
3767 list_add(&driver->tty_drivers, &tty_drivers);
3768
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -07003769 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003770 for(i = 0; i < driver->num; i++)
3771 tty_register_device(driver, i, NULL);
3772 }
3773 proc_tty_register_driver(driver);
3774 return 0;
3775}
3776
3777EXPORT_SYMBOL(tty_register_driver);
3778
3779/*
3780 * Called by a tty driver to unregister itself.
3781 */
3782int tty_unregister_driver(struct tty_driver *driver)
3783{
3784 int i;
3785 struct termios *tp;
3786 void *p;
3787
3788 if (driver->refcount)
3789 return -EBUSY;
3790
3791 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3792 driver->num);
3793
3794 list_del(&driver->tty_drivers);
3795
3796 /*
3797 * Free the termios and termios_locked structures because
3798 * we don't want to get memory leaks when modular tty
3799 * drivers are removed from the kernel.
3800 */
3801 for (i = 0; i < driver->num; i++) {
3802 tp = driver->termios[i];
3803 if (tp) {
3804 driver->termios[i] = NULL;
3805 kfree(tp);
3806 }
3807 tp = driver->termios_locked[i];
3808 if (tp) {
3809 driver->termios_locked[i] = NULL;
3810 kfree(tp);
3811 }
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -07003812 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003813 tty_unregister_device(driver, i);
3814 }
3815 p = driver->ttys;
3816 proc_tty_unregister_driver(driver);
3817 driver->ttys = NULL;
3818 driver->termios = driver->termios_locked = NULL;
3819 kfree(p);
3820 cdev_del(&driver->cdev);
3821 return 0;
3822}
3823
3824EXPORT_SYMBOL(tty_unregister_driver);
3825
3826
3827/*
3828 * Initialize the console device. This is called *early*, so
3829 * we can't necessarily depend on lots of kernel help here.
3830 * Just do some early initializations, and do the complex setup
3831 * later.
3832 */
3833void __init console_init(void)
3834{
3835 initcall_t *call;
3836
3837 /* Setup the default TTY line discipline. */
3838 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3839
3840 /*
3841 * set up the console device so that later boot sequences can
3842 * inform about problems etc..
3843 */
3844#ifdef CONFIG_EARLY_PRINTK
3845 disable_early_printk();
3846#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003847 call = __con_initcall_start;
3848 while (call < __con_initcall_end) {
3849 (*call)();
3850 call++;
3851 }
3852}
3853
3854#ifdef CONFIG_VT
3855extern int vty_init(void);
3856#endif
3857
3858static int __init tty_class_init(void)
3859{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003860 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003861 if (IS_ERR(tty_class))
3862 return PTR_ERR(tty_class);
3863 return 0;
3864}
3865
3866postcore_initcall(tty_class_init);
3867
3868/* 3/2004 jmc: why do these devices exist? */
3869
3870static struct cdev tty_cdev, console_cdev;
3871#ifdef CONFIG_UNIX98_PTYS
3872static struct cdev ptmx_cdev;
3873#endif
3874#ifdef CONFIG_VT
3875static struct cdev vc0_cdev;
3876#endif
3877
3878/*
3879 * Ok, now we can initialize the rest of the tty devices and can count
3880 * on memory allocations, interrupts etc..
3881 */
3882static int __init tty_init(void)
3883{
3884 cdev_init(&tty_cdev, &tty_fops);
3885 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3886 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3887 panic("Couldn't register /dev/tty driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003888 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003889
3890 cdev_init(&console_cdev, &console_fops);
3891 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3892 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3893 panic("Couldn't register /dev/console driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003894 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003895
3896#ifdef CONFIG_UNIX98_PTYS
3897 cdev_init(&ptmx_cdev, &ptmx_fops);
3898 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3899 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3900 panic("Couldn't register /dev/ptmx driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003901 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902#endif
3903
3904#ifdef CONFIG_VT
3905 cdev_init(&vc0_cdev, &console_fops);
3906 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3907 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3908 panic("Couldn't register /dev/tty0 driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003909 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003910
3911 vty_init();
3912#endif
3913 return 0;
3914}
3915module_init(tty_init);