blob: e90ea39c7c4b1112fd7d7db878b96d8531a0f162 [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);
Alan Coxde2a84f2006-09-29 02:00:57 -0700132EXPORT_SYMBOL(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
134#ifdef CONFIG_UNIX98_PTYS
135extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
136extern int pty_limit; /* Config limit on Unix98 ptys */
137static DEFINE_IDR(allocated_ptys);
138static DECLARE_MUTEX(allocated_ptys_lock);
139static int ptmx_open(struct inode *, struct file *);
140#endif
141
142extern void disable_early_printk(void);
143
144static void initialize_tty_struct(struct tty_struct *tty);
145
146static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149static unsigned int tty_poll(struct file *, poll_table *);
150static int tty_open(struct inode *, struct file *);
151static int tty_release(struct inode *, struct file *);
152int tty_ioctl(struct inode * inode, struct file * file,
153 unsigned int cmd, unsigned long arg);
154static int tty_fasync(int fd, struct file * filp, int on);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155static void release_mem(struct tty_struct *tty, int idx);
156
Alan Coxaf9b8972006-08-27 01:24:01 -0700157/**
158 * alloc_tty_struct - allocate a tty object
159 *
160 * Return a new empty tty structure. The data fields have not
161 * been initialized in any way but has been zeroed
162 *
163 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700164 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166static struct tty_struct *alloc_tty_struct(void)
167{
Alan Cox1266b1e2006-09-29 02:00:40 -0700168 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
170
Alan Cox33f0f882006-01-09 20:54:13 -0800171static void tty_buffer_free_all(struct tty_struct *);
172
Alan Coxaf9b8972006-08-27 01:24:01 -0700173/**
174 * free_tty_struct - free a disused tty
175 * @tty: tty struct to free
176 *
177 * Free the write buffers, tty queue and tty memory itself.
178 *
179 * Locking: none. Must be called after tty is definitely unused
180 */
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182static inline void free_tty_struct(struct tty_struct *tty)
183{
184 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800185 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 kfree(tty);
187}
188
189#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
190
Alan Coxaf9b8972006-08-27 01:24:01 -0700191/**
192 * tty_name - return tty naming
193 * @tty: tty structure
194 * @buf: buffer for output
195 *
196 * Convert a tty structure into a name. The name reflects the kernel
197 * naming policy and if udev is in use may not reflect user space
198 *
199 * Locking: none
200 */
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202char *tty_name(struct tty_struct *tty, char *buf)
203{
204 if (!tty) /* Hmm. NULL pointer. That's fun. */
205 strcpy(buf, "NULL tty");
206 else
207 strcpy(buf, tty->name);
208 return buf;
209}
210
211EXPORT_SYMBOL(tty_name);
212
Andrew Mortond769a662005-05-05 16:15:50 -0700213int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 const char *routine)
215{
216#ifdef TTY_PARANOIA_CHECK
217 if (!tty) {
218 printk(KERN_WARNING
219 "null TTY for (%d:%d) in %s\n",
220 imajor(inode), iminor(inode), routine);
221 return 1;
222 }
223 if (tty->magic != TTY_MAGIC) {
224 printk(KERN_WARNING
225 "bad magic number for tty struct (%d:%d) in %s\n",
226 imajor(inode), iminor(inode), routine);
227 return 1;
228 }
229#endif
230 return 0;
231}
232
233static int check_tty_count(struct tty_struct *tty, const char *routine)
234{
235#ifdef CHECK_TTY_COUNT
236 struct list_head *p;
237 int count = 0;
238
239 file_list_lock();
240 list_for_each(p, &tty->tty_files) {
241 count++;
242 }
243 file_list_unlock();
244 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
245 tty->driver->subtype == PTY_TYPE_SLAVE &&
246 tty->link && tty->link->count)
247 count++;
248 if (tty->count != count) {
249 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
250 "!= #fd's(%d) in %s\n",
251 tty->name, tty->count, count, routine);
252 return count;
253 }
254#endif
255 return 0;
256}
257
258/*
Alan Cox33f0f882006-01-09 20:54:13 -0800259 * Tty buffer allocation management
260 */
261
Alan Coxaf9b8972006-08-27 01:24:01 -0700262
263/**
264 * tty_buffer_free_all - free buffers used by a tty
265 * @tty: tty to free from
266 *
267 * Remove all the buffers pending on a tty whether queued with data
268 * or in the free ring. Must be called when the tty is no longer in use
269 *
270 * Locking: none
271 */
272
Alan Cox01da5fd2006-08-27 01:24:02 -0700273
274/**
275 * tty_buffer_free_all - free buffers used by a tty
276 * @tty: tty to free from
277 *
278 * Remove all the buffers pending on a tty whether queued with data
279 * or in the free ring. Must be called when the tty is no longer in use
280 *
281 * Locking: none
282 */
283
Alan Cox33f0f882006-01-09 20:54:13 -0800284static void tty_buffer_free_all(struct tty_struct *tty)
285{
286 struct tty_buffer *thead;
287 while((thead = tty->buf.head) != NULL) {
288 tty->buf.head = thead->next;
289 kfree(thead);
290 }
291 while((thead = tty->buf.free) != NULL) {
292 tty->buf.free = thead->next;
293 kfree(thead);
294 }
295 tty->buf.tail = NULL;
Alan Cox01da5fd2006-08-27 01:24:02 -0700296 tty->buf.memory_used = 0;
Alan Cox33f0f882006-01-09 20:54:13 -0800297}
298
Alan Cox01da5fd2006-08-27 01:24:02 -0700299/**
300 * tty_buffer_init - prepare a tty buffer structure
301 * @tty: tty to initialise
302 *
303 * Set up the initial state of the buffer management for a tty device.
304 * Must be called before the other tty buffer functions are used.
305 *
306 * Locking: none
307 */
308
Alan Cox33f0f882006-01-09 20:54:13 -0800309static void tty_buffer_init(struct tty_struct *tty)
310{
Paul Fulghum808249c2006-02-03 03:04:41 -0800311 spin_lock_init(&tty->buf.lock);
Alan Cox33f0f882006-01-09 20:54:13 -0800312 tty->buf.head = NULL;
313 tty->buf.tail = NULL;
314 tty->buf.free = NULL;
Alan Cox01da5fd2006-08-27 01:24:02 -0700315 tty->buf.memory_used = 0;
Alan Cox33f0f882006-01-09 20:54:13 -0800316}
317
Alan Cox01da5fd2006-08-27 01:24:02 -0700318/**
319 * tty_buffer_alloc - allocate a tty buffer
320 * @tty: tty device
321 * @size: desired size (characters)
322 *
323 * Allocate a new tty buffer to hold the desired number of characters.
324 * Return NULL if out of memory or the allocation would exceed the
325 * per device queue
326 *
327 * Locking: Caller must hold tty->buf.lock
328 */
329
330static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
Alan Cox33f0f882006-01-09 20:54:13 -0800331{
Alan Cox01da5fd2006-08-27 01:24:02 -0700332 struct tty_buffer *p;
333
334 if (tty->buf.memory_used + size > 65536)
335 return NULL;
336 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
Alan Cox33f0f882006-01-09 20:54:13 -0800337 if(p == NULL)
338 return NULL;
339 p->used = 0;
340 p->size = size;
341 p->next = NULL;
Paul Fulghum8977d922006-02-10 01:51:14 -0800342 p->commit = 0;
343 p->read = 0;
Alan Cox33f0f882006-01-09 20:54:13 -0800344 p->char_buf_ptr = (char *)(p->data);
345 p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
Alan Cox01da5fd2006-08-27 01:24:02 -0700346 tty->buf.memory_used += size;
Alan Cox33f0f882006-01-09 20:54:13 -0800347 return p;
348}
349
Alan Cox01da5fd2006-08-27 01:24:02 -0700350/**
351 * tty_buffer_free - free a tty buffer
352 * @tty: tty owning the buffer
353 * @b: the buffer to free
354 *
355 * Free a tty buffer, or add it to the free list according to our
356 * internal strategy
357 *
358 * Locking: Caller must hold tty->buf.lock
359 */
Alan Cox33f0f882006-01-09 20:54:13 -0800360
361static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
362{
363 /* Dumb strategy for now - should keep some stats */
Alan Cox01da5fd2006-08-27 01:24:02 -0700364 tty->buf.memory_used -= b->size;
365 WARN_ON(tty->buf.memory_used < 0);
366
Alan Cox33f0f882006-01-09 20:54:13 -0800367 if(b->size >= 512)
368 kfree(b);
369 else {
370 b->next = tty->buf.free;
371 tty->buf.free = b;
372 }
373}
374
Alan Cox01da5fd2006-08-27 01:24:02 -0700375/**
376 * tty_buffer_find - find a free tty buffer
377 * @tty: tty owning the buffer
378 * @size: characters wanted
379 *
380 * Locate an existing suitable tty buffer or if we are lacking one then
381 * allocate a new one. We round our buffers off in 256 character chunks
382 * to get better allocation behaviour.
383 *
384 * Locking: Caller must hold tty->buf.lock
385 */
386
Alan Cox33f0f882006-01-09 20:54:13 -0800387static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
388{
389 struct tty_buffer **tbh = &tty->buf.free;
390 while((*tbh) != NULL) {
391 struct tty_buffer *t = *tbh;
392 if(t->size >= size) {
393 *tbh = t->next;
394 t->next = NULL;
395 t->used = 0;
Paul Fulghum8977d922006-02-10 01:51:14 -0800396 t->commit = 0;
397 t->read = 0;
Alan Cox01da5fd2006-08-27 01:24:02 -0700398 tty->buf.memory_used += t->size;
Alan Cox33f0f882006-01-09 20:54:13 -0800399 return t;
400 }
401 tbh = &((*tbh)->next);
402 }
403 /* Round the buffer size out */
404 size = (size + 0xFF) & ~ 0xFF;
Alan Cox01da5fd2006-08-27 01:24:02 -0700405 return tty_buffer_alloc(tty, size);
Alan Cox33f0f882006-01-09 20:54:13 -0800406 /* Should possibly check if this fails for the largest buffer we
407 have queued and recycle that ? */
408}
409
Alan Cox01da5fd2006-08-27 01:24:02 -0700410/**
411 * tty_buffer_request_room - grow tty buffer if needed
412 * @tty: tty structure
413 * @size: size desired
414 *
415 * Make at least size bytes of linear space available for the tty
416 * buffer. If we fail return the size we managed to find.
417 *
418 * Locking: Takes tty->buf.lock
419 */
Alan Cox33f0f882006-01-09 20:54:13 -0800420int tty_buffer_request_room(struct tty_struct *tty, size_t size)
421{
Paul Fulghum808249c2006-02-03 03:04:41 -0800422 struct tty_buffer *b, *n;
423 int left;
424 unsigned long flags;
425
426 spin_lock_irqsave(&tty->buf.lock, flags);
Alan Cox33f0f882006-01-09 20:54:13 -0800427
428 /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
429 remove this conditional if its worth it. This would be invisible
430 to the callers */
Paul Fulghum33b37a32006-06-28 04:26:49 -0700431 if ((b = tty->buf.tail) != NULL)
Alan Cox33f0f882006-01-09 20:54:13 -0800432 left = b->size - b->used;
Paul Fulghum33b37a32006-06-28 04:26:49 -0700433 else
Paul Fulghum808249c2006-02-03 03:04:41 -0800434 left = 0;
435
436 if (left < size) {
437 /* This is the slow path - looking for new buffers to use */
438 if ((n = tty_buffer_find(tty, size)) != NULL) {
439 if (b != NULL) {
440 b->next = n;
Paul Fulghum8977d922006-02-10 01:51:14 -0800441 b->commit = b->used;
Paul Fulghum808249c2006-02-03 03:04:41 -0800442 } else
443 tty->buf.head = n;
444 tty->buf.tail = n;
Paul Fulghum808249c2006-02-03 03:04:41 -0800445 } else
446 size = left;
447 }
448
449 spin_unlock_irqrestore(&tty->buf.lock, flags);
Alan Cox33f0f882006-01-09 20:54:13 -0800450 return size;
451}
Alan Cox33f0f882006-01-09 20:54:13 -0800452EXPORT_SYMBOL_GPL(tty_buffer_request_room);
453
Alan Coxaf9b8972006-08-27 01:24:01 -0700454/**
455 * tty_insert_flip_string - Add characters to the tty buffer
456 * @tty: tty structure
457 * @chars: characters
458 * @size: size
459 *
460 * Queue a series of bytes to the tty buffering. All the characters
461 * passed are marked as without error. Returns the number added.
462 *
463 * Locking: Called functions may take tty->buf.lock
464 */
465
Andrew Mortone1a25092006-04-10 22:54:05 -0700466int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
467 size_t size)
Alan Cox33f0f882006-01-09 20:54:13 -0800468{
469 int copied = 0;
470 do {
471 int space = tty_buffer_request_room(tty, size - copied);
472 struct tty_buffer *tb = tty->buf.tail;
473 /* If there is no space then tb may be NULL */
474 if(unlikely(space == 0))
475 break;
476 memcpy(tb->char_buf_ptr + tb->used, chars, space);
477 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
478 tb->used += space;
479 copied += space;
480 chars += space;
Alexey Dobriyan527063b2006-09-29 01:59:50 -0700481 /* There is a small chance that we need to split the data over
482 several buffers. If this is the case we must loop */
483 } while (unlikely(size > copied));
Alan Cox33f0f882006-01-09 20:54:13 -0800484 return copied;
485}
Andrew Mortonee37df72006-03-31 02:30:35 -0800486EXPORT_SYMBOL(tty_insert_flip_string);
Alan Cox33f0f882006-01-09 20:54:13 -0800487
Alan Coxaf9b8972006-08-27 01:24:01 -0700488/**
489 * tty_insert_flip_string_flags - Add characters to the tty buffer
490 * @tty: tty structure
491 * @chars: characters
492 * @flags: flag bytes
493 * @size: size
494 *
495 * Queue a series of bytes to the tty buffering. For each character
496 * the flags array indicates the status of the character. Returns the
497 * number added.
498 *
499 * Locking: Called functions may take tty->buf.lock
500 */
501
Andrew Mortone1a25092006-04-10 22:54:05 -0700502int tty_insert_flip_string_flags(struct tty_struct *tty,
503 const unsigned char *chars, const char *flags, size_t size)
Alan Cox33f0f882006-01-09 20:54:13 -0800504{
505 int copied = 0;
506 do {
507 int space = tty_buffer_request_room(tty, size - copied);
508 struct tty_buffer *tb = tty->buf.tail;
509 /* If there is no space then tb may be NULL */
510 if(unlikely(space == 0))
511 break;
512 memcpy(tb->char_buf_ptr + tb->used, chars, space);
513 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
514 tb->used += space;
515 copied += space;
516 chars += space;
517 flags += space;
Alexey Dobriyan527063b2006-09-29 01:59:50 -0700518 /* There is a small chance that we need to split the data over
519 several buffers. If this is the case we must loop */
520 } while (unlikely(size > copied));
Alan Cox33f0f882006-01-09 20:54:13 -0800521 return copied;
522}
Tobias Powalowskiff4547f2006-05-22 22:35:28 -0700523EXPORT_SYMBOL(tty_insert_flip_string_flags);
Alan Cox33f0f882006-01-09 20:54:13 -0800524
Alan Coxaf9b8972006-08-27 01:24:01 -0700525/**
526 * tty_schedule_flip - push characters to ldisc
527 * @tty: tty to push from
528 *
529 * Takes any pending buffers and transfers their ownership to the
530 * ldisc side of the queue. It then schedules those characters for
531 * processing by the line discipline.
532 *
533 * Locking: Takes tty->buf.lock
534 */
535
Andrew Mortone1a25092006-04-10 22:54:05 -0700536void tty_schedule_flip(struct tty_struct *tty)
537{
538 unsigned long flags;
539 spin_lock_irqsave(&tty->buf.lock, flags);
Paul Fulghum33b37a32006-06-28 04:26:49 -0700540 if (tty->buf.tail != NULL)
Andrew Mortone1a25092006-04-10 22:54:05 -0700541 tty->buf.tail->commit = tty->buf.tail->used;
Andrew Mortone1a25092006-04-10 22:54:05 -0700542 spin_unlock_irqrestore(&tty->buf.lock, flags);
543 schedule_delayed_work(&tty->buf.work, 1);
544}
545EXPORT_SYMBOL(tty_schedule_flip);
Alan Cox33f0f882006-01-09 20:54:13 -0800546
Alan Coxaf9b8972006-08-27 01:24:01 -0700547/**
548 * tty_prepare_flip_string - make room for characters
549 * @tty: tty
550 * @chars: return pointer for character write area
551 * @size: desired size
552 *
Alan Cox33f0f882006-01-09 20:54:13 -0800553 * Prepare a block of space in the buffer for data. Returns the length
554 * available and buffer pointer to the space which is now allocated and
555 * accounted for as ready for normal characters. This is used for drivers
556 * that need their own block copy routines into the buffer. There is no
557 * guarantee the buffer is a DMA target!
Alan Coxaf9b8972006-08-27 01:24:01 -0700558 *
559 * Locking: May call functions taking tty->buf.lock
Alan Cox33f0f882006-01-09 20:54:13 -0800560 */
561
562int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
563{
564 int space = tty_buffer_request_room(tty, size);
Paul Fulghum808249c2006-02-03 03:04:41 -0800565 if (likely(space)) {
566 struct tty_buffer *tb = tty->buf.tail;
567 *chars = tb->char_buf_ptr + tb->used;
568 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
569 tb->used += space;
570 }
Alan Cox33f0f882006-01-09 20:54:13 -0800571 return space;
572}
573
574EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
575
Alan Coxaf9b8972006-08-27 01:24:01 -0700576/**
577 * tty_prepare_flip_string_flags - make room for characters
578 * @tty: tty
579 * @chars: return pointer for character write area
580 * @flags: return pointer for status flag write area
581 * @size: desired size
582 *
Alan Cox33f0f882006-01-09 20:54:13 -0800583 * Prepare a block of space in the buffer for data. Returns the length
584 * available and buffer pointer to the space which is now allocated and
585 * accounted for as ready for characters. This is used for drivers
586 * that need their own block copy routines into the buffer. There is no
587 * guarantee the buffer is a DMA target!
Alan Coxaf9b8972006-08-27 01:24:01 -0700588 *
589 * Locking: May call functions taking tty->buf.lock
Alan Cox33f0f882006-01-09 20:54:13 -0800590 */
591
592int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
593{
594 int space = tty_buffer_request_room(tty, size);
Paul Fulghum808249c2006-02-03 03:04:41 -0800595 if (likely(space)) {
596 struct tty_buffer *tb = tty->buf.tail;
597 *chars = tb->char_buf_ptr + tb->used;
598 *flags = tb->flag_buf_ptr + tb->used;
599 tb->used += space;
600 }
Alan Cox33f0f882006-01-09 20:54:13 -0800601 return space;
602}
603
604EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
605
606
607
Alan Coxaf9b8972006-08-27 01:24:01 -0700608/**
609 * tty_set_termios_ldisc - set ldisc field
610 * @tty: tty structure
611 * @num: line discipline number
612 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 * This is probably overkill for real world processors but
614 * they are not on hot paths so a little discipline won't do
615 * any harm.
Alan Coxaf9b8972006-08-27 01:24:01 -0700616 *
617 * Locking: takes termios_sem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 */
619
620static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
621{
Arjan van de Ven5785c952006-09-29 02:00:43 -0700622 mutex_lock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 tty->termios->c_line = num;
Arjan van de Ven5785c952006-09-29 02:00:43 -0700624 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625}
626
627/*
628 * This guards the refcounted line discipline lists. The lock
629 * must be taken with irqs off because there are hangup path
630 * callers who will do ldisc lookups and cannot sleep.
631 */
632
633static DEFINE_SPINLOCK(tty_ldisc_lock);
634static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
Alexey Dobriyanbfb07592005-06-23 00:10:32 -0700635static struct tty_ldisc tty_ldiscs[NR_LDISCS]; /* line disc dispatch table */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
Alan Coxaf9b8972006-08-27 01:24:01 -0700637/**
638 * tty_register_ldisc - install a line discipline
639 * @disc: ldisc number
640 * @new_ldisc: pointer to the ldisc object
641 *
642 * Installs a new line discipline into the kernel. The discipline
643 * is set up as unreferenced and then made available to the kernel
644 * from this point onwards.
645 *
646 * Locking:
647 * takes tty_ldisc_lock to guard against ldisc races
648 */
649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
651{
652 unsigned long flags;
653 int ret = 0;
654
655 if (disc < N_TTY || disc >= NR_LDISCS)
656 return -EINVAL;
657
658 spin_lock_irqsave(&tty_ldisc_lock, flags);
Alexey Dobriyanbfb07592005-06-23 00:10:32 -0700659 tty_ldiscs[disc] = *new_ldisc;
660 tty_ldiscs[disc].num = disc;
661 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
662 tty_ldiscs[disc].refcount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
664
665 return ret;
666}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667EXPORT_SYMBOL(tty_register_ldisc);
668
Alan Coxaf9b8972006-08-27 01:24:01 -0700669/**
670 * tty_unregister_ldisc - unload a line discipline
671 * @disc: ldisc number
672 * @new_ldisc: pointer to the ldisc object
673 *
674 * Remove a line discipline from the kernel providing it is not
675 * currently in use.
676 *
677 * Locking:
678 * takes tty_ldisc_lock to guard against ldisc races
679 */
680
Alexey Dobriyanbfb07592005-06-23 00:10:32 -0700681int tty_unregister_ldisc(int disc)
682{
683 unsigned long flags;
684 int ret = 0;
685
686 if (disc < N_TTY || disc >= NR_LDISCS)
687 return -EINVAL;
688
689 spin_lock_irqsave(&tty_ldisc_lock, flags);
690 if (tty_ldiscs[disc].refcount)
691 ret = -EBUSY;
692 else
693 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
694 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
695
696 return ret;
697}
698EXPORT_SYMBOL(tty_unregister_ldisc);
699
Alan Coxaf9b8972006-08-27 01:24:01 -0700700/**
701 * tty_ldisc_get - take a reference to an ldisc
702 * @disc: ldisc number
703 *
704 * Takes a reference to a line discipline. Deals with refcounts and
705 * module locking counts. Returns NULL if the discipline is not available.
706 * Returns a pointer to the discipline and bumps the ref count if it is
707 * available
708 *
709 * Locking:
710 * takes tty_ldisc_lock to guard against ldisc races
711 */
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713struct tty_ldisc *tty_ldisc_get(int disc)
714{
715 unsigned long flags;
716 struct tty_ldisc *ld;
717
718 if (disc < N_TTY || disc >= NR_LDISCS)
719 return NULL;
720
721 spin_lock_irqsave(&tty_ldisc_lock, flags);
722
723 ld = &tty_ldiscs[disc];
724 /* Check the entry is defined */
725 if(ld->flags & LDISC_FLAG_DEFINED)
726 {
727 /* If the module is being unloaded we can't use it */
728 if (!try_module_get(ld->owner))
729 ld = NULL;
730 else /* lock it */
731 ld->refcount++;
732 }
733 else
734 ld = NULL;
735 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
736 return ld;
737}
738
739EXPORT_SYMBOL_GPL(tty_ldisc_get);
740
Alan Coxaf9b8972006-08-27 01:24:01 -0700741/**
742 * tty_ldisc_put - drop ldisc reference
743 * @disc: ldisc number
744 *
745 * Drop a reference to a line discipline. Manage refcounts and
746 * module usage counts
747 *
748 * Locking:
749 * takes tty_ldisc_lock to guard against ldisc races
750 */
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752void tty_ldisc_put(int disc)
753{
754 struct tty_ldisc *ld;
755 unsigned long flags;
756
Eric Sesterhenn56ee4822006-03-26 18:17:21 +0200757 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759 spin_lock_irqsave(&tty_ldisc_lock, flags);
760 ld = &tty_ldiscs[disc];
Eric Sesterhenn56ee4822006-03-26 18:17:21 +0200761 BUG_ON(ld->refcount == 0);
762 ld->refcount--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 module_put(ld->owner);
764 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
765}
766
767EXPORT_SYMBOL_GPL(tty_ldisc_put);
768
Alan Coxaf9b8972006-08-27 01:24:01 -0700769/**
770 * tty_ldisc_assign - set ldisc on a tty
771 * @tty: tty to assign
772 * @ld: line discipline
773 *
774 * Install an instance of a line discipline into a tty structure. The
775 * ldisc must have a reference count above zero to ensure it remains/
776 * The tty instance refcount starts at zero.
777 *
778 * Locking:
779 * Caller must hold references
780 */
781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
783{
784 tty->ldisc = *ld;
785 tty->ldisc.refcount = 0;
786}
787
788/**
789 * tty_ldisc_try - internal helper
790 * @tty: the tty
791 *
792 * Make a single attempt to grab and bump the refcount on
793 * the tty ldisc. Return 0 on failure or 1 on success. This is
794 * used to implement both the waiting and non waiting versions
795 * of tty_ldisc_ref
Alan Coxaf9b8972006-08-27 01:24:01 -0700796 *
797 * Locking: takes tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 */
799
800static int tty_ldisc_try(struct tty_struct *tty)
801{
802 unsigned long flags;
803 struct tty_ldisc *ld;
804 int ret = 0;
805
806 spin_lock_irqsave(&tty_ldisc_lock, flags);
807 ld = &tty->ldisc;
808 if(test_bit(TTY_LDISC, &tty->flags))
809 {
810 ld->refcount++;
811 ret = 1;
812 }
813 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
814 return ret;
815}
816
817/**
818 * tty_ldisc_ref_wait - wait for the tty ldisc
819 * @tty: tty device
820 *
821 * Dereference the line discipline for the terminal and take a
822 * reference to it. If the line discipline is in flux then
823 * wait patiently until it changes.
824 *
825 * Note: Must not be called from an IRQ/timer context. The caller
826 * must also be careful not to hold other locks that will deadlock
827 * against a discipline change, such as an existing ldisc reference
828 * (which we check for)
Alan Coxaf9b8972006-08-27 01:24:01 -0700829 *
830 * Locking: call functions take tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 */
832
833struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
834{
835 /* wait_event is a macro */
836 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
837 if(tty->ldisc.refcount == 0)
838 printk(KERN_ERR "tty_ldisc_ref_wait\n");
839 return &tty->ldisc;
840}
841
842EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
843
844/**
845 * tty_ldisc_ref - get the tty ldisc
846 * @tty: tty device
847 *
848 * Dereference the line discipline for the terminal and take a
849 * reference to it. If the line discipline is in flux then
850 * return NULL. Can be called from IRQ and timer functions.
Alan Coxaf9b8972006-08-27 01:24:01 -0700851 *
852 * Locking: called functions take tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 */
854
855struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
856{
857 if(tty_ldisc_try(tty))
858 return &tty->ldisc;
859 return NULL;
860}
861
862EXPORT_SYMBOL_GPL(tty_ldisc_ref);
863
864/**
865 * tty_ldisc_deref - free a tty ldisc reference
866 * @ld: reference to free up
867 *
868 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
869 * be called in IRQ context.
Alan Coxaf9b8972006-08-27 01:24:01 -0700870 *
871 * Locking: takes tty_ldisc_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 */
873
874void tty_ldisc_deref(struct tty_ldisc *ld)
875{
876 unsigned long flags;
877
Eric Sesterhenn56ee4822006-03-26 18:17:21 +0200878 BUG_ON(ld == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
880 spin_lock_irqsave(&tty_ldisc_lock, flags);
881 if(ld->refcount == 0)
882 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
883 else
884 ld->refcount--;
885 if(ld->refcount == 0)
886 wake_up(&tty_ldisc_wait);
887 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
888}
889
890EXPORT_SYMBOL_GPL(tty_ldisc_deref);
891
892/**
893 * tty_ldisc_enable - allow ldisc use
894 * @tty: terminal to activate ldisc on
895 *
896 * Set the TTY_LDISC flag when the line discipline can be called
897 * again. Do neccessary wakeups for existing sleepers.
898 *
899 * Note: nobody should set this bit except via this function. Clearing
900 * directly is allowed.
901 */
902
903static void tty_ldisc_enable(struct tty_struct *tty)
904{
905 set_bit(TTY_LDISC, &tty->flags);
906 wake_up(&tty_ldisc_wait);
907}
908
909/**
910 * tty_set_ldisc - set line discipline
911 * @tty: the terminal to set
912 * @ldisc: the line discipline
913 *
914 * Set the discipline of a tty line. Must be called from a process
915 * context.
Alan Coxaf9b8972006-08-27 01:24:01 -0700916 *
917 * Locking: takes tty_ldisc_lock.
918 * called functions take termios_sem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 */
920
921static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
922{
Jason Baronff55fe22005-09-09 13:01:57 -0700923 int retval = 0;
924 struct tty_ldisc o_ldisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 char buf[64];
926 int work;
927 unsigned long flags;
928 struct tty_ldisc *ld;
Jason Baronff55fe22005-09-09 13:01:57 -0700929 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
931 if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
932 return -EINVAL;
933
934restart:
935
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 ld = tty_ldisc_get(ldisc);
937 /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
938 /* Cyrus Durgin <cider@speakeasy.org> */
939 if (ld == NULL) {
940 request_module("tty-ldisc-%d", ldisc);
941 ld = tty_ldisc_get(ldisc);
942 }
943 if (ld == NULL)
944 return -EINVAL;
945
Alan Cox33f0f882006-01-09 20:54:13 -0800946 /*
947 * No more input please, we are switching. The new ldisc
948 * will update this value in the ldisc open function
949 */
950
951 tty->receive_room = 0;
952
953 /*
954 * Problem: What do we do if this blocks ?
955 */
956
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 tty_wait_until_sent(tty, 0);
958
Jason Baronff55fe22005-09-09 13:01:57 -0700959 if (tty->ldisc.num == ldisc) {
960 tty_ldisc_put(ldisc);
961 return 0;
962 }
963
964 o_ldisc = tty->ldisc;
965 o_tty = tty->link;
966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 /*
968 * Make sure we don't change while someone holds a
969 * reference to the line discipline. The TTY_LDISC bit
970 * prevents anyone taking a reference once it is clear.
971 * We need the lock to avoid racing reference takers.
972 */
Jason Baronff55fe22005-09-09 13:01:57 -0700973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 spin_lock_irqsave(&tty_ldisc_lock, flags);
Jason Baronff55fe22005-09-09 13:01:57 -0700975 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
976 if(tty->ldisc.refcount) {
977 /* Free the new ldisc we grabbed. Must drop the lock
978 first. */
979 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
980 tty_ldisc_put(ldisc);
981 /*
982 * There are several reasons we may be busy, including
983 * random momentary I/O traffic. We must therefore
984 * retry. We could distinguish between blocking ops
985 * and retries if we made tty_ldisc_wait() smarter. That
986 * is up for discussion.
987 */
988 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
989 return -ERESTARTSYS;
990 goto restart;
991 }
992 if(o_tty && o_tty->ldisc.refcount) {
993 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
994 tty_ldisc_put(ldisc);
995 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
996 return -ERESTARTSYS;
997 goto restart;
998 }
999 }
1000
1001 /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
1002
1003 if (!test_bit(TTY_LDISC, &tty->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1005 tty_ldisc_put(ldisc);
Jason Baronff55fe22005-09-09 13:01:57 -07001006 ld = tty_ldisc_ref_wait(tty);
1007 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 goto restart;
1009 }
Jason Baronff55fe22005-09-09 13:01:57 -07001010
1011 clear_bit(TTY_LDISC, &tty->flags);
Paul Fulghum817d6d32006-06-28 04:26:47 -07001012 if (o_tty)
Jason Baronff55fe22005-09-09 13:01:57 -07001013 clear_bit(TTY_LDISC, &o_tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
Jason Baronff55fe22005-09-09 13:01:57 -07001015
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 /*
1017 * From this point on we know nobody has an ldisc
1018 * usage reference, nor can they obtain one until
1019 * we say so later on.
1020 */
Jason Baronff55fe22005-09-09 13:01:57 -07001021
Alan Cox33f0f882006-01-09 20:54:13 -08001022 work = cancel_delayed_work(&tty->buf.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 /*
Alan Cox33f0f882006-01-09 20:54:13 -08001024 * Wait for ->hangup_work and ->buf.work handlers to terminate
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 */
1026
1027 flush_scheduled_work();
1028 /* Shutdown the current discipline. */
1029 if (tty->ldisc.close)
1030 (tty->ldisc.close)(tty);
1031
1032 /* Now set up the new line discipline. */
1033 tty_ldisc_assign(tty, ld);
1034 tty_set_termios_ldisc(tty, ldisc);
1035 if (tty->ldisc.open)
1036 retval = (tty->ldisc.open)(tty);
1037 if (retval < 0) {
1038 tty_ldisc_put(ldisc);
1039 /* There is an outstanding reference here so this is safe */
1040 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1041 tty_set_termios_ldisc(tty, tty->ldisc.num);
1042 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1043 tty_ldisc_put(o_ldisc.num);
1044 /* This driver is always present */
1045 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1046 tty_set_termios_ldisc(tty, N_TTY);
1047 if (tty->ldisc.open) {
1048 int r = tty->ldisc.open(tty);
1049
1050 if (r < 0)
1051 panic("Couldn't open N_TTY ldisc for "
1052 "%s --- error %d.",
1053 tty_name(tty, buf), r);
1054 }
1055 }
1056 }
1057 /* At this point we hold a reference to the new ldisc and a
1058 a reference to the old ldisc. If we ended up flipping back
1059 to the existing ldisc we have two references to it */
1060
1061 if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1062 tty->driver->set_ldisc(tty);
1063
1064 tty_ldisc_put(o_ldisc.num);
1065
1066 /*
1067 * Allow ldisc referencing to occur as soon as the driver
1068 * ldisc callback completes.
1069 */
1070
1071 tty_ldisc_enable(tty);
Jason Baronff55fe22005-09-09 13:01:57 -07001072 if (o_tty)
1073 tty_ldisc_enable(o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
1075 /* Restart it in case no characters kick it off. Safe if
1076 already running */
Jason Baronff55fe22005-09-09 13:01:57 -07001077 if (work)
Alan Cox33f0f882006-01-09 20:54:13 -08001078 schedule_delayed_work(&tty->buf.work, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 return retval;
1080}
1081
Alan Coxaf9b8972006-08-27 01:24:01 -07001082/**
1083 * get_tty_driver - find device of a tty
1084 * @dev_t: device identifier
1085 * @index: returns the index of the tty
1086 *
1087 * This routine returns a tty driver structure, given a device number
1088 * and also passes back the index number.
1089 *
1090 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001092
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093static struct tty_driver *get_tty_driver(dev_t device, int *index)
1094{
1095 struct tty_driver *p;
1096
1097 list_for_each_entry(p, &tty_drivers, tty_drivers) {
1098 dev_t base = MKDEV(p->major, p->minor_start);
1099 if (device < base || device >= base + p->num)
1100 continue;
1101 *index = device - base;
1102 return p;
1103 }
1104 return NULL;
1105}
1106
Alan Coxaf9b8972006-08-27 01:24:01 -07001107/**
1108 * tty_check_change - check for POSIX terminal changes
1109 * @tty: tty to check
1110 *
1111 * If we try to write to, or set the state of, a terminal and we're
1112 * not in the foreground, send a SIGTTOU. If the signal is blocked or
1113 * ignored, go ahead and perform the operation. (POSIX 7.2)
1114 *
1115 * Locking: none
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001117
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118int tty_check_change(struct tty_struct * tty)
1119{
1120 if (current->signal->tty != tty)
1121 return 0;
1122 if (tty->pgrp <= 0) {
1123 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
1124 return 0;
1125 }
1126 if (process_group(current) == tty->pgrp)
1127 return 0;
1128 if (is_ignored(SIGTTOU))
1129 return 0;
1130 if (is_orphaned_pgrp(process_group(current)))
1131 return -EIO;
1132 (void) kill_pg(process_group(current), SIGTTOU, 1);
1133 return -ERESTARTSYS;
1134}
1135
1136EXPORT_SYMBOL(tty_check_change);
1137
1138static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1139 size_t count, loff_t *ppos)
1140{
1141 return 0;
1142}
1143
1144static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1145 size_t count, loff_t *ppos)
1146{
1147 return -EIO;
1148}
1149
1150/* No kernel lock held - none needed ;) */
1151static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1152{
1153 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1154}
1155
1156static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1157 unsigned int cmd, unsigned long arg)
1158{
1159 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1160}
1161
Arjan van de Ven62322d22006-07-03 00:24:21 -07001162static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 .llseek = no_llseek,
1164 .read = tty_read,
1165 .write = tty_write,
1166 .poll = tty_poll,
1167 .ioctl = tty_ioctl,
1168 .open = tty_open,
1169 .release = tty_release,
1170 .fasync = tty_fasync,
1171};
1172
1173#ifdef CONFIG_UNIX98_PTYS
Arjan van de Ven62322d22006-07-03 00:24:21 -07001174static const struct file_operations ptmx_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 .llseek = no_llseek,
1176 .read = tty_read,
1177 .write = tty_write,
1178 .poll = tty_poll,
1179 .ioctl = tty_ioctl,
1180 .open = ptmx_open,
1181 .release = tty_release,
1182 .fasync = tty_fasync,
1183};
1184#endif
1185
Arjan van de Ven62322d22006-07-03 00:24:21 -07001186static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 .llseek = no_llseek,
1188 .read = tty_read,
1189 .write = redirected_tty_write,
1190 .poll = tty_poll,
1191 .ioctl = tty_ioctl,
1192 .open = tty_open,
1193 .release = tty_release,
1194 .fasync = tty_fasync,
1195};
1196
Arjan van de Ven62322d22006-07-03 00:24:21 -07001197static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 .llseek = no_llseek,
1199 .read = hung_up_tty_read,
1200 .write = hung_up_tty_write,
1201 .poll = hung_up_tty_poll,
1202 .ioctl = hung_up_tty_ioctl,
1203 .release = tty_release,
1204};
1205
1206static DEFINE_SPINLOCK(redirect_lock);
1207static struct file *redirect;
1208
1209/**
1210 * tty_wakeup - request more data
1211 * @tty: terminal
1212 *
1213 * Internal and external helper for wakeups of tty. This function
1214 * informs the line discipline if present that the driver is ready
1215 * to receive more output data.
1216 */
1217
1218void tty_wakeup(struct tty_struct *tty)
1219{
1220 struct tty_ldisc *ld;
1221
1222 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1223 ld = tty_ldisc_ref(tty);
1224 if(ld) {
1225 if(ld->write_wakeup)
1226 ld->write_wakeup(tty);
1227 tty_ldisc_deref(ld);
1228 }
1229 }
1230 wake_up_interruptible(&tty->write_wait);
1231}
1232
1233EXPORT_SYMBOL_GPL(tty_wakeup);
1234
1235/**
1236 * tty_ldisc_flush - flush line discipline queue
1237 * @tty: tty
1238 *
1239 * Flush the line discipline queue (if any) for this tty. If there
1240 * is no line discipline active this is a no-op.
1241 */
1242
1243void tty_ldisc_flush(struct tty_struct *tty)
1244{
1245 struct tty_ldisc *ld = tty_ldisc_ref(tty);
1246 if(ld) {
1247 if(ld->flush_buffer)
1248 ld->flush_buffer(tty);
1249 tty_ldisc_deref(ld);
1250 }
1251}
1252
1253EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1254
Alan Coxaf9b8972006-08-27 01:24:01 -07001255/**
1256 * do_tty_hangup - actual handler for hangup events
1257 * @data: tty device
1258 *
1259 * This can be called by the "eventd" kernel thread. That is process
1260 * synchronous but doesn't hold any locks, so we need to make sure we
1261 * have the appropriate locks for what we're doing.
1262 *
1263 * The hangup event clears any pending redirections onto the hung up
1264 * device. It ensures future writes will error and it does the needed
1265 * line discipline hangup and signal delivery. The tty object itself
1266 * remains intact.
1267 *
1268 * Locking:
1269 * BKL
1270 * redirect lock for undoing redirection
1271 * file list lock for manipulating list of ttys
1272 * tty_ldisc_lock from called functions
1273 * termios_sem resetting termios data
1274 * tasklist_lock to walk task list for hangup event
1275 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 */
1277static void do_tty_hangup(void *data)
1278{
1279 struct tty_struct *tty = (struct tty_struct *) data;
1280 struct file * cons_filp = NULL;
1281 struct file *filp, *f = NULL;
1282 struct task_struct *p;
1283 struct tty_ldisc *ld;
1284 int closecount = 0, n;
1285
1286 if (!tty)
1287 return;
1288
1289 /* inuse_filps is protected by the single kernel lock */
1290 lock_kernel();
1291
1292 spin_lock(&redirect_lock);
1293 if (redirect && redirect->private_data == tty) {
1294 f = redirect;
1295 redirect = NULL;
1296 }
1297 spin_unlock(&redirect_lock);
1298
1299 check_tty_count(tty, "do_tty_hangup");
1300 file_list_lock();
1301 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Eric Dumazet2f512012005-10-30 15:02:16 -08001302 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 if (filp->f_op->write == redirected_tty_write)
1304 cons_filp = filp;
1305 if (filp->f_op->write != tty_write)
1306 continue;
1307 closecount++;
1308 tty_fasync(-1, filp, 0); /* can't block */
1309 filp->f_op = &hung_up_tty_fops;
1310 }
1311 file_list_unlock();
1312
1313 /* FIXME! What are the locking issues here? This may me overdoing things..
1314 * this question is especially important now that we've removed the irqlock. */
1315
1316 ld = tty_ldisc_ref(tty);
1317 if(ld != NULL) /* We may have no line discipline at this point */
1318 {
1319 if (ld->flush_buffer)
1320 ld->flush_buffer(tty);
1321 if (tty->driver->flush_buffer)
1322 tty->driver->flush_buffer(tty);
1323 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1324 ld->write_wakeup)
1325 ld->write_wakeup(tty);
1326 if (ld->hangup)
1327 ld->hangup(tty);
1328 }
1329
1330 /* FIXME: Once we trust the LDISC code better we can wait here for
1331 ldisc completion and fix the driver call race */
1332
1333 wake_up_interruptible(&tty->write_wait);
1334 wake_up_interruptible(&tty->read_wait);
1335
1336 /*
1337 * Shutdown the current line discipline, and reset it to
1338 * N_TTY.
1339 */
1340 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1341 {
Arjan van de Ven5785c952006-09-29 02:00:43 -07001342 mutex_lock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 *tty->termios = tty->driver->init_termios;
Arjan van de Ven5785c952006-09-29 02:00:43 -07001344 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 }
1346
1347 /* Defer ldisc switch */
1348 /* tty_deferred_ldisc_switch(N_TTY);
1349
1350 This should get done automatically when the port closes and
1351 tty_release is called */
1352
1353 read_lock(&tasklist_lock);
1354 if (tty->session > 0) {
1355 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1356 if (p->signal->tty == tty)
1357 p->signal->tty = NULL;
1358 if (!p->signal->leader)
1359 continue;
Eric W. Biedermanf96a7952006-03-28 16:11:01 -08001360 group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1361 group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 if (tty->pgrp > 0)
1363 p->signal->tty_old_pgrp = tty->pgrp;
1364 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1365 }
1366 read_unlock(&tasklist_lock);
1367
1368 tty->flags = 0;
1369 tty->session = 0;
1370 tty->pgrp = -1;
1371 tty->ctrl_status = 0;
1372 /*
1373 * If one of the devices matches a console pointer, we
1374 * cannot just call hangup() because that will cause
1375 * tty->count and state->count to go out of sync.
1376 * So we just call close() the right number of times.
1377 */
1378 if (cons_filp) {
1379 if (tty->driver->close)
1380 for (n = 0; n < closecount; n++)
1381 tty->driver->close(tty, cons_filp);
1382 } else if (tty->driver->hangup)
1383 (tty->driver->hangup)(tty);
1384
1385 /* We don't want to have driver/ldisc interactions beyond
1386 the ones we did here. The driver layer expects no
1387 calls after ->hangup() from the ldisc side. However we
1388 can't yet guarantee all that */
1389
1390 set_bit(TTY_HUPPED, &tty->flags);
1391 if (ld) {
1392 tty_ldisc_enable(tty);
1393 tty_ldisc_deref(ld);
1394 }
1395 unlock_kernel();
1396 if (f)
1397 fput(f);
1398}
1399
Alan Coxaf9b8972006-08-27 01:24:01 -07001400/**
1401 * tty_hangup - trigger a hangup event
1402 * @tty: tty to hangup
1403 *
1404 * A carrier loss (virtual or otherwise) has occurred on this like
1405 * schedule a hangup sequence to run after this event.
1406 */
1407
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408void tty_hangup(struct tty_struct * tty)
1409{
1410#ifdef TTY_DEBUG_HANGUP
1411 char buf[64];
1412
1413 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1414#endif
1415 schedule_work(&tty->hangup_work);
1416}
1417
1418EXPORT_SYMBOL(tty_hangup);
1419
Alan Coxaf9b8972006-08-27 01:24:01 -07001420/**
1421 * tty_vhangup - process vhangup
1422 * @tty: tty to hangup
1423 *
1424 * The user has asked via system call for the terminal to be hung up.
1425 * We do this synchronously so that when the syscall returns the process
1426 * is complete. That guarantee is neccessary for security reasons.
1427 */
1428
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429void tty_vhangup(struct tty_struct * tty)
1430{
1431#ifdef TTY_DEBUG_HANGUP
1432 char buf[64];
1433
1434 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1435#endif
1436 do_tty_hangup((void *) tty);
1437}
1438EXPORT_SYMBOL(tty_vhangup);
1439
Alan Coxaf9b8972006-08-27 01:24:01 -07001440/**
1441 * tty_hung_up_p - was tty hung up
1442 * @filp: file pointer of tty
1443 *
1444 * Return true if the tty has been subject to a vhangup or a carrier
1445 * loss
1446 */
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448int tty_hung_up_p(struct file * filp)
1449{
1450 return (filp->f_op == &hung_up_tty_fops);
1451}
1452
1453EXPORT_SYMBOL(tty_hung_up_p);
1454
Alan Coxaf9b8972006-08-27 01:24:01 -07001455/**
1456 * disassociate_ctty - disconnect controlling tty
1457 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001459 * This function is typically called only by the session leader, when
1460 * it wants to disassociate itself from its controlling tty.
1461 *
1462 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
1464 * (2) Clears the tty from being controlling the session
1465 * (3) Clears the controlling tty for all processes in the
1466 * session group.
1467 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001468 * The argument on_exit is set to 1 if called when a process is
1469 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
1470 *
1471 * Locking: tty_mutex is taken to protect current->signal->tty
1472 * BKL is taken for hysterical raisins
1473 * Tasklist lock is taken (under tty_mutex) to walk process
1474 * lists for the session.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001476
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477void disassociate_ctty(int on_exit)
1478{
1479 struct tty_struct *tty;
1480 struct task_struct *p;
1481 int tty_pgrp = -1;
1482
1483 lock_kernel();
1484
Ingo Molnar70522e12006-03-23 03:00:31 -08001485 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 tty = current->signal->tty;
1487 if (tty) {
1488 tty_pgrp = tty->pgrp;
Ingo Molnar70522e12006-03-23 03:00:31 -08001489 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1491 tty_vhangup(tty);
1492 } else {
1493 if (current->signal->tty_old_pgrp) {
1494 kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
1495 kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
1496 }
Ingo Molnar70522e12006-03-23 03:00:31 -08001497 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 unlock_kernel();
1499 return;
1500 }
1501 if (tty_pgrp > 0) {
1502 kill_pg(tty_pgrp, SIGHUP, on_exit);
1503 if (!on_exit)
1504 kill_pg(tty_pgrp, SIGCONT, on_exit);
1505 }
1506
1507 /* Must lock changes to tty_old_pgrp */
Ingo Molnar70522e12006-03-23 03:00:31 -08001508 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 current->signal->tty_old_pgrp = 0;
1510 tty->session = 0;
1511 tty->pgrp = -1;
1512
1513 /* Now clear signal->tty under the lock */
1514 read_lock(&tasklist_lock);
1515 do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
1516 p->signal->tty = NULL;
1517 } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
1518 read_unlock(&tasklist_lock);
Ingo Molnar70522e12006-03-23 03:00:31 -08001519 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 unlock_kernel();
1521}
1522
Alan Coxaf9b8972006-08-27 01:24:01 -07001523
1524/**
1525 * stop_tty - propogate flow control
1526 * @tty: tty to stop
1527 *
1528 * Perform flow control to the driver. For PTY/TTY pairs we
1529 * must also propogate the TIOCKPKT status. May be called
1530 * on an already stopped device and will not re-call the driver
1531 * method.
1532 *
1533 * This functionality is used by both the line disciplines for
1534 * halting incoming flow and by the driver. It may therefore be
1535 * called from any context, may be under the tty atomic_write_lock
1536 * but not always.
1537 *
1538 * Locking:
1539 * Broken. Relies on BKL which is unsafe here.
1540 */
1541
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542void stop_tty(struct tty_struct *tty)
1543{
1544 if (tty->stopped)
1545 return;
1546 tty->stopped = 1;
1547 if (tty->link && tty->link->packet) {
1548 tty->ctrl_status &= ~TIOCPKT_START;
1549 tty->ctrl_status |= TIOCPKT_STOP;
1550 wake_up_interruptible(&tty->link->read_wait);
1551 }
1552 if (tty->driver->stop)
1553 (tty->driver->stop)(tty);
1554}
1555
1556EXPORT_SYMBOL(stop_tty);
1557
Alan Coxaf9b8972006-08-27 01:24:01 -07001558/**
1559 * start_tty - propogate flow control
1560 * @tty: tty to start
1561 *
1562 * Start a tty that has been stopped if at all possible. Perform
1563 * any neccessary wakeups and propogate the TIOCPKT status. If this
1564 * is the tty was previous stopped and is being started then the
1565 * driver start method is invoked and the line discipline woken.
1566 *
1567 * Locking:
1568 * Broken. Relies on BKL which is unsafe here.
1569 */
1570
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571void start_tty(struct tty_struct *tty)
1572{
1573 if (!tty->stopped || tty->flow_stopped)
1574 return;
1575 tty->stopped = 0;
1576 if (tty->link && tty->link->packet) {
1577 tty->ctrl_status &= ~TIOCPKT_STOP;
1578 tty->ctrl_status |= TIOCPKT_START;
1579 wake_up_interruptible(&tty->link->read_wait);
1580 }
1581 if (tty->driver->start)
1582 (tty->driver->start)(tty);
1583
1584 /* If we have a running line discipline it may need kicking */
1585 tty_wakeup(tty);
1586 wake_up_interruptible(&tty->write_wait);
1587}
1588
1589EXPORT_SYMBOL(start_tty);
1590
Alan Coxaf9b8972006-08-27 01:24:01 -07001591/**
1592 * tty_read - read method for tty device files
1593 * @file: pointer to tty file
1594 * @buf: user buffer
1595 * @count: size of user buffer
1596 * @ppos: unused
1597 *
1598 * Perform the read system call function on this terminal device. Checks
1599 * for hung up devices before calling the line discipline method.
1600 *
1601 * Locking:
1602 * Locks the line discipline internally while needed
1603 * For historical reasons the line discipline read method is
1604 * invoked under the BKL. This will go away in time so do not rely on it
1605 * in new code. Multiple read calls may be outstanding in parallel.
1606 */
1607
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
1609 loff_t *ppos)
1610{
1611 int i;
1612 struct tty_struct * tty;
1613 struct inode *inode;
1614 struct tty_ldisc *ld;
1615
1616 tty = (struct tty_struct *)file->private_data;
1617 inode = file->f_dentry->d_inode;
1618 if (tty_paranoia_check(tty, inode, "tty_read"))
1619 return -EIO;
1620 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1621 return -EIO;
1622
1623 /* We want to wait for the line discipline to sort out in this
1624 situation */
1625 ld = tty_ldisc_ref_wait(tty);
1626 lock_kernel();
1627 if (ld->read)
1628 i = (ld->read)(tty,file,buf,count);
1629 else
1630 i = -EIO;
1631 tty_ldisc_deref(ld);
1632 unlock_kernel();
1633 if (i > 0)
1634 inode->i_atime = current_fs_time(inode->i_sb);
1635 return i;
1636}
1637
1638/*
1639 * Split writes up in sane blocksizes to avoid
1640 * denial-of-service type attacks
1641 */
1642static inline ssize_t do_tty_write(
1643 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1644 struct tty_struct *tty,
1645 struct file *file,
1646 const char __user *buf,
1647 size_t count)
1648{
1649 ssize_t ret = 0, written = 0;
1650 unsigned int chunk;
1651
Alan Coxaf9b8972006-08-27 01:24:01 -07001652 /* FIXME: O_NDELAY ... */
Ingo Molnar70522e12006-03-23 03:00:31 -08001653 if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 return -ERESTARTSYS;
1655 }
1656
1657 /*
1658 * We chunk up writes into a temporary buffer. This
1659 * simplifies low-level drivers immensely, since they
1660 * don't have locking issues and user mode accesses.
1661 *
1662 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1663 * big chunk-size..
1664 *
1665 * The default chunk-size is 2kB, because the NTTY
1666 * layer has problems with bigger chunks. It will
1667 * claim to be able to handle more characters than
1668 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001669 *
1670 * FIXME: This can probably go away now except that 64K chunks
1671 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 */
1673 chunk = 2048;
1674 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1675 chunk = 65536;
1676 if (count < chunk)
1677 chunk = count;
1678
Ingo Molnar70522e12006-03-23 03:00:31 -08001679 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 if (tty->write_cnt < chunk) {
1681 unsigned char *buf;
1682
1683 if (chunk < 1024)
1684 chunk = 1024;
1685
1686 buf = kmalloc(chunk, GFP_KERNEL);
1687 if (!buf) {
Ingo Molnar70522e12006-03-23 03:00:31 -08001688 mutex_unlock(&tty->atomic_write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 return -ENOMEM;
1690 }
1691 kfree(tty->write_buf);
1692 tty->write_cnt = chunk;
1693 tty->write_buf = buf;
1694 }
1695
1696 /* Do the write .. */
1697 for (;;) {
1698 size_t size = count;
1699 if (size > chunk)
1700 size = chunk;
1701 ret = -EFAULT;
1702 if (copy_from_user(tty->write_buf, buf, size))
1703 break;
1704 lock_kernel();
1705 ret = write(tty, file, tty->write_buf, size);
1706 unlock_kernel();
1707 if (ret <= 0)
1708 break;
1709 written += ret;
1710 buf += ret;
1711 count -= ret;
1712 if (!count)
1713 break;
1714 ret = -ERESTARTSYS;
1715 if (signal_pending(current))
1716 break;
1717 cond_resched();
1718 }
1719 if (written) {
1720 struct inode *inode = file->f_dentry->d_inode;
1721 inode->i_mtime = current_fs_time(inode->i_sb);
1722 ret = written;
1723 }
Ingo Molnar70522e12006-03-23 03:00:31 -08001724 mutex_unlock(&tty->atomic_write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 return ret;
1726}
1727
1728
Alan Coxaf9b8972006-08-27 01:24:01 -07001729/**
1730 * tty_write - write method for tty device file
1731 * @file: tty file pointer
1732 * @buf: user data to write
1733 * @count: bytes to write
1734 * @ppos: unused
1735 *
1736 * Write data to a tty device via the line discipline.
1737 *
1738 * Locking:
1739 * Locks the line discipline as required
1740 * Writes to the tty driver are serialized by the atomic_write_lock
1741 * and are then processed in chunks to the device. The line discipline
1742 * write method will not be involked in parallel for each device
1743 * The line discipline write method is called under the big
1744 * kernel lock for historical reasons. New code should not rely on this.
1745 */
1746
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1748 loff_t *ppos)
1749{
1750 struct tty_struct * tty;
1751 struct inode *inode = file->f_dentry->d_inode;
1752 ssize_t ret;
1753 struct tty_ldisc *ld;
1754
1755 tty = (struct tty_struct *)file->private_data;
1756 if (tty_paranoia_check(tty, inode, "tty_write"))
1757 return -EIO;
1758 if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1759 return -EIO;
1760
1761 ld = tty_ldisc_ref_wait(tty);
1762 if (!ld->write)
1763 ret = -EIO;
1764 else
1765 ret = do_tty_write(ld->write, tty, file, buf, count);
1766 tty_ldisc_deref(ld);
1767 return ret;
1768}
1769
1770ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1771 loff_t *ppos)
1772{
1773 struct file *p = NULL;
1774
1775 spin_lock(&redirect_lock);
1776 if (redirect) {
1777 get_file(redirect);
1778 p = redirect;
1779 }
1780 spin_unlock(&redirect_lock);
1781
1782 if (p) {
1783 ssize_t res;
1784 res = vfs_write(p, buf, count, &p->f_pos);
1785 fput(p);
1786 return res;
1787 }
1788
1789 return tty_write(file, buf, count, ppos);
1790}
1791
1792static char ptychar[] = "pqrstuvwxyzabcde";
1793
Alan Coxaf9b8972006-08-27 01:24:01 -07001794/**
1795 * pty_line_name - generate name for a pty
1796 * @driver: the tty driver in use
1797 * @index: the minor number
1798 * @p: output buffer of at least 6 bytes
1799 *
1800 * Generate a name from a driver reference and write it to the output
1801 * buffer.
1802 *
1803 * Locking: None
1804 */
1805static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806{
1807 int i = index + driver->name_base;
1808 /* ->name is initialized to "ttyp", but "tty" is expected */
1809 sprintf(p, "%s%c%x",
1810 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1811 ptychar[i >> 4 & 0xf], i & 0xf);
1812}
1813
Alan Coxaf9b8972006-08-27 01:24:01 -07001814/**
1815 * pty_line_name - generate name for a tty
1816 * @driver: the tty driver in use
1817 * @index: the minor number
1818 * @p: output buffer of at least 7 bytes
1819 *
1820 * Generate a name from a driver reference and write it to the output
1821 * buffer.
1822 *
1823 * Locking: None
1824 */
1825static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826{
1827 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1828}
1829
Alan Coxaf9b8972006-08-27 01:24:01 -07001830/**
1831 * init_dev - initialise a tty device
1832 * @driver: tty driver we are opening a device on
1833 * @idx: device index
1834 * @tty: returned tty structure
1835 *
1836 * Prepare a tty device. This may not be a "new" clean device but
1837 * could also be an active device. The pty drivers require special
1838 * handling because of this.
1839 *
1840 * Locking:
1841 * The function is called under the tty_mutex, which
1842 * protects us from the tty struct or driver itself going away.
1843 *
1844 * On exit the tty device has the line discipline attached and
1845 * a reference count of 1. If a pair was created for pty/tty use
1846 * and the other was a pty master then it too has a reference count of 1.
1847 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001849 * failed open. The new code protects the open with a mutex, so it's
1850 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 * relaxed for the (most common) case of reopening a tty.
1852 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001853
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854static int init_dev(struct tty_driver *driver, int idx,
1855 struct tty_struct **ret_tty)
1856{
1857 struct tty_struct *tty, *o_tty;
1858 struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1859 struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
Alan Coxaf9b8972006-08-27 01:24:01 -07001860 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862 /* check whether we're reopening an existing tty */
1863 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1864 tty = devpts_get_tty(idx);
1865 if (tty && driver->subtype == PTY_TYPE_MASTER)
1866 tty = tty->link;
1867 } else {
1868 tty = driver->ttys[idx];
1869 }
1870 if (tty) goto fast_track;
1871
1872 /*
1873 * First time open is complex, especially for PTY devices.
1874 * This code guarantees that either everything succeeds and the
1875 * TTY is ready for operation, or else the table slots are vacated
1876 * and the allocated memory released. (Except that the termios
1877 * and locked termios may be retained.)
1878 */
1879
1880 if (!try_module_get(driver->owner)) {
1881 retval = -ENODEV;
1882 goto end_init;
1883 }
1884
1885 o_tty = NULL;
1886 tp = o_tp = NULL;
1887 ltp = o_ltp = NULL;
1888
1889 tty = alloc_tty_struct();
1890 if(!tty)
1891 goto fail_no_mem;
1892 initialize_tty_struct(tty);
1893 tty->driver = driver;
1894 tty->index = idx;
1895 tty_line_name(driver, idx, tty->name);
1896
1897 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1898 tp_loc = &tty->termios;
1899 ltp_loc = &tty->termios_locked;
1900 } else {
1901 tp_loc = &driver->termios[idx];
1902 ltp_loc = &driver->termios_locked[idx];
1903 }
1904
1905 if (!*tp_loc) {
1906 tp = (struct termios *) kmalloc(sizeof(struct termios),
1907 GFP_KERNEL);
1908 if (!tp)
1909 goto free_mem_out;
1910 *tp = driver->init_termios;
1911 }
1912
1913 if (!*ltp_loc) {
1914 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1915 GFP_KERNEL);
1916 if (!ltp)
1917 goto free_mem_out;
1918 memset(ltp, 0, sizeof(struct termios));
1919 }
1920
1921 if (driver->type == TTY_DRIVER_TYPE_PTY) {
1922 o_tty = alloc_tty_struct();
1923 if (!o_tty)
1924 goto free_mem_out;
1925 initialize_tty_struct(o_tty);
1926 o_tty->driver = driver->other;
1927 o_tty->index = idx;
1928 tty_line_name(driver->other, idx, o_tty->name);
1929
1930 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1931 o_tp_loc = &o_tty->termios;
1932 o_ltp_loc = &o_tty->termios_locked;
1933 } else {
1934 o_tp_loc = &driver->other->termios[idx];
1935 o_ltp_loc = &driver->other->termios_locked[idx];
1936 }
1937
1938 if (!*o_tp_loc) {
1939 o_tp = (struct termios *)
1940 kmalloc(sizeof(struct termios), GFP_KERNEL);
1941 if (!o_tp)
1942 goto free_mem_out;
1943 *o_tp = driver->other->init_termios;
1944 }
1945
1946 if (!*o_ltp_loc) {
1947 o_ltp = (struct termios *)
1948 kmalloc(sizeof(struct termios), GFP_KERNEL);
1949 if (!o_ltp)
1950 goto free_mem_out;
1951 memset(o_ltp, 0, sizeof(struct termios));
1952 }
1953
1954 /*
1955 * Everything allocated ... set up the o_tty structure.
1956 */
1957 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1958 driver->other->ttys[idx] = o_tty;
1959 }
1960 if (!*o_tp_loc)
1961 *o_tp_loc = o_tp;
1962 if (!*o_ltp_loc)
1963 *o_ltp_loc = o_ltp;
1964 o_tty->termios = *o_tp_loc;
1965 o_tty->termios_locked = *o_ltp_loc;
1966 driver->other->refcount++;
1967 if (driver->subtype == PTY_TYPE_MASTER)
1968 o_tty->count++;
1969
1970 /* Establish the links in both directions */
1971 tty->link = o_tty;
1972 o_tty->link = tty;
1973 }
1974
1975 /*
1976 * All structures have been allocated, so now we install them.
1977 * Failures after this point use release_mem to clean up, so
1978 * there's no need to null out the local pointers.
1979 */
1980 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1981 driver->ttys[idx] = tty;
1982 }
1983
1984 if (!*tp_loc)
1985 *tp_loc = tp;
1986 if (!*ltp_loc)
1987 *ltp_loc = ltp;
1988 tty->termios = *tp_loc;
1989 tty->termios_locked = *ltp_loc;
1990 driver->refcount++;
1991 tty->count++;
1992
1993 /*
1994 * Structures all installed ... call the ldisc open routines.
1995 * If we fail here just call release_mem to clean up. No need
1996 * to decrement the use counts, as release_mem doesn't care.
1997 */
1998
1999 if (tty->ldisc.open) {
2000 retval = (tty->ldisc.open)(tty);
2001 if (retval)
2002 goto release_mem_out;
2003 }
2004 if (o_tty && o_tty->ldisc.open) {
2005 retval = (o_tty->ldisc.open)(o_tty);
2006 if (retval) {
2007 if (tty->ldisc.close)
2008 (tty->ldisc.close)(tty);
2009 goto release_mem_out;
2010 }
2011 tty_ldisc_enable(o_tty);
2012 }
2013 tty_ldisc_enable(tty);
2014 goto success;
2015
2016 /*
2017 * This fast open can be used if the tty is already open.
2018 * No memory is allocated, and the only failures are from
2019 * attempting to open a closing tty or attempting multiple
2020 * opens on a pty master.
2021 */
2022fast_track:
2023 if (test_bit(TTY_CLOSING, &tty->flags)) {
2024 retval = -EIO;
2025 goto end_init;
2026 }
2027 if (driver->type == TTY_DRIVER_TYPE_PTY &&
2028 driver->subtype == PTY_TYPE_MASTER) {
2029 /*
2030 * special case for PTY masters: only one open permitted,
2031 * and the slave side open count is incremented as well.
2032 */
2033 if (tty->count) {
2034 retval = -EIO;
2035 goto end_init;
2036 }
2037 tty->link->count++;
2038 }
2039 tty->count++;
2040 tty->driver = driver; /* N.B. why do this every time?? */
2041
2042 /* FIXME */
2043 if(!test_bit(TTY_LDISC, &tty->flags))
2044 printk(KERN_ERR "init_dev but no ldisc\n");
2045success:
2046 *ret_tty = tty;
2047
Ingo Molnar70522e12006-03-23 03:00:31 -08002048 /* All paths come through here to release the mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049end_init:
2050 return retval;
2051
2052 /* Release locally allocated memory ... nothing placed in slots */
2053free_mem_out:
Jesper Juhl735d5662005-11-07 01:01:29 -08002054 kfree(o_tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 if (o_tty)
2056 free_tty_struct(o_tty);
Jesper Juhl735d5662005-11-07 01:01:29 -08002057 kfree(ltp);
2058 kfree(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 free_tty_struct(tty);
2060
2061fail_no_mem:
2062 module_put(driver->owner);
2063 retval = -ENOMEM;
2064 goto end_init;
2065
2066 /* call the tty release_mem routine to clean out this slot */
2067release_mem_out:
Akinobu Mita40509142006-09-29 02:01:27 -07002068 if (printk_ratelimit())
2069 printk(KERN_INFO "init_dev: ldisc open failed, "
2070 "clearing slot %d\n", idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 release_mem(tty, idx);
2072 goto end_init;
2073}
2074
Alan Coxaf9b8972006-08-27 01:24:01 -07002075/**
2076 * release_mem - release tty structure memory
2077 *
2078 * Releases memory associated with a tty structure, and clears out the
2079 * driver table slots. This function is called when a device is no longer
2080 * in use. It also gets called when setup of a device fails.
2081 *
2082 * Locking:
2083 * tty_mutex - sometimes only
2084 * takes the file list lock internally when working on the list
2085 * of ttys that the driver keeps.
2086 * FIXME: should we require tty_mutex is held here ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002088
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089static void release_mem(struct tty_struct *tty, int idx)
2090{
2091 struct tty_struct *o_tty;
2092 struct termios *tp;
2093 int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2094
2095 if ((o_tty = tty->link) != NULL) {
2096 if (!devpts)
2097 o_tty->driver->ttys[idx] = NULL;
2098 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2099 tp = o_tty->termios;
2100 if (!devpts)
2101 o_tty->driver->termios[idx] = NULL;
2102 kfree(tp);
2103
2104 tp = o_tty->termios_locked;
2105 if (!devpts)
2106 o_tty->driver->termios_locked[idx] = NULL;
2107 kfree(tp);
2108 }
2109 o_tty->magic = 0;
2110 o_tty->driver->refcount--;
2111 file_list_lock();
2112 list_del_init(&o_tty->tty_files);
2113 file_list_unlock();
2114 free_tty_struct(o_tty);
2115 }
2116
2117 if (!devpts)
2118 tty->driver->ttys[idx] = NULL;
2119 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2120 tp = tty->termios;
2121 if (!devpts)
2122 tty->driver->termios[idx] = NULL;
2123 kfree(tp);
2124
2125 tp = tty->termios_locked;
2126 if (!devpts)
2127 tty->driver->termios_locked[idx] = NULL;
2128 kfree(tp);
2129 }
2130
2131 tty->magic = 0;
2132 tty->driver->refcount--;
2133 file_list_lock();
2134 list_del_init(&tty->tty_files);
2135 file_list_unlock();
2136 module_put(tty->driver->owner);
2137 free_tty_struct(tty);
2138}
2139
2140/*
2141 * Even releasing the tty structures is a tricky business.. We have
2142 * to be very careful that the structures are all released at the
2143 * same time, as interrupts might otherwise get the wrong pointers.
2144 *
2145 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2146 * lead to double frees or releasing memory still in use.
2147 */
2148static void release_dev(struct file * filp)
2149{
2150 struct tty_struct *tty, *o_tty;
2151 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07002152 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 int idx;
2154 char buf[64];
2155 unsigned long flags;
2156
2157 tty = (struct tty_struct *)filp->private_data;
2158 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
2159 return;
2160
2161 check_tty_count(tty, "release_dev");
2162
2163 tty_fasync(-1, filp, 0);
2164
2165 idx = tty->index;
2166 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2167 tty->driver->subtype == PTY_TYPE_MASTER);
2168 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 o_tty = tty->link;
2170
2171#ifdef TTY_PARANOIA_CHECK
2172 if (idx < 0 || idx >= tty->driver->num) {
2173 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2174 "free (%s)\n", tty->name);
2175 return;
2176 }
2177 if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2178 if (tty != tty->driver->ttys[idx]) {
2179 printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2180 "for (%s)\n", idx, tty->name);
2181 return;
2182 }
2183 if (tty->termios != tty->driver->termios[idx]) {
2184 printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2185 "for (%s)\n",
2186 idx, tty->name);
2187 return;
2188 }
2189 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2190 printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2191 "termios_locked for (%s)\n",
2192 idx, tty->name);
2193 return;
2194 }
2195 }
2196#endif
2197
2198#ifdef TTY_DEBUG_HANGUP
2199 printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2200 tty_name(tty, buf), tty->count);
2201#endif
2202
2203#ifdef TTY_PARANOIA_CHECK
2204 if (tty->driver->other &&
2205 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2206 if (o_tty != tty->driver->other->ttys[idx]) {
2207 printk(KERN_DEBUG "release_dev: other->table[%d] "
2208 "not o_tty for (%s)\n",
2209 idx, tty->name);
2210 return;
2211 }
2212 if (o_tty->termios != tty->driver->other->termios[idx]) {
2213 printk(KERN_DEBUG "release_dev: other->termios[%d] "
2214 "not o_termios for (%s)\n",
2215 idx, tty->name);
2216 return;
2217 }
2218 if (o_tty->termios_locked !=
2219 tty->driver->other->termios_locked[idx]) {
2220 printk(KERN_DEBUG "release_dev: other->termios_locked["
2221 "%d] not o_termios_locked for (%s)\n",
2222 idx, tty->name);
2223 return;
2224 }
2225 if (o_tty->link != tty) {
2226 printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2227 return;
2228 }
2229 }
2230#endif
2231 if (tty->driver->close)
2232 tty->driver->close(tty, filp);
2233
2234 /*
2235 * Sanity check: if tty->count is going to zero, there shouldn't be
2236 * any waiters on tty->read_wait or tty->write_wait. We test the
2237 * wait queues and kick everyone out _before_ actually starting to
2238 * close. This ensures that we won't block while releasing the tty
2239 * structure.
2240 *
2241 * The test for the o_tty closing is necessary, since the master and
2242 * slave sides may close in any order. If the slave side closes out
2243 * first, its count will be one, since the master side holds an open.
2244 * Thus this test wouldn't be triggered at the time the slave closes,
2245 * so we do it now.
2246 *
2247 * Note that it's possible for the tty to be opened again while we're
2248 * flushing out waiters. By recalculating the closing flags before
2249 * each iteration we avoid any problems.
2250 */
2251 while (1) {
2252 /* Guard against races with tty->count changes elsewhere and
2253 opens on /dev/tty */
2254
Ingo Molnar70522e12006-03-23 03:00:31 -08002255 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 tty_closing = tty->count <= 1;
2257 o_tty_closing = o_tty &&
2258 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 do_sleep = 0;
2260
2261 if (tty_closing) {
2262 if (waitqueue_active(&tty->read_wait)) {
2263 wake_up(&tty->read_wait);
2264 do_sleep++;
2265 }
2266 if (waitqueue_active(&tty->write_wait)) {
2267 wake_up(&tty->write_wait);
2268 do_sleep++;
2269 }
2270 }
2271 if (o_tty_closing) {
2272 if (waitqueue_active(&o_tty->read_wait)) {
2273 wake_up(&o_tty->read_wait);
2274 do_sleep++;
2275 }
2276 if (waitqueue_active(&o_tty->write_wait)) {
2277 wake_up(&o_tty->write_wait);
2278 do_sleep++;
2279 }
2280 }
2281 if (!do_sleep)
2282 break;
2283
2284 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2285 "active!\n", tty_name(tty, buf));
Ingo Molnar70522e12006-03-23 03:00:31 -08002286 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 schedule();
2288 }
2289
2290 /*
2291 * The closing flags are now consistent with the open counts on
2292 * both sides, and we've completed the last operation that could
2293 * block, so it's safe to proceed with closing.
2294 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 if (pty_master) {
2296 if (--o_tty->count < 0) {
2297 printk(KERN_WARNING "release_dev: bad pty slave count "
2298 "(%d) for %s\n",
2299 o_tty->count, tty_name(o_tty, buf));
2300 o_tty->count = 0;
2301 }
2302 }
2303 if (--tty->count < 0) {
2304 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2305 tty->count, tty_name(tty, buf));
2306 tty->count = 0;
2307 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308
2309 /*
2310 * We've decremented tty->count, so we need to remove this file
2311 * descriptor off the tty->tty_files list; this serves two
2312 * purposes:
2313 * - check_tty_count sees the correct number of file descriptors
2314 * associated with this tty.
2315 * - do_tty_hangup no longer sees this file descriptor as
2316 * something that needs to be handled for hangups.
2317 */
2318 file_kill(filp);
2319 filp->private_data = NULL;
2320
2321 /*
2322 * Perform some housekeeping before deciding whether to return.
2323 *
2324 * Set the TTY_CLOSING flag if this was the last open. In the
2325 * case of a pty we may have to wait around for the other side
2326 * to close, and TTY_CLOSING makes sure we can't be reopened.
2327 */
2328 if(tty_closing)
2329 set_bit(TTY_CLOSING, &tty->flags);
2330 if(o_tty_closing)
2331 set_bit(TTY_CLOSING, &o_tty->flags);
2332
2333 /*
2334 * If _either_ side is closing, make sure there aren't any
2335 * processes that still think tty or o_tty is their controlling
2336 * tty.
2337 */
2338 if (tty_closing || o_tty_closing) {
2339 struct task_struct *p;
2340
2341 read_lock(&tasklist_lock);
2342 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2343 p->signal->tty = NULL;
2344 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2345 if (o_tty)
2346 do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
2347 p->signal->tty = NULL;
2348 } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
2349 read_unlock(&tasklist_lock);
2350 }
2351
Ingo Molnar70522e12006-03-23 03:00:31 -08002352 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08002353
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 /* check whether both sides are closing ... */
2355 if (!tty_closing || (o_tty && !o_tty_closing))
2356 return;
2357
2358#ifdef TTY_DEBUG_HANGUP
2359 printk(KERN_DEBUG "freeing tty structure...");
2360#endif
2361 /*
2362 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
2363 * kill any delayed work. As this is the final close it does not
2364 * race with the set_ldisc code path.
2365 */
2366 clear_bit(TTY_LDISC, &tty->flags);
Alan Cox33f0f882006-01-09 20:54:13 -08002367 cancel_delayed_work(&tty->buf.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368
2369 /*
Alan Cox33f0f882006-01-09 20:54:13 -08002370 * Wait for ->hangup_work and ->buf.work handlers to terminate
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 */
2372
2373 flush_scheduled_work();
2374
2375 /*
2376 * Wait for any short term users (we know they are just driver
2377 * side waiters as the file is closing so user count on the file
2378 * side is zero.
2379 */
2380 spin_lock_irqsave(&tty_ldisc_lock, flags);
2381 while(tty->ldisc.refcount)
2382 {
2383 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2384 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2385 spin_lock_irqsave(&tty_ldisc_lock, flags);
2386 }
2387 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2388 /*
2389 * Shutdown the current line discipline, and reset it to N_TTY.
2390 * N.B. why reset ldisc when we're releasing the memory??
2391 *
2392 * FIXME: this MUST get fixed for the new reflocking
2393 */
2394 if (tty->ldisc.close)
2395 (tty->ldisc.close)(tty);
2396 tty_ldisc_put(tty->ldisc.num);
2397
2398 /*
2399 * Switch the line discipline back
2400 */
2401 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2402 tty_set_termios_ldisc(tty,N_TTY);
2403 if (o_tty) {
2404 /* FIXME: could o_tty be in setldisc here ? */
2405 clear_bit(TTY_LDISC, &o_tty->flags);
2406 if (o_tty->ldisc.close)
2407 (o_tty->ldisc.close)(o_tty);
2408 tty_ldisc_put(o_tty->ldisc.num);
2409 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2410 tty_set_termios_ldisc(o_tty,N_TTY);
2411 }
2412 /*
2413 * The release_mem function takes care of the details of clearing
2414 * the slots and preserving the termios structure.
2415 */
2416 release_mem(tty, idx);
2417
2418#ifdef CONFIG_UNIX98_PTYS
2419 /* Make this pty number available for reallocation */
2420 if (devpts) {
2421 down(&allocated_ptys_lock);
2422 idr_remove(&allocated_ptys, idx);
2423 up(&allocated_ptys_lock);
2424 }
2425#endif
2426
2427}
2428
Alan Coxaf9b8972006-08-27 01:24:01 -07002429/**
2430 * tty_open - open a tty device
2431 * @inode: inode of device file
2432 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002434 * tty_open and tty_release keep up the tty count that contains the
2435 * number of opens done on a tty. We cannot use the inode-count, as
2436 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002438 * Open-counting is needed for pty masters, as well as for keeping
2439 * track of serial lines: DTR is dropped when the last close happens.
2440 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2441 *
2442 * The termios state of a pty is reset on first open so that
2443 * settings don't persist across reuse.
2444 *
2445 * Locking: tty_mutex protects current->signal->tty, get_tty_driver and
2446 * init_dev work. tty->count should protect the rest.
2447 * task_lock is held to update task details for sessions
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002449
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450static int tty_open(struct inode * inode, struct file * filp)
2451{
2452 struct tty_struct *tty;
2453 int noctty, retval;
2454 struct tty_driver *driver;
2455 int index;
2456 dev_t device = inode->i_rdev;
2457 unsigned short saved_flags = filp->f_flags;
2458
2459 nonseekable_open(inode, filp);
2460
2461retry_open:
2462 noctty = filp->f_flags & O_NOCTTY;
2463 index = -1;
2464 retval = 0;
2465
Ingo Molnar70522e12006-03-23 03:00:31 -08002466 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467
2468 if (device == MKDEV(TTYAUX_MAJOR,0)) {
2469 if (!current->signal->tty) {
Ingo Molnar70522e12006-03-23 03:00:31 -08002470 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 return -ENXIO;
2472 }
2473 driver = current->signal->tty->driver;
2474 index = current->signal->tty->index;
2475 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2476 /* noctty = 1; */
2477 goto got_driver;
2478 }
2479#ifdef CONFIG_VT
2480 if (device == MKDEV(TTY_MAJOR,0)) {
2481 extern struct tty_driver *console_driver;
2482 driver = console_driver;
2483 index = fg_console;
2484 noctty = 1;
2485 goto got_driver;
2486 }
2487#endif
2488 if (device == MKDEV(TTYAUX_MAJOR,1)) {
2489 driver = console_device(&index);
2490 if (driver) {
2491 /* Don't let /dev/console block */
2492 filp->f_flags |= O_NONBLOCK;
2493 noctty = 1;
2494 goto got_driver;
2495 }
Ingo Molnar70522e12006-03-23 03:00:31 -08002496 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 return -ENODEV;
2498 }
2499
2500 driver = get_tty_driver(device, &index);
2501 if (!driver) {
Ingo Molnar70522e12006-03-23 03:00:31 -08002502 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 return -ENODEV;
2504 }
2505got_driver:
2506 retval = init_dev(driver, index, &tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08002507 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508 if (retval)
2509 return retval;
2510
2511 filp->private_data = tty;
2512 file_move(filp, &tty->tty_files);
2513 check_tty_count(tty, "tty_open");
2514 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2515 tty->driver->subtype == PTY_TYPE_MASTER)
2516 noctty = 1;
2517#ifdef TTY_DEBUG_HANGUP
2518 printk(KERN_DEBUG "opening %s...", tty->name);
2519#endif
2520 if (!retval) {
2521 if (tty->driver->open)
2522 retval = tty->driver->open(tty, filp);
2523 else
2524 retval = -ENODEV;
2525 }
2526 filp->f_flags = saved_flags;
2527
2528 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2529 retval = -EBUSY;
2530
2531 if (retval) {
2532#ifdef TTY_DEBUG_HANGUP
2533 printk(KERN_DEBUG "error %d in opening %s...", retval,
2534 tty->name);
2535#endif
2536 release_dev(filp);
2537 if (retval != -ERESTARTSYS)
2538 return retval;
2539 if (signal_pending(current))
2540 return retval;
2541 schedule();
2542 /*
2543 * Need to reset f_op in case a hangup happened.
2544 */
2545 if (filp->f_op == &hung_up_tty_fops)
2546 filp->f_op = &tty_fops;
2547 goto retry_open;
2548 }
2549 if (!noctty &&
2550 current->signal->leader &&
2551 !current->signal->tty &&
2552 tty->session == 0) {
2553 task_lock(current);
2554 current->signal->tty = tty;
2555 task_unlock(current);
2556 current->signal->tty_old_pgrp = 0;
2557 tty->session = current->signal->session;
2558 tty->pgrp = process_group(current);
2559 }
2560 return 0;
2561}
2562
2563#ifdef CONFIG_UNIX98_PTYS
Alan Coxaf9b8972006-08-27 01:24:01 -07002564/**
2565 * ptmx_open - open a unix 98 pty master
2566 * @inode: inode of device file
2567 * @filp: file pointer to tty
2568 *
2569 * Allocate a unix98 pty master device from the ptmx driver.
2570 *
2571 * Locking: tty_mutex protects theinit_dev work. tty->count should
2572 protect the rest.
2573 * allocated_ptys_lock handles the list of free pty numbers
2574 */
2575
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576static int ptmx_open(struct inode * inode, struct file * filp)
2577{
2578 struct tty_struct *tty;
2579 int retval;
2580 int index;
2581 int idr_ret;
2582
2583 nonseekable_open(inode, filp);
2584
2585 /* find a device that is not in use. */
2586 down(&allocated_ptys_lock);
2587 if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2588 up(&allocated_ptys_lock);
2589 return -ENOMEM;
2590 }
2591 idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2592 if (idr_ret < 0) {
2593 up(&allocated_ptys_lock);
2594 if (idr_ret == -EAGAIN)
2595 return -ENOMEM;
2596 return -EIO;
2597 }
2598 if (index >= pty_limit) {
2599 idr_remove(&allocated_ptys, index);
2600 up(&allocated_ptys_lock);
2601 return -EIO;
2602 }
2603 up(&allocated_ptys_lock);
2604
Ingo Molnar70522e12006-03-23 03:00:31 -08002605 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 retval = init_dev(ptm_driver, index, &tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08002607 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608
2609 if (retval)
2610 goto out;
2611
2612 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2613 filp->private_data = tty;
2614 file_move(filp, &tty->tty_files);
2615
2616 retval = -ENOMEM;
2617 if (devpts_pty_new(tty->link))
2618 goto out1;
2619
2620 check_tty_count(tty, "tty_open");
2621 retval = ptm_driver->open(tty, filp);
2622 if (!retval)
2623 return 0;
2624out1:
2625 release_dev(filp);
Paul Fulghum9453a5a2006-04-10 22:54:18 -07002626 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627out:
2628 down(&allocated_ptys_lock);
2629 idr_remove(&allocated_ptys, index);
2630 up(&allocated_ptys_lock);
2631 return retval;
2632}
2633#endif
2634
Alan Coxaf9b8972006-08-27 01:24:01 -07002635/**
2636 * tty_release - vfs callback for close
2637 * @inode: inode of tty
2638 * @filp: file pointer for handle to tty
2639 *
2640 * Called the last time each file handle is closed that references
2641 * this tty. There may however be several such references.
2642 *
2643 * Locking:
2644 * Takes bkl. See release_dev
2645 */
2646
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647static int tty_release(struct inode * inode, struct file * filp)
2648{
2649 lock_kernel();
2650 release_dev(filp);
2651 unlock_kernel();
2652 return 0;
2653}
2654
Alan Coxaf9b8972006-08-27 01:24:01 -07002655/**
2656 * tty_poll - check tty status
2657 * @filp: file being polled
2658 * @wait: poll wait structures to update
2659 *
2660 * Call the line discipline polling method to obtain the poll
2661 * status of the device.
2662 *
2663 * Locking: locks called line discipline but ldisc poll method
2664 * may be re-entered freely by other callers.
2665 */
2666
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667static unsigned int tty_poll(struct file * filp, poll_table * wait)
2668{
2669 struct tty_struct * tty;
2670 struct tty_ldisc *ld;
2671 int ret = 0;
2672
2673 tty = (struct tty_struct *)filp->private_data;
2674 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
2675 return 0;
2676
2677 ld = tty_ldisc_ref_wait(tty);
2678 if (ld->poll)
2679 ret = (ld->poll)(tty, filp, wait);
2680 tty_ldisc_deref(ld);
2681 return ret;
2682}
2683
2684static int tty_fasync(int fd, struct file * filp, int on)
2685{
2686 struct tty_struct * tty;
2687 int retval;
2688
2689 tty = (struct tty_struct *)filp->private_data;
2690 if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2691 return 0;
2692
2693 retval = fasync_helper(fd, filp, on, &tty->fasync);
2694 if (retval <= 0)
2695 return retval;
2696
2697 if (on) {
2698 if (!waitqueue_active(&tty->read_wait))
2699 tty->minimum_to_wake = 1;
2700 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2701 if (retval)
2702 return retval;
2703 } else {
2704 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2705 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2706 }
2707 return 0;
2708}
2709
Alan Coxaf9b8972006-08-27 01:24:01 -07002710/**
2711 * tiocsti - fake input character
2712 * @tty: tty to fake input into
2713 * @p: pointer to character
2714 *
2715 * Fake input to a tty device. Does the neccessary locking and
2716 * input management.
2717 *
2718 * FIXME: does not honour flow control ??
2719 *
2720 * Locking:
2721 * Called functions take tty_ldisc_lock
2722 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002723 *
2724 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002725 */
2726
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727static int tiocsti(struct tty_struct *tty, char __user *p)
2728{
2729 char ch, mbz = 0;
2730 struct tty_ldisc *ld;
2731
2732 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2733 return -EPERM;
2734 if (get_user(ch, p))
2735 return -EFAULT;
2736 ld = tty_ldisc_ref_wait(tty);
2737 ld->receive_buf(tty, &ch, &mbz, 1);
2738 tty_ldisc_deref(ld);
2739 return 0;
2740}
2741
Alan Coxaf9b8972006-08-27 01:24:01 -07002742/**
2743 * tiocgwinsz - implement window query ioctl
2744 * @tty; tty
2745 * @arg: user buffer for result
2746 *
Alan Cox808a0d32006-09-29 02:00:40 -07002747 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002748 *
Alan Cox808a0d32006-09-29 02:00:40 -07002749 * Locking: tty->termios_sem is taken to ensure the winsize data
2750 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002751 */
2752
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2754{
Alan Cox808a0d32006-09-29 02:00:40 -07002755 int err;
2756
Arjan van de Ven5785c952006-09-29 02:00:43 -07002757 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002758 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002759 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002760
2761 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762}
2763
Alan Coxaf9b8972006-08-27 01:24:01 -07002764/**
2765 * tiocswinsz - implement window size set ioctl
2766 * @tty; tty
2767 * @arg: user buffer for result
2768 *
2769 * Copies the user idea of the window size to the kernel. Traditionally
2770 * this is just advisory information but for the Linux console it
2771 * actually has driver level meaning and triggers a VC resize.
2772 *
2773 * Locking:
Alan Coxca9bda02006-09-29 02:00:03 -07002774 * Called function use the console_sem is used to ensure we do
2775 * not try and resize the console twice at once.
2776 * The tty->termios_sem is used to ensure we don't double
2777 * resize and get confused. Lock order - tty->termios.sem before
2778 * console sem
Alan Coxaf9b8972006-08-27 01:24:01 -07002779 */
2780
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2782 struct winsize __user * arg)
2783{
2784 struct winsize tmp_ws;
2785
2786 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2787 return -EFAULT;
Alan Coxca9bda02006-09-29 02:00:03 -07002788
Arjan van de Ven5785c952006-09-29 02:00:43 -07002789 mutex_lock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
Alan Coxca9bda02006-09-29 02:00:03 -07002791 goto done;
2792
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793#ifdef CONFIG_VT
2794 if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
Arjan van de Ven5785c952006-09-29 02:00:43 -07002795 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2796 tmp_ws.ws_row)) {
2797 mutex_unlock(&tty->termios_mutex);
Alan Coxca9bda02006-09-29 02:00:03 -07002798 return -ENXIO;
2799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 }
2801#endif
2802 if (tty->pgrp > 0)
2803 kill_pg(tty->pgrp, SIGWINCH, 1);
2804 if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2805 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2806 tty->winsize = tmp_ws;
2807 real_tty->winsize = tmp_ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002808done:
Arjan van de Ven5785c952006-09-29 02:00:43 -07002809 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 return 0;
2811}
2812
Alan Coxaf9b8972006-08-27 01:24:01 -07002813/**
2814 * tioccons - allow admin to move logical console
2815 * @file: the file to become console
2816 *
2817 * Allow the adminstrator to move the redirected console device
2818 *
2819 * Locking: uses redirect_lock to guard the redirect information
2820 */
2821
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822static int tioccons(struct file *file)
2823{
2824 if (!capable(CAP_SYS_ADMIN))
2825 return -EPERM;
2826 if (file->f_op->write == redirected_tty_write) {
2827 struct file *f;
2828 spin_lock(&redirect_lock);
2829 f = redirect;
2830 redirect = NULL;
2831 spin_unlock(&redirect_lock);
2832 if (f)
2833 fput(f);
2834 return 0;
2835 }
2836 spin_lock(&redirect_lock);
2837 if (redirect) {
2838 spin_unlock(&redirect_lock);
2839 return -EBUSY;
2840 }
2841 get_file(file);
2842 redirect = file;
2843 spin_unlock(&redirect_lock);
2844 return 0;
2845}
2846
Alan Coxaf9b8972006-08-27 01:24:01 -07002847/**
2848 * fionbio - non blocking ioctl
2849 * @file: file to set blocking value
2850 * @p: user parameter
2851 *
2852 * Historical tty interfaces had a blocking control ioctl before
2853 * the generic functionality existed. This piece of history is preserved
2854 * in the expected tty API of posix OS's.
2855 *
2856 * Locking: none, the open fle handle ensures it won't go away.
2857 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858
2859static int fionbio(struct file *file, int __user *p)
2860{
2861 int nonblock;
2862
2863 if (get_user(nonblock, p))
2864 return -EFAULT;
2865
2866 if (nonblock)
2867 file->f_flags |= O_NONBLOCK;
2868 else
2869 file->f_flags &= ~O_NONBLOCK;
2870 return 0;
2871}
2872
Alan Coxaf9b8972006-08-27 01:24:01 -07002873/**
2874 * tiocsctty - set controlling tty
2875 * @tty: tty structure
2876 * @arg: user argument
2877 *
2878 * This ioctl is used to manage job control. It permits a session
2879 * leader to set this tty as the controlling tty for the session.
2880 *
2881 * Locking:
2882 * Takes tasklist lock internally to walk sessions
2883 * Takes task_lock() when updating signal->tty
Alan Cox28298232006-09-29 02:00:58 -07002884 * Takes tty_mutex() to protect tty instance
Alan Coxaf9b8972006-08-27 01:24:01 -07002885 *
2886 */
2887
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888static int tiocsctty(struct tty_struct *tty, int arg)
2889{
Ingo Molnar36c8b582006-07-03 00:25:41 -07002890 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891
2892 if (current->signal->leader &&
2893 (current->signal->session == tty->session))
2894 return 0;
2895 /*
2896 * The process must be a session leader and
2897 * not have a controlling tty already.
2898 */
2899 if (!current->signal->leader || current->signal->tty)
2900 return -EPERM;
2901 if (tty->session > 0) {
2902 /*
2903 * This tty is already the controlling
2904 * tty for another session group!
2905 */
2906 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2907 /*
2908 * Steal it away
2909 */
2910
2911 read_lock(&tasklist_lock);
2912 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2913 p->signal->tty = NULL;
2914 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2915 read_unlock(&tasklist_lock);
2916 } else
2917 return -EPERM;
2918 }
Alan Cox28298232006-09-29 02:00:58 -07002919 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 task_lock(current);
2921 current->signal->tty = tty;
2922 task_unlock(current);
Alan Cox28298232006-09-29 02:00:58 -07002923 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 current->signal->tty_old_pgrp = 0;
2925 tty->session = current->signal->session;
2926 tty->pgrp = process_group(current);
2927 return 0;
2928}
2929
Alan Coxaf9b8972006-08-27 01:24:01 -07002930/**
2931 * tiocgpgrp - get process group
2932 * @tty: tty passed by user
2933 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2934 * @p: returned pid
2935 *
2936 * Obtain the process group of the tty. If there is no process group
2937 * return an error.
2938 *
2939 * Locking: none. Reference to ->signal->tty is safe.
2940 */
2941
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2943{
2944 /*
2945 * (tty == real_tty) is a cheap way of
2946 * testing if the tty is NOT a master pty.
2947 */
2948 if (tty == real_tty && current->signal->tty != real_tty)
2949 return -ENOTTY;
2950 return put_user(real_tty->pgrp, p);
2951}
2952
Alan Coxaf9b8972006-08-27 01:24:01 -07002953/**
2954 * tiocspgrp - attempt to set process group
2955 * @tty: tty passed by user
2956 * @real_tty: tty side device matching tty passed by user
2957 * @p: pid pointer
2958 *
2959 * Set the process group of the tty to the session passed. Only
2960 * permitted where the tty session is our session.
2961 *
2962 * Locking: None
Alan Coxaf9b8972006-08-27 01:24:01 -07002963 */
2964
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2966{
2967 pid_t pgrp;
2968 int retval = tty_check_change(real_tty);
2969
2970 if (retval == -EIO)
2971 return -ENOTTY;
2972 if (retval)
2973 return retval;
2974 if (!current->signal->tty ||
2975 (current->signal->tty != real_tty) ||
2976 (real_tty->session != current->signal->session))
2977 return -ENOTTY;
2978 if (get_user(pgrp, p))
2979 return -EFAULT;
2980 if (pgrp < 0)
2981 return -EINVAL;
2982 if (session_of_pgrp(pgrp) != current->signal->session)
2983 return -EPERM;
2984 real_tty->pgrp = pgrp;
2985 return 0;
2986}
2987
Alan Coxaf9b8972006-08-27 01:24:01 -07002988/**
2989 * tiocgsid - get session id
2990 * @tty: tty passed by user
2991 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2992 * @p: pointer to returned session id
2993 *
2994 * Obtain the session id of the tty. If there is no session
2995 * return an error.
2996 *
2997 * Locking: none. Reference to ->signal->tty is safe.
2998 */
2999
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3001{
3002 /*
3003 * (tty == real_tty) is a cheap way of
3004 * testing if the tty is NOT a master pty.
3005 */
3006 if (tty == real_tty && current->signal->tty != real_tty)
3007 return -ENOTTY;
3008 if (real_tty->session <= 0)
3009 return -ENOTTY;
3010 return put_user(real_tty->session, p);
3011}
3012
Alan Coxaf9b8972006-08-27 01:24:01 -07003013/**
3014 * tiocsetd - set line discipline
3015 * @tty: tty device
3016 * @p: pointer to user data
3017 *
3018 * Set the line discipline according to user request.
3019 *
3020 * Locking: see tty_set_ldisc, this function is just a helper
3021 */
3022
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023static int tiocsetd(struct tty_struct *tty, int __user *p)
3024{
3025 int ldisc;
3026
3027 if (get_user(ldisc, p))
3028 return -EFAULT;
3029 return tty_set_ldisc(tty, ldisc);
3030}
3031
Alan Coxaf9b8972006-08-27 01:24:01 -07003032/**
3033 * send_break - performed time break
3034 * @tty: device to break on
3035 * @duration: timeout in mS
3036 *
3037 * Perform a timed break on hardware that lacks its own driver level
3038 * timed break functionality.
3039 *
3040 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07003041 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07003042 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003043 */
3044
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003045static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046{
Alan Cox28298232006-09-29 02:00:58 -07003047 if (mutex_lock_interruptible(&tty->atomic_write_lock))
3048 return -EINTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049 tty->driver->break_ctl(tty, -1);
3050 if (!signal_pending(current)) {
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003051 msleep_interruptible(duration);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 }
3053 tty->driver->break_ctl(tty, 0);
Alan Cox28298232006-09-29 02:00:58 -07003054 mutex_unlock(&tty->atomic_write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055 if (signal_pending(current))
3056 return -EINTR;
3057 return 0;
3058}
3059
Alan Coxaf9b8972006-08-27 01:24:01 -07003060/**
3061 * tiocmget - get modem status
3062 * @tty: tty device
3063 * @file: user file pointer
3064 * @p: pointer to result
3065 *
3066 * Obtain the modem status bits from the tty driver if the feature
3067 * is supported. Return -EINVAL if it is not available.
3068 *
3069 * Locking: none (up to the driver)
3070 */
3071
3072static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003073{
3074 int retval = -EINVAL;
3075
3076 if (tty->driver->tiocmget) {
3077 retval = tty->driver->tiocmget(tty, file);
3078
3079 if (retval >= 0)
3080 retval = put_user(retval, p);
3081 }
3082 return retval;
3083}
3084
Alan Coxaf9b8972006-08-27 01:24:01 -07003085/**
3086 * tiocmset - set modem status
3087 * @tty: tty device
3088 * @file: user file pointer
3089 * @cmd: command - clear bits, set bits or set all
3090 * @p: pointer to desired bits
3091 *
3092 * Set the modem status bits from the tty driver if the feature
3093 * is supported. Return -EINVAL if it is not available.
3094 *
3095 * Locking: none (up to the driver)
3096 */
3097
3098static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 unsigned __user *p)
3100{
3101 int retval = -EINVAL;
3102
3103 if (tty->driver->tiocmset) {
3104 unsigned int set, clear, val;
3105
3106 retval = get_user(val, p);
3107 if (retval)
3108 return retval;
3109
3110 set = clear = 0;
3111 switch (cmd) {
3112 case TIOCMBIS:
3113 set = val;
3114 break;
3115 case TIOCMBIC:
3116 clear = val;
3117 break;
3118 case TIOCMSET:
3119 set = val;
3120 clear = ~val;
3121 break;
3122 }
3123
3124 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3125 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3126
3127 retval = tty->driver->tiocmset(tty, file, set, clear);
3128 }
3129 return retval;
3130}
3131
3132/*
3133 * Split this up, as gcc can choke on it otherwise..
3134 */
3135int tty_ioctl(struct inode * inode, struct file * file,
3136 unsigned int cmd, unsigned long arg)
3137{
3138 struct tty_struct *tty, *real_tty;
3139 void __user *p = (void __user *)arg;
3140 int retval;
3141 struct tty_ldisc *ld;
3142
3143 tty = (struct tty_struct *)file->private_data;
3144 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3145 return -EINVAL;
3146
Alan Cox28298232006-09-29 02:00:58 -07003147 /* CHECKME: is this safe as one end closes ? */
3148
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149 real_tty = tty;
3150 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3151 tty->driver->subtype == PTY_TYPE_MASTER)
3152 real_tty = tty->link;
3153
3154 /*
3155 * Break handling by driver
3156 */
3157 if (!tty->driver->break_ctl) {
3158 switch(cmd) {
3159 case TIOCSBRK:
3160 case TIOCCBRK:
3161 if (tty->driver->ioctl)
3162 return tty->driver->ioctl(tty, file, cmd, arg);
3163 return -EINVAL;
3164
3165 /* These two ioctl's always return success; even if */
3166 /* the driver doesn't support them. */
3167 case TCSBRK:
3168 case TCSBRKP:
3169 if (!tty->driver->ioctl)
3170 return 0;
3171 retval = tty->driver->ioctl(tty, file, cmd, arg);
3172 if (retval == -ENOIOCTLCMD)
3173 retval = 0;
3174 return retval;
3175 }
3176 }
3177
3178 /*
3179 * Factor out some common prep work
3180 */
3181 switch (cmd) {
3182 case TIOCSETD:
3183 case TIOCSBRK:
3184 case TIOCCBRK:
3185 case TCSBRK:
3186 case TCSBRKP:
3187 retval = tty_check_change(tty);
3188 if (retval)
3189 return retval;
3190 if (cmd != TIOCCBRK) {
3191 tty_wait_until_sent(tty, 0);
3192 if (signal_pending(current))
3193 return -EINTR;
3194 }
3195 break;
3196 }
3197
3198 switch (cmd) {
3199 case TIOCSTI:
3200 return tiocsti(tty, p);
3201 case TIOCGWINSZ:
3202 return tiocgwinsz(tty, p);
3203 case TIOCSWINSZ:
3204 return tiocswinsz(tty, real_tty, p);
3205 case TIOCCONS:
3206 return real_tty!=tty ? -EINVAL : tioccons(file);
3207 case FIONBIO:
3208 return fionbio(file, p);
3209 case TIOCEXCL:
3210 set_bit(TTY_EXCLUSIVE, &tty->flags);
3211 return 0;
3212 case TIOCNXCL:
3213 clear_bit(TTY_EXCLUSIVE, &tty->flags);
3214 return 0;
3215 case TIOCNOTTY:
Alan Coxaf9b8972006-08-27 01:24:01 -07003216 /* FIXME: taks lock or tty_mutex ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217 if (current->signal->tty != tty)
3218 return -ENOTTY;
3219 if (current->signal->leader)
3220 disassociate_ctty(0);
3221 task_lock(current);
3222 current->signal->tty = NULL;
3223 task_unlock(current);
3224 return 0;
3225 case TIOCSCTTY:
3226 return tiocsctty(tty, arg);
3227 case TIOCGPGRP:
3228 return tiocgpgrp(tty, real_tty, p);
3229 case TIOCSPGRP:
3230 return tiocspgrp(tty, real_tty, p);
3231 case TIOCGSID:
3232 return tiocgsid(tty, real_tty, p);
3233 case TIOCGETD:
3234 /* FIXME: check this is ok */
3235 return put_user(tty->ldisc.num, (int __user *)p);
3236 case TIOCSETD:
3237 return tiocsetd(tty, p);
3238#ifdef CONFIG_VT
3239 case TIOCLINUX:
3240 return tioclinux(tty, arg);
3241#endif
3242 /*
3243 * Break handling
3244 */
3245 case TIOCSBRK: /* Turn break on, unconditionally */
3246 tty->driver->break_ctl(tty, -1);
3247 return 0;
3248
3249 case TIOCCBRK: /* Turn break off, unconditionally */
3250 tty->driver->break_ctl(tty, 0);
3251 return 0;
3252 case TCSBRK: /* SVID version: non-zero arg --> no break */
Paul Fulghum283fef52006-06-27 02:54:00 -07003253 /* non-zero arg means wait for all output data
3254 * to be sent (performed above) but don't send break.
3255 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003256 */
3257 if (!arg)
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003258 return send_break(tty, 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259 return 0;
3260 case TCSBRKP: /* support for POSIX tcsendbreak() */
Domen Puncerb20f3ae2005-06-25 14:58:42 -07003261 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262
3263 case TIOCMGET:
3264 return tty_tiocmget(tty, file, p);
3265
3266 case TIOCMSET:
3267 case TIOCMBIC:
3268 case TIOCMBIS:
3269 return tty_tiocmset(tty, file, cmd, p);
3270 }
3271 if (tty->driver->ioctl) {
3272 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3273 if (retval != -ENOIOCTLCMD)
3274 return retval;
3275 }
3276 ld = tty_ldisc_ref_wait(tty);
3277 retval = -EINVAL;
3278 if (ld->ioctl) {
3279 retval = ld->ioctl(tty, file, cmd, arg);
3280 if (retval == -ENOIOCTLCMD)
3281 retval = -EINVAL;
3282 }
3283 tty_ldisc_deref(ld);
3284 return retval;
3285}
3286
3287
3288/*
3289 * This implements the "Secure Attention Key" --- the idea is to
3290 * prevent trojan horses by killing all processes associated with this
3291 * tty when the user hits the "Secure Attention Key". Required for
3292 * super-paranoid applications --- see the Orange Book for more details.
3293 *
3294 * This code could be nicer; ideally it should send a HUP, wait a few
3295 * seconds, then send a INT, and then a KILL signal. But you then
3296 * have to coordinate with the init process, since all processes associated
3297 * with the current tty must be dead before the new getty is allowed
3298 * to spawn.
3299 *
3300 * Now, if it would be correct ;-/ The current code has a nasty hole -
3301 * it doesn't catch files in flight. We may send the descriptor to ourselves
3302 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3303 *
3304 * Nasty bug: do_SAK is being called in interrupt context. This can
3305 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3306 */
3307static void __do_SAK(void *arg)
3308{
3309#ifdef TTY_SOFT_SAK
3310 tty_hangup(tty);
3311#else
3312 struct tty_struct *tty = arg;
Eric W. Biederman652486f2006-03-28 16:11:02 -08003313 struct task_struct *g, *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 int session;
3315 int i;
3316 struct file *filp;
3317 struct tty_ldisc *disc;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07003318 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319
3320 if (!tty)
3321 return;
3322 session = tty->session;
3323
3324 /* We don't want an ldisc switch during this */
3325 disc = tty_ldisc_ref(tty);
3326 if (disc && disc->flush_buffer)
3327 disc->flush_buffer(tty);
3328 tty_ldisc_deref(disc);
3329
3330 if (tty->driver->flush_buffer)
3331 tty->driver->flush_buffer(tty);
3332
3333 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003334 /* Kill the entire session */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335 do_each_task_pid(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08003336 printk(KERN_NOTICE "SAK: killed process %d"
3337 " (%s): p->signal->session==tty->session\n",
3338 p->pid, p->comm);
3339 send_sig(SIGKILL, p, 1);
3340 } while_each_task_pid(session, PIDTYPE_SID, p);
3341 /* Now kill any processes that happen to have the
3342 * tty open.
3343 */
3344 do_each_thread(g, p) {
3345 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003346 printk(KERN_NOTICE "SAK: killed process %d"
3347 " (%s): p->signal->session==tty->session\n",
3348 p->pid, p->comm);
3349 send_sig(SIGKILL, p, 1);
3350 continue;
3351 }
3352 task_lock(p);
3353 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07003354 /*
3355 * We don't take a ref to the file, so we must
3356 * hold ->file_lock instead.
3357 */
3358 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07003359 fdt = files_fdtable(p->files);
3360 for (i=0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361 filp = fcheck_files(p->files, i);
3362 if (!filp)
3363 continue;
3364 if (filp->f_op->read == tty_read &&
3365 filp->private_data == tty) {
3366 printk(KERN_NOTICE "SAK: killed process %d"
3367 " (%s): fd#%d opened to the tty\n",
3368 p->pid, p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06003369 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370 break;
3371 }
3372 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07003373 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374 }
3375 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003376 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377 read_unlock(&tasklist_lock);
3378#endif
3379}
3380
3381/*
3382 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3383 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3384 * the values which we write to it will be identical to the values which it
3385 * already has. --akpm
3386 */
3387void do_SAK(struct tty_struct *tty)
3388{
3389 if (!tty)
3390 return;
3391 PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
3392 schedule_work(&tty->SAK_work);
3393}
3394
3395EXPORT_SYMBOL(do_SAK);
3396
Alan Coxaf9b8972006-08-27 01:24:01 -07003397/**
3398 * flush_to_ldisc
3399 * @private_: tty structure passed from work queue.
3400 *
3401 * This routine is called out of the software interrupt to flush data
3402 * from the buffer chain to the line discipline.
3403 *
3404 * Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3405 * while invoking the line discipline receive_buf method. The
3406 * receive_buf method is single threaded for each tty instance.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407 */
3408
3409static void flush_to_ldisc(void *private_)
3410{
3411 struct tty_struct *tty = (struct tty_struct *) private_;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003412 unsigned long flags;
3413 struct tty_ldisc *disc;
Paul Fulghum2c3bb202006-06-28 04:26:48 -07003414 struct tty_buffer *tbuf, *head;
Paul Fulghum8977d922006-02-10 01:51:14 -08003415 char *char_buf;
3416 unsigned char *flag_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417
3418 disc = tty_ldisc_ref(tty);
3419 if (disc == NULL) /* !TTY_LDISC */
3420 return;
3421
Paul Fulghum808249c2006-02-03 03:04:41 -08003422 spin_lock_irqsave(&tty->buf.lock, flags);
Paul Fulghum2c3bb202006-06-28 04:26:48 -07003423 head = tty->buf.head;
3424 if (head != NULL) {
3425 tty->buf.head = NULL;
3426 for (;;) {
3427 int count = head->commit - head->read;
3428 if (!count) {
3429 if (head->next == NULL)
3430 break;
3431 tbuf = head;
3432 head = head->next;
3433 tty_buffer_free(tty, tbuf);
3434 continue;
3435 }
3436 if (!tty->receive_room) {
3437 schedule_delayed_work(&tty->buf.work, 1);
3438 break;
3439 }
3440 if (count > tty->receive_room)
3441 count = tty->receive_room;
3442 char_buf = head->char_buf_ptr + head->read;
3443 flag_buf = head->flag_buf_ptr + head->read;
3444 head->read += count;
Paul Fulghum8977d922006-02-10 01:51:14 -08003445 spin_unlock_irqrestore(&tty->buf.lock, flags);
3446 disc->receive_buf(tty, char_buf, flag_buf, count);
3447 spin_lock_irqsave(&tty->buf.lock, flags);
3448 }
Paul Fulghum2c3bb202006-06-28 04:26:48 -07003449 tty->buf.head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003450 }
Paul Fulghum808249c2006-02-03 03:04:41 -08003451 spin_unlock_irqrestore(&tty->buf.lock, flags);
Paul Fulghum817d6d32006-06-28 04:26:47 -07003452
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453 tty_ldisc_deref(disc);
3454}
3455
3456/*
3457 * Routine which returns the baud rate of the tty
3458 *
3459 * Note that the baud_table needs to be kept in sync with the
3460 * include/asm/termbits.h file.
3461 */
3462static int baud_table[] = {
3463 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
3464 9600, 19200, 38400, 57600, 115200, 230400, 460800,
3465#ifdef __sparc__
3466 76800, 153600, 307200, 614400, 921600
3467#else
3468 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
3469 2500000, 3000000, 3500000, 4000000
3470#endif
3471};
3472
3473static int n_baud_table = ARRAY_SIZE(baud_table);
3474
3475/**
3476 * tty_termios_baud_rate
3477 * @termios: termios structure
3478 *
3479 * Convert termios baud rate data into a speed. This should be called
3480 * with the termios lock held if this termios is a terminal termios
3481 * structure. May change the termios data.
Alan Coxaf9b8972006-08-27 01:24:01 -07003482 *
3483 * Locking: none
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 */
3485
3486int tty_termios_baud_rate(struct termios *termios)
3487{
3488 unsigned int cbaud;
3489
3490 cbaud = termios->c_cflag & CBAUD;
3491
3492 if (cbaud & CBAUDEX) {
3493 cbaud &= ~CBAUDEX;
3494
3495 if (cbaud < 1 || cbaud + 15 > n_baud_table)
3496 termios->c_cflag &= ~CBAUDEX;
3497 else
3498 cbaud += 15;
3499 }
3500 return baud_table[cbaud];
3501}
3502
3503EXPORT_SYMBOL(tty_termios_baud_rate);
3504
3505/**
3506 * tty_get_baud_rate - get tty bit rates
3507 * @tty: tty to query
3508 *
3509 * Returns the baud rate as an integer for this terminal. The
3510 * termios lock must be held by the caller and the terminal bit
3511 * flags may be updated.
Alan Coxaf9b8972006-08-27 01:24:01 -07003512 *
3513 * Locking: none
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514 */
3515
3516int tty_get_baud_rate(struct tty_struct *tty)
3517{
3518 int baud = tty_termios_baud_rate(tty->termios);
3519
3520 if (baud == 38400 && tty->alt_speed) {
3521 if (!tty->warned) {
3522 printk(KERN_WARNING "Use of setserial/setrocket to "
3523 "set SPD_* flags is deprecated\n");
3524 tty->warned = 1;
3525 }
3526 baud = tty->alt_speed;
3527 }
3528
3529 return baud;
3530}
3531
3532EXPORT_SYMBOL(tty_get_baud_rate);
3533
3534/**
3535 * tty_flip_buffer_push - terminal
3536 * @tty: tty to push
3537 *
3538 * Queue a push of the terminal flip buffers to the line discipline. This
3539 * function must not be called from IRQ context if tty->low_latency is set.
3540 *
3541 * In the event of the queue being busy for flipping the work will be
3542 * held off and retried later.
Alan Coxaf9b8972006-08-27 01:24:01 -07003543 *
3544 * Locking: tty buffer lock. Driver locks in low latency mode.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545 */
3546
3547void tty_flip_buffer_push(struct tty_struct *tty)
3548{
Paul Fulghum808249c2006-02-03 03:04:41 -08003549 unsigned long flags;
3550 spin_lock_irqsave(&tty->buf.lock, flags);
Paul Fulghum33b37a32006-06-28 04:26:49 -07003551 if (tty->buf.tail != NULL)
Paul Fulghum8977d922006-02-10 01:51:14 -08003552 tty->buf.tail->commit = tty->buf.tail->used;
Paul Fulghum808249c2006-02-03 03:04:41 -08003553 spin_unlock_irqrestore(&tty->buf.lock, flags);
3554
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555 if (tty->low_latency)
3556 flush_to_ldisc((void *) tty);
3557 else
Alan Cox33f0f882006-01-09 20:54:13 -08003558 schedule_delayed_work(&tty->buf.work, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559}
3560
3561EXPORT_SYMBOL(tty_flip_buffer_push);
3562
Alan Cox33f0f882006-01-09 20:54:13 -08003563
Alan Coxaf9b8972006-08-27 01:24:01 -07003564/**
3565 * initialize_tty_struct
3566 * @tty: tty to initialize
3567 *
3568 * This subroutine initializes a tty structure that has been newly
3569 * allocated.
3570 *
3571 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003573
Linus Torvalds1da177e2005-04-16 15:20:36 -07003574static void initialize_tty_struct(struct tty_struct *tty)
3575{
3576 memset(tty, 0, sizeof(struct tty_struct));
3577 tty->magic = TTY_MAGIC;
3578 tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3579 tty->pgrp = -1;
3580 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08003581 tty->buf.head = tty->buf.tail = NULL;
3582 tty_buffer_init(tty);
3583 INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
3584 init_MUTEX(&tty->buf.pty_sem);
Arjan van de Ven5785c952006-09-29 02:00:43 -07003585 mutex_init(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586 init_waitqueue_head(&tty->write_wait);
3587 init_waitqueue_head(&tty->read_wait);
3588 INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08003589 mutex_init(&tty->atomic_read_lock);
3590 mutex_init(&tty->atomic_write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591 spin_lock_init(&tty->read_lock);
3592 INIT_LIST_HEAD(&tty->tty_files);
3593 INIT_WORK(&tty->SAK_work, NULL, NULL);
3594}
3595
3596/*
3597 * The default put_char routine if the driver did not define one.
3598 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003599
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3601{
3602 tty->driver->write(tty, &ch, 1);
3603}
3604
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003605static struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606
3607/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003608 * tty_register_device - register a tty device
3609 * @driver: the tty driver that describes the tty device
3610 * @index: the index in the tty driver for this tty device
3611 * @device: a struct device that is associated with this tty device.
3612 * This field is optional, if there is no known struct device
3613 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003614 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003615 * Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003616 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003617 * This call is required to be made to register an individual tty device
3618 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3619 * that bit is not set, this function should not be called by a tty
3620 * driver.
3621 *
3622 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003624
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003625struct class_device *tty_register_device(struct tty_driver *driver,
3626 unsigned index, struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627{
3628 char name[64];
3629 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3630
3631 if (index >= driver->num) {
3632 printk(KERN_ERR "Attempt to register invalid tty line number "
3633 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003634 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003635 }
3636
Linus Torvalds1da177e2005-04-16 15:20:36 -07003637 if (driver->type == TTY_DRIVER_TYPE_PTY)
3638 pty_line_name(driver, index, name);
3639 else
3640 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003641
3642 return class_device_create(tty_class, NULL, dev, device, "%s", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643}
3644
3645/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003646 * tty_unregister_device - unregister a tty device
3647 * @driver: the tty driver that describes the tty device
3648 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003650 * If a tty device is registered with a call to tty_register_device() then
3651 * this function must be called when the tty device is gone.
3652 *
3653 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003655
Linus Torvalds1da177e2005-04-16 15:20:36 -07003656void tty_unregister_device(struct tty_driver *driver, unsigned index)
3657{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003658 class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003659}
3660
3661EXPORT_SYMBOL(tty_register_device);
3662EXPORT_SYMBOL(tty_unregister_device);
3663
3664struct tty_driver *alloc_tty_driver(int lines)
3665{
3666 struct tty_driver *driver;
3667
3668 driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
3669 if (driver) {
3670 memset(driver, 0, sizeof(struct tty_driver));
3671 driver->magic = TTY_DRIVER_MAGIC;
3672 driver->num = lines;
3673 /* later we'll move allocation of tables here */
3674 }
3675 return driver;
3676}
3677
3678void put_tty_driver(struct tty_driver *driver)
3679{
3680 kfree(driver);
3681}
3682
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003683void tty_set_operations(struct tty_driver *driver,
3684 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003685{
3686 driver->open = op->open;
3687 driver->close = op->close;
3688 driver->write = op->write;
3689 driver->put_char = op->put_char;
3690 driver->flush_chars = op->flush_chars;
3691 driver->write_room = op->write_room;
3692 driver->chars_in_buffer = op->chars_in_buffer;
3693 driver->ioctl = op->ioctl;
3694 driver->set_termios = op->set_termios;
3695 driver->throttle = op->throttle;
3696 driver->unthrottle = op->unthrottle;
3697 driver->stop = op->stop;
3698 driver->start = op->start;
3699 driver->hangup = op->hangup;
3700 driver->break_ctl = op->break_ctl;
3701 driver->flush_buffer = op->flush_buffer;
3702 driver->set_ldisc = op->set_ldisc;
3703 driver->wait_until_sent = op->wait_until_sent;
3704 driver->send_xchar = op->send_xchar;
3705 driver->read_proc = op->read_proc;
3706 driver->write_proc = op->write_proc;
3707 driver->tiocmget = op->tiocmget;
3708 driver->tiocmset = op->tiocmset;
3709}
3710
3711
3712EXPORT_SYMBOL(alloc_tty_driver);
3713EXPORT_SYMBOL(put_tty_driver);
3714EXPORT_SYMBOL(tty_set_operations);
3715
3716/*
3717 * Called by a tty driver to register itself.
3718 */
3719int tty_register_driver(struct tty_driver *driver)
3720{
3721 int error;
3722 int i;
3723 dev_t dev;
3724 void **p = NULL;
3725
3726 if (driver->flags & TTY_DRIVER_INSTALLED)
3727 return 0;
3728
3729 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
3730 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3731 if (!p)
3732 return -ENOMEM;
3733 memset(p, 0, driver->num * 3 * sizeof(void *));
3734 }
3735
3736 if (!driver->major) {
3737 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3738 (char*)driver->name);
3739 if (!error) {
3740 driver->major = MAJOR(dev);
3741 driver->minor_start = MINOR(dev);
3742 }
3743 } else {
3744 dev = MKDEV(driver->major, driver->minor_start);
3745 error = register_chrdev_region(dev, driver->num,
3746 (char*)driver->name);
3747 }
3748 if (error < 0) {
3749 kfree(p);
3750 return error;
3751 }
3752
3753 if (p) {
3754 driver->ttys = (struct tty_struct **)p;
3755 driver->termios = (struct termios **)(p + driver->num);
3756 driver->termios_locked = (struct termios **)(p + driver->num * 2);
3757 } else {
3758 driver->ttys = NULL;
3759 driver->termios = NULL;
3760 driver->termios_locked = NULL;
3761 }
3762
3763 cdev_init(&driver->cdev, &tty_fops);
3764 driver->cdev.owner = driver->owner;
3765 error = cdev_add(&driver->cdev, dev, driver->num);
3766 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003767 unregister_chrdev_region(dev, driver->num);
3768 driver->ttys = NULL;
3769 driver->termios = driver->termios_locked = NULL;
3770 kfree(p);
3771 return error;
3772 }
3773
3774 if (!driver->put_char)
3775 driver->put_char = tty_default_put_char;
3776
3777 list_add(&driver->tty_drivers, &tty_drivers);
3778
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -07003779 if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003780 for(i = 0; i < driver->num; i++)
3781 tty_register_device(driver, i, NULL);
3782 }
3783 proc_tty_register_driver(driver);
3784 return 0;
3785}
3786
3787EXPORT_SYMBOL(tty_register_driver);
3788
3789/*
3790 * Called by a tty driver to unregister itself.
3791 */
3792int tty_unregister_driver(struct tty_driver *driver)
3793{
3794 int i;
3795 struct termios *tp;
3796 void *p;
3797
3798 if (driver->refcount)
3799 return -EBUSY;
3800
3801 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3802 driver->num);
3803
3804 list_del(&driver->tty_drivers);
3805
3806 /*
3807 * Free the termios and termios_locked structures because
3808 * we don't want to get memory leaks when modular tty
3809 * drivers are removed from the kernel.
3810 */
3811 for (i = 0; i < driver->num; i++) {
3812 tp = driver->termios[i];
3813 if (tp) {
3814 driver->termios[i] = NULL;
3815 kfree(tp);
3816 }
3817 tp = driver->termios_locked[i];
3818 if (tp) {
3819 driver->termios_locked[i] = NULL;
3820 kfree(tp);
3821 }
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -07003822 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003823 tty_unregister_device(driver, i);
3824 }
3825 p = driver->ttys;
3826 proc_tty_unregister_driver(driver);
3827 driver->ttys = NULL;
3828 driver->termios = driver->termios_locked = NULL;
3829 kfree(p);
3830 cdev_del(&driver->cdev);
3831 return 0;
3832}
3833
3834EXPORT_SYMBOL(tty_unregister_driver);
3835
3836
3837/*
3838 * Initialize the console device. This is called *early*, so
3839 * we can't necessarily depend on lots of kernel help here.
3840 * Just do some early initializations, and do the complex setup
3841 * later.
3842 */
3843void __init console_init(void)
3844{
3845 initcall_t *call;
3846
3847 /* Setup the default TTY line discipline. */
3848 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
3849
3850 /*
3851 * set up the console device so that later boot sequences can
3852 * inform about problems etc..
3853 */
3854#ifdef CONFIG_EARLY_PRINTK
3855 disable_early_printk();
3856#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003857 call = __con_initcall_start;
3858 while (call < __con_initcall_end) {
3859 (*call)();
3860 call++;
3861 }
3862}
3863
3864#ifdef CONFIG_VT
3865extern int vty_init(void);
3866#endif
3867
3868static int __init tty_class_init(void)
3869{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003870 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871 if (IS_ERR(tty_class))
3872 return PTR_ERR(tty_class);
3873 return 0;
3874}
3875
3876postcore_initcall(tty_class_init);
3877
3878/* 3/2004 jmc: why do these devices exist? */
3879
3880static struct cdev tty_cdev, console_cdev;
3881#ifdef CONFIG_UNIX98_PTYS
3882static struct cdev ptmx_cdev;
3883#endif
3884#ifdef CONFIG_VT
3885static struct cdev vc0_cdev;
3886#endif
3887
3888/*
3889 * Ok, now we can initialize the rest of the tty devices and can count
3890 * on memory allocations, interrupts etc..
3891 */
3892static int __init tty_init(void)
3893{
3894 cdev_init(&tty_cdev, &tty_fops);
3895 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3896 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3897 panic("Couldn't register /dev/tty driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003898 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003899
3900 cdev_init(&console_cdev, &console_fops);
3901 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3902 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3903 panic("Couldn't register /dev/console driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003904 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003905
3906#ifdef CONFIG_UNIX98_PTYS
3907 cdev_init(&ptmx_cdev, &ptmx_fops);
3908 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
3909 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
3910 panic("Couldn't register /dev/ptmx driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003911 class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003912#endif
3913
3914#ifdef CONFIG_VT
3915 cdev_init(&vc0_cdev, &console_fops);
3916 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3917 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3918 panic("Couldn't register /dev/tty0 driver\n");
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07003919 class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920
3921 vty_init();
3922#endif
3923 return 0;
3924}
3925module_init(tty_init);