Loading...
1/*
2 * Copyright (C) 1991, 1992 Linus Torvalds
3 */
4
5/*
6 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
7 * or rs-channels. It also implements echoing, cooked mode etc.
8 *
9 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
10 *
11 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
12 * tty_struct and tty_queue structures. Previously there was an array
13 * of 256 tty_struct's which was statically allocated, and the
14 * tty_queue structures were allocated at boot time. Both are now
15 * dynamically allocated only when the tty is open.
16 *
17 * Also restructured routines so that there is more of a separation
18 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
19 * the low-level tty routines (serial.c, pty.c, console.c). This
20 * makes for cleaner and more compact code. -TYT, 9/17/92
21 *
22 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
23 * which can be dynamically activated and de-activated by the line
24 * discipline handling modules (like SLIP).
25 *
26 * NOTE: pay no attention to the line discipline code (yet); its
27 * interface is still subject to change in this version...
28 * -- TYT, 1/31/92
29 *
30 * Added functionality to the OPOST tty handling. No delays, but all
31 * other bits should be there.
32 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
33 *
34 * Rewrote canonical mode and added more termios flags.
35 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
36 *
37 * Reorganized FASYNC support so mouse code can share it.
38 * -- ctm@ardi.com, 9Sep95
39 *
40 * New TIOCLINUX variants added.
41 * -- mj@k332.feld.cvut.cz, 19-Nov-95
42 *
43 * Restrict vt switching via ioctl()
44 * -- grif@cs.ucr.edu, 5-Dec-95
45 *
46 * Move console and virtual terminal code to more appropriate files,
47 * implement CONFIG_VT and generalize console device interface.
48 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
49 *
50 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
51 * -- Bill Hawes <whawes@star.net>, June 97
52 *
53 * Added devfs support.
54 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
55 *
56 * Added support for a Unix98-style ptmx device.
57 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
58 *
59 * Reduced memory usage for older ARM systems
60 * -- Russell King <rmk@arm.linux.org.uk>
61 *
62 * Move do_SAK() into process context. Less stack use in devfs functions.
63 * alloc_tty_struct() always uses kmalloc()
64 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
65 */
66
67#include <linux/types.h>
68#include <linux/major.h>
69#include <linux/errno.h>
70#include <linux/signal.h>
71#include <linux/fcntl.h>
72#include <linux/sched.h>
73#include <linux/interrupt.h>
74#include <linux/tty.h>
75#include <linux/tty_driver.h>
76#include <linux/tty_flip.h>
77#include <linux/devpts_fs.h>
78#include <linux/file.h>
79#include <linux/fdtable.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/device.h>
92#include <linux/wait.h>
93#include <linux/bitops.h>
94#include <linux/delay.h>
95#include <linux/seq_file.h>
96#include <linux/serial.h>
97#include <linux/ratelimit.h>
98
99#include <linux/uaccess.h>
100
101#include <linux/kbd_kern.h>
102#include <linux/vt_kern.h>
103#include <linux/selection.h>
104
105#include <linux/kmod.h>
106#include <linux/nsproxy.h>
107
108#undef TTY_DEBUG_HANGUP
109
110#define TTY_PARANOIA_CHECK 1
111#define CHECK_TTY_COUNT 1
112
113struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
119 .c_cc = INIT_C_CC,
120 .c_ispeed = 38400,
121 .c_ospeed = 38400
122};
123
124EXPORT_SYMBOL(tty_std_termios);
125
126/* This list gets poked at by procfs and various bits of boot up code. This
127 could do with some rationalisation such as pulling the tty proc function
128 into this file */
129
130LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131
132/* Mutex to protect creating and releasing a tty. This is shared with
133 vt.c for deeply disgusting hack reasons */
134DEFINE_MUTEX(tty_mutex);
135EXPORT_SYMBOL(tty_mutex);
136
137/* Spinlock to protect the tty->tty_files list */
138DEFINE_SPINLOCK(tty_files_lock);
139
140static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
141static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
142ssize_t redirected_tty_write(struct file *, const char __user *,
143 size_t, loff_t *);
144static unsigned int tty_poll(struct file *, poll_table *);
145static int tty_open(struct inode *, struct file *);
146long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
147#ifdef CONFIG_COMPAT
148static long tty_compat_ioctl(struct file *file, unsigned int cmd,
149 unsigned long arg);
150#else
151#define tty_compat_ioctl NULL
152#endif
153static int __tty_fasync(int fd, struct file *filp, int on);
154static int tty_fasync(int fd, struct file *filp, int on);
155static void release_tty(struct tty_struct *tty, int idx);
156static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
157static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
158
159/**
160 * alloc_tty_struct - allocate a tty object
161 *
162 * Return a new empty tty structure. The data fields have not
163 * been initialized in any way but has been zeroed
164 *
165 * Locking: none
166 */
167
168struct tty_struct *alloc_tty_struct(void)
169{
170 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
171}
172
173/**
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
182void free_tty_struct(struct tty_struct *tty)
183{
184 if (!tty)
185 return;
186 if (tty->dev)
187 put_device(tty->dev);
188 kfree(tty->write_buf);
189 tty->magic = 0xDEADDEAD;
190 kfree(tty);
191}
192
193static inline struct tty_struct *file_tty(struct file *file)
194{
195 return ((struct tty_file_private *)file->private_data)->tty;
196}
197
198int tty_alloc_file(struct file *file)
199{
200 struct tty_file_private *priv;
201
202 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
203 if (!priv)
204 return -ENOMEM;
205
206 file->private_data = priv;
207
208 return 0;
209}
210
211/* Associate a new file with the tty structure */
212void tty_add_file(struct tty_struct *tty, struct file *file)
213{
214 struct tty_file_private *priv = file->private_data;
215
216 priv->tty = tty;
217 priv->file = file;
218
219 spin_lock(&tty_files_lock);
220 list_add(&priv->list, &tty->tty_files);
221 spin_unlock(&tty_files_lock);
222}
223
224/**
225 * tty_free_file - free file->private_data
226 *
227 * This shall be used only for fail path handling when tty_add_file was not
228 * called yet.
229 */
230void tty_free_file(struct file *file)
231{
232 struct tty_file_private *priv = file->private_data;
233
234 file->private_data = NULL;
235 kfree(priv);
236}
237
238/* Delete file from its tty */
239static void tty_del_file(struct file *file)
240{
241 struct tty_file_private *priv = file->private_data;
242
243 spin_lock(&tty_files_lock);
244 list_del(&priv->list);
245 spin_unlock(&tty_files_lock);
246 tty_free_file(file);
247}
248
249
250#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
251
252/**
253 * tty_name - return tty naming
254 * @tty: tty structure
255 * @buf: buffer for output
256 *
257 * Convert a tty structure into a name. The name reflects the kernel
258 * naming policy and if udev is in use may not reflect user space
259 *
260 * Locking: none
261 */
262
263char *tty_name(struct tty_struct *tty, char *buf)
264{
265 if (!tty) /* Hmm. NULL pointer. That's fun. */
266 strcpy(buf, "NULL tty");
267 else
268 strcpy(buf, tty->name);
269 return buf;
270}
271
272EXPORT_SYMBOL(tty_name);
273
274int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
275 const char *routine)
276{
277#ifdef TTY_PARANOIA_CHECK
278 if (!tty) {
279 printk(KERN_WARNING
280 "null TTY for (%d:%d) in %s\n",
281 imajor(inode), iminor(inode), routine);
282 return 1;
283 }
284 if (tty->magic != TTY_MAGIC) {
285 printk(KERN_WARNING
286 "bad magic number for tty struct (%d:%d) in %s\n",
287 imajor(inode), iminor(inode), routine);
288 return 1;
289 }
290#endif
291 return 0;
292}
293
294static int check_tty_count(struct tty_struct *tty, const char *routine)
295{
296#ifdef CHECK_TTY_COUNT
297 struct list_head *p;
298 int count = 0;
299
300 spin_lock(&tty_files_lock);
301 list_for_each(p, &tty->tty_files) {
302 count++;
303 }
304 spin_unlock(&tty_files_lock);
305 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
306 tty->driver->subtype == PTY_TYPE_SLAVE &&
307 tty->link && tty->link->count)
308 count++;
309 if (tty->count != count) {
310 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
311 "!= #fd's(%d) in %s\n",
312 tty->name, tty->count, count, routine);
313 return count;
314 }
315#endif
316 return 0;
317}
318
319/**
320 * get_tty_driver - find device of a tty
321 * @dev_t: device identifier
322 * @index: returns the index of the tty
323 *
324 * This routine returns a tty driver structure, given a device number
325 * and also passes back the index number.
326 *
327 * Locking: caller must hold tty_mutex
328 */
329
330static struct tty_driver *get_tty_driver(dev_t device, int *index)
331{
332 struct tty_driver *p;
333
334 list_for_each_entry(p, &tty_drivers, tty_drivers) {
335 dev_t base = MKDEV(p->major, p->minor_start);
336 if (device < base || device >= base + p->num)
337 continue;
338 *index = device - base;
339 return tty_driver_kref_get(p);
340 }
341 return NULL;
342}
343
344#ifdef CONFIG_CONSOLE_POLL
345
346/**
347 * tty_find_polling_driver - find device of a polled tty
348 * @name: name string to match
349 * @line: pointer to resulting tty line nr
350 *
351 * This routine returns a tty driver structure, given a name
352 * and the condition that the tty driver is capable of polled
353 * operation.
354 */
355struct tty_driver *tty_find_polling_driver(char *name, int *line)
356{
357 struct tty_driver *p, *res = NULL;
358 int tty_line = 0;
359 int len;
360 char *str, *stp;
361
362 for (str = name; *str; str++)
363 if ((*str >= '0' && *str <= '9') || *str == ',')
364 break;
365 if (!*str)
366 return NULL;
367
368 len = str - name;
369 tty_line = simple_strtoul(str, &str, 10);
370
371 mutex_lock(&tty_mutex);
372 /* Search through the tty devices to look for a match */
373 list_for_each_entry(p, &tty_drivers, tty_drivers) {
374 if (strncmp(name, p->name, len) != 0)
375 continue;
376 stp = str;
377 if (*stp == ',')
378 stp++;
379 if (*stp == '\0')
380 stp = NULL;
381
382 if (tty_line >= 0 && tty_line < p->num && p->ops &&
383 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
384 res = tty_driver_kref_get(p);
385 *line = tty_line;
386 break;
387 }
388 }
389 mutex_unlock(&tty_mutex);
390
391 return res;
392}
393EXPORT_SYMBOL_GPL(tty_find_polling_driver);
394#endif
395
396/**
397 * tty_check_change - check for POSIX terminal changes
398 * @tty: tty to check
399 *
400 * If we try to write to, or set the state of, a terminal and we're
401 * not in the foreground, send a SIGTTOU. If the signal is blocked or
402 * ignored, go ahead and perform the operation. (POSIX 7.2)
403 *
404 * Locking: ctrl_lock
405 */
406
407int tty_check_change(struct tty_struct *tty)
408{
409 unsigned long flags;
410 int ret = 0;
411
412 if (current->signal->tty != tty)
413 return 0;
414
415 spin_lock_irqsave(&tty->ctrl_lock, flags);
416
417 if (!tty->pgrp) {
418 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
419 goto out_unlock;
420 }
421 if (task_pgrp(current) == tty->pgrp)
422 goto out_unlock;
423 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
424 if (is_ignored(SIGTTOU))
425 goto out;
426 if (is_current_pgrp_orphaned()) {
427 ret = -EIO;
428 goto out;
429 }
430 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
431 set_thread_flag(TIF_SIGPENDING);
432 ret = -ERESTARTSYS;
433out:
434 return ret;
435out_unlock:
436 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
437 return ret;
438}
439
440EXPORT_SYMBOL(tty_check_change);
441
442static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
443 size_t count, loff_t *ppos)
444{
445 return 0;
446}
447
448static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
449 size_t count, loff_t *ppos)
450{
451 return -EIO;
452}
453
454/* No kernel lock held - none needed ;) */
455static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
456{
457 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
458}
459
460static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
461 unsigned long arg)
462{
463 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
464}
465
466static long hung_up_tty_compat_ioctl(struct file *file,
467 unsigned int cmd, unsigned long arg)
468{
469 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
470}
471
472static const struct file_operations tty_fops = {
473 .llseek = no_llseek,
474 .read = tty_read,
475 .write = tty_write,
476 .poll = tty_poll,
477 .unlocked_ioctl = tty_ioctl,
478 .compat_ioctl = tty_compat_ioctl,
479 .open = tty_open,
480 .release = tty_release,
481 .fasync = tty_fasync,
482};
483
484static const struct file_operations console_fops = {
485 .llseek = no_llseek,
486 .read = tty_read,
487 .write = redirected_tty_write,
488 .poll = tty_poll,
489 .unlocked_ioctl = tty_ioctl,
490 .compat_ioctl = tty_compat_ioctl,
491 .open = tty_open,
492 .release = tty_release,
493 .fasync = tty_fasync,
494};
495
496static const struct file_operations hung_up_tty_fops = {
497 .llseek = no_llseek,
498 .read = hung_up_tty_read,
499 .write = hung_up_tty_write,
500 .poll = hung_up_tty_poll,
501 .unlocked_ioctl = hung_up_tty_ioctl,
502 .compat_ioctl = hung_up_tty_compat_ioctl,
503 .release = tty_release,
504};
505
506static DEFINE_SPINLOCK(redirect_lock);
507static struct file *redirect;
508
509/**
510 * tty_wakeup - request more data
511 * @tty: terminal
512 *
513 * Internal and external helper for wakeups of tty. This function
514 * informs the line discipline if present that the driver is ready
515 * to receive more output data.
516 */
517
518void tty_wakeup(struct tty_struct *tty)
519{
520 struct tty_ldisc *ld;
521
522 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
523 ld = tty_ldisc_ref(tty);
524 if (ld) {
525 if (ld->ops->write_wakeup)
526 ld->ops->write_wakeup(tty);
527 tty_ldisc_deref(ld);
528 }
529 }
530 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
531}
532
533EXPORT_SYMBOL_GPL(tty_wakeup);
534
535/**
536 * tty_signal_session_leader - sends SIGHUP to session leader
537 * @tty controlling tty
538 * @exit_session if non-zero, signal all foreground group processes
539 *
540 * Send SIGHUP and SIGCONT to the session leader and its process group.
541 * Optionally, signal all processes in the foreground process group.
542 *
543 * Returns the number of processes in the session with this tty
544 * as their controlling terminal. This value is used to drop
545 * tty references for those processes.
546 */
547static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)
548{
549 struct task_struct *p;
550 int refs = 0;
551 struct pid *tty_pgrp = NULL;
552
553 read_lock(&tasklist_lock);
554 if (tty->session) {
555 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
556 spin_lock_irq(&p->sighand->siglock);
557 if (p->signal->tty == tty) {
558 p->signal->tty = NULL;
559 /* We defer the dereferences outside fo
560 the tasklist lock */
561 refs++;
562 }
563 if (!p->signal->leader) {
564 spin_unlock_irq(&p->sighand->siglock);
565 continue;
566 }
567 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
568 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
569 put_pid(p->signal->tty_old_pgrp); /* A noop */
570 spin_lock(&tty->ctrl_lock);
571 tty_pgrp = get_pid(tty->pgrp);
572 if (tty->pgrp)
573 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
574 spin_unlock(&tty->ctrl_lock);
575 spin_unlock_irq(&p->sighand->siglock);
576 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
577 }
578 read_unlock(&tasklist_lock);
579
580 if (tty_pgrp) {
581 if (exit_session)
582 kill_pgrp(tty_pgrp, SIGHUP, exit_session);
583 put_pid(tty_pgrp);
584 }
585
586 return refs;
587}
588
589/**
590 * __tty_hangup - actual handler for hangup events
591 * @work: tty device
592 *
593 * This can be called by a "kworker" kernel thread. That is process
594 * synchronous but doesn't hold any locks, so we need to make sure we
595 * have the appropriate locks for what we're doing.
596 *
597 * The hangup event clears any pending redirections onto the hung up
598 * device. It ensures future writes will error and it does the needed
599 * line discipline hangup and signal delivery. The tty object itself
600 * remains intact.
601 *
602 * Locking:
603 * BTM
604 * redirect lock for undoing redirection
605 * file list lock for manipulating list of ttys
606 * tty_ldiscs_lock from called functions
607 * termios_rwsem resetting termios data
608 * tasklist_lock to walk task list for hangup event
609 * ->siglock to protect ->signal/->sighand
610 */
611static void __tty_hangup(struct tty_struct *tty, int exit_session)
612{
613 struct file *cons_filp = NULL;
614 struct file *filp, *f = NULL;
615 struct tty_file_private *priv;
616 int closecount = 0, n;
617 int refs;
618
619 if (!tty)
620 return;
621
622
623 spin_lock(&redirect_lock);
624 if (redirect && file_tty(redirect) == tty) {
625 f = redirect;
626 redirect = NULL;
627 }
628 spin_unlock(&redirect_lock);
629
630 tty_lock(tty);
631
632 if (test_bit(TTY_HUPPED, &tty->flags)) {
633 tty_unlock(tty);
634 return;
635 }
636
637 /* some functions below drop BTM, so we need this bit */
638 set_bit(TTY_HUPPING, &tty->flags);
639
640 /* inuse_filps is protected by the single tty lock,
641 this really needs to change if we want to flush the
642 workqueue with the lock held */
643 check_tty_count(tty, "tty_hangup");
644
645 spin_lock(&tty_files_lock);
646 /* This breaks for file handles being sent over AF_UNIX sockets ? */
647 list_for_each_entry(priv, &tty->tty_files, list) {
648 filp = priv->file;
649 if (filp->f_op->write == redirected_tty_write)
650 cons_filp = filp;
651 if (filp->f_op->write != tty_write)
652 continue;
653 closecount++;
654 __tty_fasync(-1, filp, 0); /* can't block */
655 filp->f_op = &hung_up_tty_fops;
656 }
657 spin_unlock(&tty_files_lock);
658
659 refs = tty_signal_session_leader(tty, exit_session);
660 /* Account for the p->signal references we killed */
661 while (refs--)
662 tty_kref_put(tty);
663
664 /*
665 * it drops BTM and thus races with reopen
666 * we protect the race by TTY_HUPPING
667 */
668 tty_ldisc_hangup(tty);
669
670 spin_lock_irq(&tty->ctrl_lock);
671 clear_bit(TTY_THROTTLED, &tty->flags);
672 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
673 put_pid(tty->session);
674 put_pid(tty->pgrp);
675 tty->session = NULL;
676 tty->pgrp = NULL;
677 tty->ctrl_status = 0;
678 spin_unlock_irq(&tty->ctrl_lock);
679
680 /*
681 * If one of the devices matches a console pointer, we
682 * cannot just call hangup() because that will cause
683 * tty->count and state->count to go out of sync.
684 * So we just call close() the right number of times.
685 */
686 if (cons_filp) {
687 if (tty->ops->close)
688 for (n = 0; n < closecount; n++)
689 tty->ops->close(tty, cons_filp);
690 } else if (tty->ops->hangup)
691 (tty->ops->hangup)(tty);
692 /*
693 * We don't want to have driver/ldisc interactions beyond
694 * the ones we did here. The driver layer expects no
695 * calls after ->hangup() from the ldisc side. However we
696 * can't yet guarantee all that.
697 */
698 set_bit(TTY_HUPPED, &tty->flags);
699 clear_bit(TTY_HUPPING, &tty->flags);
700
701 tty_unlock(tty);
702
703 if (f)
704 fput(f);
705}
706
707static void do_tty_hangup(struct work_struct *work)
708{
709 struct tty_struct *tty =
710 container_of(work, struct tty_struct, hangup_work);
711
712 __tty_hangup(tty, 0);
713}
714
715/**
716 * tty_hangup - trigger a hangup event
717 * @tty: tty to hangup
718 *
719 * A carrier loss (virtual or otherwise) has occurred on this like
720 * schedule a hangup sequence to run after this event.
721 */
722
723void tty_hangup(struct tty_struct *tty)
724{
725#ifdef TTY_DEBUG_HANGUP
726 char buf[64];
727 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
728#endif
729 schedule_work(&tty->hangup_work);
730}
731
732EXPORT_SYMBOL(tty_hangup);
733
734/**
735 * tty_vhangup - process vhangup
736 * @tty: tty to hangup
737 *
738 * The user has asked via system call for the terminal to be hung up.
739 * We do this synchronously so that when the syscall returns the process
740 * is complete. That guarantee is necessary for security reasons.
741 */
742
743void tty_vhangup(struct tty_struct *tty)
744{
745#ifdef TTY_DEBUG_HANGUP
746 char buf[64];
747
748 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
749#endif
750 __tty_hangup(tty, 0);
751}
752
753EXPORT_SYMBOL(tty_vhangup);
754
755
756/**
757 * tty_vhangup_self - process vhangup for own ctty
758 *
759 * Perform a vhangup on the current controlling tty
760 */
761
762void tty_vhangup_self(void)
763{
764 struct tty_struct *tty;
765
766 tty = get_current_tty();
767 if (tty) {
768 tty_vhangup(tty);
769 tty_kref_put(tty);
770 }
771}
772
773/**
774 * tty_vhangup_session - hangup session leader exit
775 * @tty: tty to hangup
776 *
777 * The session leader is exiting and hanging up its controlling terminal.
778 * Every process in the foreground process group is signalled SIGHUP.
779 *
780 * We do this synchronously so that when the syscall returns the process
781 * is complete. That guarantee is necessary for security reasons.
782 */
783
784static void tty_vhangup_session(struct tty_struct *tty)
785{
786#ifdef TTY_DEBUG_HANGUP
787 char buf[64];
788
789 printk(KERN_DEBUG "%s vhangup session...\n", tty_name(tty, buf));
790#endif
791 __tty_hangup(tty, 1);
792}
793
794/**
795 * tty_hung_up_p - was tty hung up
796 * @filp: file pointer of tty
797 *
798 * Return true if the tty has been subject to a vhangup or a carrier
799 * loss
800 */
801
802int tty_hung_up_p(struct file *filp)
803{
804 return (filp->f_op == &hung_up_tty_fops);
805}
806
807EXPORT_SYMBOL(tty_hung_up_p);
808
809static void session_clear_tty(struct pid *session)
810{
811 struct task_struct *p;
812 do_each_pid_task(session, PIDTYPE_SID, p) {
813 proc_clear_tty(p);
814 } while_each_pid_task(session, PIDTYPE_SID, p);
815}
816
817/**
818 * disassociate_ctty - disconnect controlling tty
819 * @on_exit: true if exiting so need to "hang up" the session
820 *
821 * This function is typically called only by the session leader, when
822 * it wants to disassociate itself from its controlling tty.
823 *
824 * It performs the following functions:
825 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
826 * (2) Clears the tty from being controlling the session
827 * (3) Clears the controlling tty for all processes in the
828 * session group.
829 *
830 * The argument on_exit is set to 1 if called when a process is
831 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
832 *
833 * Locking:
834 * BTM is taken for hysterical raisins, and held when
835 * called from no_tty().
836 * tty_mutex is taken to protect tty
837 * ->siglock is taken to protect ->signal/->sighand
838 * tasklist_lock is taken to walk process list for sessions
839 * ->siglock is taken to protect ->signal/->sighand
840 */
841
842void disassociate_ctty(int on_exit)
843{
844 struct tty_struct *tty;
845
846 if (!current->signal->leader)
847 return;
848
849 tty = get_current_tty();
850 if (tty) {
851 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {
852 tty_vhangup_session(tty);
853 } else {
854 struct pid *tty_pgrp = tty_get_pgrp(tty);
855 if (tty_pgrp) {
856 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
857 if (!on_exit)
858 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
859 put_pid(tty_pgrp);
860 }
861 }
862 tty_kref_put(tty);
863
864 } else if (on_exit) {
865 struct pid *old_pgrp;
866 spin_lock_irq(¤t->sighand->siglock);
867 old_pgrp = current->signal->tty_old_pgrp;
868 current->signal->tty_old_pgrp = NULL;
869 spin_unlock_irq(¤t->sighand->siglock);
870 if (old_pgrp) {
871 kill_pgrp(old_pgrp, SIGHUP, on_exit);
872 kill_pgrp(old_pgrp, SIGCONT, on_exit);
873 put_pid(old_pgrp);
874 }
875 return;
876 }
877
878 spin_lock_irq(¤t->sighand->siglock);
879 put_pid(current->signal->tty_old_pgrp);
880 current->signal->tty_old_pgrp = NULL;
881
882 tty = tty_kref_get(current->signal->tty);
883 if (tty) {
884 unsigned long flags;
885 spin_lock_irqsave(&tty->ctrl_lock, flags);
886 put_pid(tty->session);
887 put_pid(tty->pgrp);
888 tty->session = NULL;
889 tty->pgrp = NULL;
890 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
891 tty_kref_put(tty);
892 } else {
893#ifdef TTY_DEBUG_HANGUP
894 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
895 " = NULL", tty);
896#endif
897 }
898
899 spin_unlock_irq(¤t->sighand->siglock);
900 /* Now clear signal->tty under the lock */
901 read_lock(&tasklist_lock);
902 session_clear_tty(task_session(current));
903 read_unlock(&tasklist_lock);
904}
905
906/**
907 *
908 * no_tty - Ensure the current process does not have a controlling tty
909 */
910void no_tty(void)
911{
912 /* FIXME: Review locking here. The tty_lock never covered any race
913 between a new association and proc_clear_tty but possible we need
914 to protect against this anyway */
915 struct task_struct *tsk = current;
916 disassociate_ctty(0);
917 proc_clear_tty(tsk);
918}
919
920
921/**
922 * stop_tty - propagate flow control
923 * @tty: tty to stop
924 *
925 * Perform flow control to the driver. For PTY/TTY pairs we
926 * must also propagate the TIOCKPKT status. May be called
927 * on an already stopped device and will not re-call the driver
928 * method.
929 *
930 * This functionality is used by both the line disciplines for
931 * halting incoming flow and by the driver. It may therefore be
932 * called from any context, may be under the tty atomic_write_lock
933 * but not always.
934 *
935 * Locking:
936 * Uses the tty control lock internally
937 */
938
939void stop_tty(struct tty_struct *tty)
940{
941 unsigned long flags;
942 spin_lock_irqsave(&tty->ctrl_lock, flags);
943 if (tty->stopped) {
944 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
945 return;
946 }
947 tty->stopped = 1;
948 if (tty->link && tty->link->packet) {
949 tty->ctrl_status &= ~TIOCPKT_START;
950 tty->ctrl_status |= TIOCPKT_STOP;
951 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
952 }
953 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
954 if (tty->ops->stop)
955 (tty->ops->stop)(tty);
956}
957
958EXPORT_SYMBOL(stop_tty);
959
960/**
961 * start_tty - propagate flow control
962 * @tty: tty to start
963 *
964 * Start a tty that has been stopped if at all possible. Perform
965 * any necessary wakeups and propagate the TIOCPKT status. If this
966 * is the tty was previous stopped and is being started then the
967 * driver start method is invoked and the line discipline woken.
968 *
969 * Locking:
970 * ctrl_lock
971 */
972
973void start_tty(struct tty_struct *tty)
974{
975 unsigned long flags;
976 spin_lock_irqsave(&tty->ctrl_lock, flags);
977 if (!tty->stopped || tty->flow_stopped) {
978 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
979 return;
980 }
981 tty->stopped = 0;
982 if (tty->link && tty->link->packet) {
983 tty->ctrl_status &= ~TIOCPKT_STOP;
984 tty->ctrl_status |= TIOCPKT_START;
985 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
986 }
987 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
988 if (tty->ops->start)
989 (tty->ops->start)(tty);
990 /* If we have a running line discipline it may need kicking */
991 tty_wakeup(tty);
992}
993
994EXPORT_SYMBOL(start_tty);
995
996/* We limit tty time update visibility to every 8 seconds or so. */
997static void tty_update_time(struct timespec *time)
998{
999 unsigned long sec = get_seconds() & ~7;
1000 if ((long)(sec - time->tv_sec) > 0)
1001 time->tv_sec = sec;
1002}
1003
1004/**
1005 * tty_read - read method for tty device files
1006 * @file: pointer to tty file
1007 * @buf: user buffer
1008 * @count: size of user buffer
1009 * @ppos: unused
1010 *
1011 * Perform the read system call function on this terminal device. Checks
1012 * for hung up devices before calling the line discipline method.
1013 *
1014 * Locking:
1015 * Locks the line discipline internally while needed. Multiple
1016 * read calls may be outstanding in parallel.
1017 */
1018
1019static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
1020 loff_t *ppos)
1021{
1022 int i;
1023 struct inode *inode = file_inode(file);
1024 struct tty_struct *tty = file_tty(file);
1025 struct tty_ldisc *ld;
1026
1027 if (tty_paranoia_check(tty, inode, "tty_read"))
1028 return -EIO;
1029 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1030 return -EIO;
1031
1032 /* We want to wait for the line discipline to sort out in this
1033 situation */
1034 ld = tty_ldisc_ref_wait(tty);
1035 if (ld->ops->read)
1036 i = (ld->ops->read)(tty, file, buf, count);
1037 else
1038 i = -EIO;
1039 tty_ldisc_deref(ld);
1040
1041 if (i > 0)
1042 tty_update_time(&inode->i_atime);
1043
1044 return i;
1045}
1046
1047void tty_write_unlock(struct tty_struct *tty)
1048 __releases(&tty->atomic_write_lock)
1049{
1050 mutex_unlock(&tty->atomic_write_lock);
1051 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
1052}
1053
1054int tty_write_lock(struct tty_struct *tty, int ndelay)
1055 __acquires(&tty->atomic_write_lock)
1056{
1057 if (!mutex_trylock(&tty->atomic_write_lock)) {
1058 if (ndelay)
1059 return -EAGAIN;
1060 if (mutex_lock_interruptible(&tty->atomic_write_lock))
1061 return -ERESTARTSYS;
1062 }
1063 return 0;
1064}
1065
1066/*
1067 * Split writes up in sane blocksizes to avoid
1068 * denial-of-service type attacks
1069 */
1070static inline ssize_t do_tty_write(
1071 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1072 struct tty_struct *tty,
1073 struct file *file,
1074 const char __user *buf,
1075 size_t count)
1076{
1077 ssize_t ret, written = 0;
1078 unsigned int chunk;
1079
1080 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1081 if (ret < 0)
1082 return ret;
1083
1084 /*
1085 * We chunk up writes into a temporary buffer. This
1086 * simplifies low-level drivers immensely, since they
1087 * don't have locking issues and user mode accesses.
1088 *
1089 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1090 * big chunk-size..
1091 *
1092 * The default chunk-size is 2kB, because the NTTY
1093 * layer has problems with bigger chunks. It will
1094 * claim to be able to handle more characters than
1095 * it actually does.
1096 *
1097 * FIXME: This can probably go away now except that 64K chunks
1098 * are too likely to fail unless switched to vmalloc...
1099 */
1100 chunk = 2048;
1101 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1102 chunk = 65536;
1103 if (count < chunk)
1104 chunk = count;
1105
1106 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1107 if (tty->write_cnt < chunk) {
1108 unsigned char *buf_chunk;
1109
1110 if (chunk < 1024)
1111 chunk = 1024;
1112
1113 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1114 if (!buf_chunk) {
1115 ret = -ENOMEM;
1116 goto out;
1117 }
1118 kfree(tty->write_buf);
1119 tty->write_cnt = chunk;
1120 tty->write_buf = buf_chunk;
1121 }
1122
1123 /* Do the write .. */
1124 for (;;) {
1125 size_t size = count;
1126 if (size > chunk)
1127 size = chunk;
1128 ret = -EFAULT;
1129 if (copy_from_user(tty->write_buf, buf, size))
1130 break;
1131 ret = write(tty, file, tty->write_buf, size);
1132 if (ret <= 0)
1133 break;
1134 written += ret;
1135 buf += ret;
1136 count -= ret;
1137 if (!count)
1138 break;
1139 ret = -ERESTARTSYS;
1140 if (signal_pending(current))
1141 break;
1142 cond_resched();
1143 }
1144 if (written) {
1145 tty_update_time(&file_inode(file)->i_mtime);
1146 ret = written;
1147 }
1148out:
1149 tty_write_unlock(tty);
1150 return ret;
1151}
1152
1153/**
1154 * tty_write_message - write a message to a certain tty, not just the console.
1155 * @tty: the destination tty_struct
1156 * @msg: the message to write
1157 *
1158 * This is used for messages that need to be redirected to a specific tty.
1159 * We don't put it into the syslog queue right now maybe in the future if
1160 * really needed.
1161 *
1162 * We must still hold the BTM and test the CLOSING flag for the moment.
1163 */
1164
1165void tty_write_message(struct tty_struct *tty, char *msg)
1166{
1167 if (tty) {
1168 mutex_lock(&tty->atomic_write_lock);
1169 tty_lock(tty);
1170 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
1171 tty_unlock(tty);
1172 tty->ops->write(tty, msg, strlen(msg));
1173 } else
1174 tty_unlock(tty);
1175 tty_write_unlock(tty);
1176 }
1177 return;
1178}
1179
1180
1181/**
1182 * tty_write - write method for tty device file
1183 * @file: tty file pointer
1184 * @buf: user data to write
1185 * @count: bytes to write
1186 * @ppos: unused
1187 *
1188 * Write data to a tty device via the line discipline.
1189 *
1190 * Locking:
1191 * Locks the line discipline as required
1192 * Writes to the tty driver are serialized by the atomic_write_lock
1193 * and are then processed in chunks to the device. The line discipline
1194 * write method will not be invoked in parallel for each device.
1195 */
1196
1197static ssize_t tty_write(struct file *file, const char __user *buf,
1198 size_t count, loff_t *ppos)
1199{
1200 struct tty_struct *tty = file_tty(file);
1201 struct tty_ldisc *ld;
1202 ssize_t ret;
1203
1204 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
1205 return -EIO;
1206 if (!tty || !tty->ops->write ||
1207 (test_bit(TTY_IO_ERROR, &tty->flags)))
1208 return -EIO;
1209 /* Short term debug to catch buggy drivers */
1210 if (tty->ops->write_room == NULL)
1211 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1212 tty->driver->name);
1213 ld = tty_ldisc_ref_wait(tty);
1214 if (!ld->ops->write)
1215 ret = -EIO;
1216 else
1217 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
1218 tty_ldisc_deref(ld);
1219 return ret;
1220}
1221
1222ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1223 size_t count, loff_t *ppos)
1224{
1225 struct file *p = NULL;
1226
1227 spin_lock(&redirect_lock);
1228 if (redirect)
1229 p = get_file(redirect);
1230 spin_unlock(&redirect_lock);
1231
1232 if (p) {
1233 ssize_t res;
1234 res = vfs_write(p, buf, count, &p->f_pos);
1235 fput(p);
1236 return res;
1237 }
1238 return tty_write(file, buf, count, ppos);
1239}
1240
1241static char ptychar[] = "pqrstuvwxyzabcde";
1242
1243/**
1244 * pty_line_name - generate name for a pty
1245 * @driver: the tty driver in use
1246 * @index: the minor number
1247 * @p: output buffer of at least 6 bytes
1248 *
1249 * Generate a name from a driver reference and write it to the output
1250 * buffer.
1251 *
1252 * Locking: None
1253 */
1254static void pty_line_name(struct tty_driver *driver, int index, char *p)
1255{
1256 int i = index + driver->name_base;
1257 /* ->name is initialized to "ttyp", but "tty" is expected */
1258 sprintf(p, "%s%c%x",
1259 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1260 ptychar[i >> 4 & 0xf], i & 0xf);
1261}
1262
1263/**
1264 * tty_line_name - generate name for a tty
1265 * @driver: the tty driver in use
1266 * @index: the minor number
1267 * @p: output buffer of at least 7 bytes
1268 *
1269 * Generate a name from a driver reference and write it to the output
1270 * buffer.
1271 *
1272 * Locking: None
1273 */
1274static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
1275{
1276 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
1277 return sprintf(p, "%s", driver->name);
1278 else
1279 return sprintf(p, "%s%d", driver->name,
1280 index + driver->name_base);
1281}
1282
1283/**
1284 * tty_driver_lookup_tty() - find an existing tty, if any
1285 * @driver: the driver for the tty
1286 * @idx: the minor number
1287 *
1288 * Return the tty, if found or ERR_PTR() otherwise.
1289 *
1290 * Locking: tty_mutex must be held. If tty is found, the mutex must
1291 * be held until the 'fast-open' is also done. Will change once we
1292 * have refcounting in the driver and per driver locking
1293 */
1294static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
1295 struct inode *inode, int idx)
1296{
1297 if (driver->ops->lookup)
1298 return driver->ops->lookup(driver, inode, idx);
1299
1300 return driver->ttys[idx];
1301}
1302
1303/**
1304 * tty_init_termios - helper for termios setup
1305 * @tty: the tty to set up
1306 *
1307 * Initialise the termios structures for this tty. Thus runs under
1308 * the tty_mutex currently so we can be relaxed about ordering.
1309 */
1310
1311int tty_init_termios(struct tty_struct *tty)
1312{
1313 struct ktermios *tp;
1314 int idx = tty->index;
1315
1316 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1317 tty->termios = tty->driver->init_termios;
1318 else {
1319 /* Check for lazy saved data */
1320 tp = tty->driver->termios[idx];
1321 if (tp != NULL)
1322 tty->termios = *tp;
1323 else
1324 tty->termios = tty->driver->init_termios;
1325 }
1326 /* Compatibility until drivers always set this */
1327 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1328 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
1329 return 0;
1330}
1331EXPORT_SYMBOL_GPL(tty_init_termios);
1332
1333int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1334{
1335 int ret = tty_init_termios(tty);
1336 if (ret)
1337 return ret;
1338
1339 tty_driver_kref_get(driver);
1340 tty->count++;
1341 driver->ttys[tty->index] = tty;
1342 return 0;
1343}
1344EXPORT_SYMBOL_GPL(tty_standard_install);
1345
1346/**
1347 * tty_driver_install_tty() - install a tty entry in the driver
1348 * @driver: the driver for the tty
1349 * @tty: the tty
1350 *
1351 * Install a tty object into the driver tables. The tty->index field
1352 * will be set by the time this is called. This method is responsible
1353 * for ensuring any need additional structures are allocated and
1354 * configured.
1355 *
1356 * Locking: tty_mutex for now
1357 */
1358static int tty_driver_install_tty(struct tty_driver *driver,
1359 struct tty_struct *tty)
1360{
1361 return driver->ops->install ? driver->ops->install(driver, tty) :
1362 tty_standard_install(driver, tty);
1363}
1364
1365/**
1366 * tty_driver_remove_tty() - remove a tty from the driver tables
1367 * @driver: the driver for the tty
1368 * @idx: the minor number
1369 *
1370 * Remvoe a tty object from the driver tables. The tty->index field
1371 * will be set by the time this is called.
1372 *
1373 * Locking: tty_mutex for now
1374 */
1375void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
1376{
1377 if (driver->ops->remove)
1378 driver->ops->remove(driver, tty);
1379 else
1380 driver->ttys[tty->index] = NULL;
1381}
1382
1383/*
1384 * tty_reopen() - fast re-open of an open tty
1385 * @tty - the tty to open
1386 *
1387 * Return 0 on success, -errno on error.
1388 *
1389 * Locking: tty_mutex must be held from the time the tty was found
1390 * till this open completes.
1391 */
1392static int tty_reopen(struct tty_struct *tty)
1393{
1394 struct tty_driver *driver = tty->driver;
1395
1396 if (test_bit(TTY_CLOSING, &tty->flags) ||
1397 test_bit(TTY_HUPPING, &tty->flags))
1398 return -EIO;
1399
1400 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1401 driver->subtype == PTY_TYPE_MASTER) {
1402 /*
1403 * special case for PTY masters: only one open permitted,
1404 * and the slave side open count is incremented as well.
1405 */
1406 if (tty->count)
1407 return -EIO;
1408
1409 tty->link->count++;
1410 }
1411 tty->count++;
1412
1413 WARN_ON(!tty->ldisc);
1414
1415 return 0;
1416}
1417
1418/**
1419 * tty_init_dev - initialise a tty device
1420 * @driver: tty driver we are opening a device on
1421 * @idx: device index
1422 * @ret_tty: returned tty structure
1423 *
1424 * Prepare a tty device. This may not be a "new" clean device but
1425 * could also be an active device. The pty drivers require special
1426 * handling because of this.
1427 *
1428 * Locking:
1429 * The function is called under the tty_mutex, which
1430 * protects us from the tty struct or driver itself going away.
1431 *
1432 * On exit the tty device has the line discipline attached and
1433 * a reference count of 1. If a pair was created for pty/tty use
1434 * and the other was a pty master then it too has a reference count of 1.
1435 *
1436 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1437 * failed open. The new code protects the open with a mutex, so it's
1438 * really quite straightforward. The mutex locking can probably be
1439 * relaxed for the (most common) case of reopening a tty.
1440 */
1441
1442struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
1443{
1444 struct tty_struct *tty;
1445 int retval;
1446
1447 /*
1448 * First time open is complex, especially for PTY devices.
1449 * This code guarantees that either everything succeeds and the
1450 * TTY is ready for operation, or else the table slots are vacated
1451 * and the allocated memory released. (Except that the termios
1452 * and locked termios may be retained.)
1453 */
1454
1455 if (!try_module_get(driver->owner))
1456 return ERR_PTR(-ENODEV);
1457
1458 tty = alloc_tty_struct();
1459 if (!tty) {
1460 retval = -ENOMEM;
1461 goto err_module_put;
1462 }
1463 initialize_tty_struct(tty, driver, idx);
1464
1465 tty_lock(tty);
1466 retval = tty_driver_install_tty(driver, tty);
1467 if (retval < 0)
1468 goto err_deinit_tty;
1469
1470 if (!tty->port)
1471 tty->port = driver->ports[idx];
1472
1473 WARN_RATELIMIT(!tty->port,
1474 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1475 __func__, tty->driver->name);
1476
1477 tty->port->itty = tty;
1478
1479 /*
1480 * Structures all installed ... call the ldisc open routines.
1481 * If we fail here just call release_tty to clean up. No need
1482 * to decrement the use counts, as release_tty doesn't care.
1483 */
1484 retval = tty_ldisc_setup(tty, tty->link);
1485 if (retval)
1486 goto err_release_tty;
1487 /* Return the tty locked so that it cannot vanish under the caller */
1488 return tty;
1489
1490err_deinit_tty:
1491 tty_unlock(tty);
1492 deinitialize_tty_struct(tty);
1493 free_tty_struct(tty);
1494err_module_put:
1495 module_put(driver->owner);
1496 return ERR_PTR(retval);
1497
1498 /* call the tty release_tty routine to clean out this slot */
1499err_release_tty:
1500 tty_unlock(tty);
1501 printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
1502 "clearing slot %d\n", idx);
1503 release_tty(tty, idx);
1504 return ERR_PTR(retval);
1505}
1506
1507void tty_free_termios(struct tty_struct *tty)
1508{
1509 struct ktermios *tp;
1510 int idx = tty->index;
1511
1512 /* If the port is going to reset then it has no termios to save */
1513 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1514 return;
1515
1516 /* Stash the termios data */
1517 tp = tty->driver->termios[idx];
1518 if (tp == NULL) {
1519 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1520 if (tp == NULL) {
1521 pr_warn("tty: no memory to save termios state.\n");
1522 return;
1523 }
1524 tty->driver->termios[idx] = tp;
1525 }
1526 *tp = tty->termios;
1527}
1528EXPORT_SYMBOL(tty_free_termios);
1529
1530/**
1531 * tty_flush_works - flush all works of a tty
1532 * @tty: tty device to flush works for
1533 *
1534 * Sync flush all works belonging to @tty.
1535 */
1536static void tty_flush_works(struct tty_struct *tty)
1537{
1538 flush_work(&tty->SAK_work);
1539 flush_work(&tty->hangup_work);
1540}
1541
1542/**
1543 * release_one_tty - release tty structure memory
1544 * @kref: kref of tty we are obliterating
1545 *
1546 * Releases memory associated with a tty structure, and clears out the
1547 * driver table slots. This function is called when a device is no longer
1548 * in use. It also gets called when setup of a device fails.
1549 *
1550 * Locking:
1551 * takes the file list lock internally when working on the list
1552 * of ttys that the driver keeps.
1553 *
1554 * This method gets called from a work queue so that the driver private
1555 * cleanup ops can sleep (needed for USB at least)
1556 */
1557static void release_one_tty(struct work_struct *work)
1558{
1559 struct tty_struct *tty =
1560 container_of(work, struct tty_struct, hangup_work);
1561 struct tty_driver *driver = tty->driver;
1562
1563 if (tty->ops->cleanup)
1564 tty->ops->cleanup(tty);
1565
1566 tty->magic = 0;
1567 tty_driver_kref_put(driver);
1568 module_put(driver->owner);
1569
1570 spin_lock(&tty_files_lock);
1571 list_del_init(&tty->tty_files);
1572 spin_unlock(&tty_files_lock);
1573
1574 put_pid(tty->pgrp);
1575 put_pid(tty->session);
1576 free_tty_struct(tty);
1577}
1578
1579static void queue_release_one_tty(struct kref *kref)
1580{
1581 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1582
1583 /* The hangup queue is now free so we can reuse it rather than
1584 waste a chunk of memory for each port */
1585 INIT_WORK(&tty->hangup_work, release_one_tty);
1586 schedule_work(&tty->hangup_work);
1587}
1588
1589/**
1590 * tty_kref_put - release a tty kref
1591 * @tty: tty device
1592 *
1593 * Release a reference to a tty device and if need be let the kref
1594 * layer destruct the object for us
1595 */
1596
1597void tty_kref_put(struct tty_struct *tty)
1598{
1599 if (tty)
1600 kref_put(&tty->kref, queue_release_one_tty);
1601}
1602EXPORT_SYMBOL(tty_kref_put);
1603
1604/**
1605 * release_tty - release tty structure memory
1606 *
1607 * Release both @tty and a possible linked partner (think pty pair),
1608 * and decrement the refcount of the backing module.
1609 *
1610 * Locking:
1611 * tty_mutex
1612 * takes the file list lock internally when working on the list
1613 * of ttys that the driver keeps.
1614 *
1615 */
1616static void release_tty(struct tty_struct *tty, int idx)
1617{
1618 /* This should always be true but check for the moment */
1619 WARN_ON(tty->index != idx);
1620 WARN_ON(!mutex_is_locked(&tty_mutex));
1621 if (tty->ops->shutdown)
1622 tty->ops->shutdown(tty);
1623 tty_free_termios(tty);
1624 tty_driver_remove_tty(tty->driver, tty);
1625 tty->port->itty = NULL;
1626 if (tty->link)
1627 tty->link->port->itty = NULL;
1628 cancel_work_sync(&tty->port->buf.work);
1629
1630 if (tty->link)
1631 tty_kref_put(tty->link);
1632 tty_kref_put(tty);
1633}
1634
1635/**
1636 * tty_release_checks - check a tty before real release
1637 * @tty: tty to check
1638 * @o_tty: link of @tty (if any)
1639 * @idx: index of the tty
1640 *
1641 * Performs some paranoid checking before true release of the @tty.
1642 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1643 */
1644static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,
1645 int idx)
1646{
1647#ifdef TTY_PARANOIA_CHECK
1648 if (idx < 0 || idx >= tty->driver->num) {
1649 printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1650 __func__, tty->name);
1651 return -1;
1652 }
1653
1654 /* not much to check for devpts */
1655 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1656 return 0;
1657
1658 if (tty != tty->driver->ttys[idx]) {
1659 printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1660 __func__, idx, tty->name);
1661 return -1;
1662 }
1663 if (tty->driver->other) {
1664 if (o_tty != tty->driver->other->ttys[idx]) {
1665 printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1666 __func__, idx, tty->name);
1667 return -1;
1668 }
1669 if (o_tty->link != tty) {
1670 printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
1671 return -1;
1672 }
1673 }
1674#endif
1675 return 0;
1676}
1677
1678/**
1679 * tty_release - vfs callback for close
1680 * @inode: inode of tty
1681 * @filp: file pointer for handle to tty
1682 *
1683 * Called the last time each file handle is closed that references
1684 * this tty. There may however be several such references.
1685 *
1686 * Locking:
1687 * Takes bkl. See tty_release_dev
1688 *
1689 * Even releasing the tty structures is a tricky business.. We have
1690 * to be very careful that the structures are all released at the
1691 * same time, as interrupts might otherwise get the wrong pointers.
1692 *
1693 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1694 * lead to double frees or releasing memory still in use.
1695 */
1696
1697int tty_release(struct inode *inode, struct file *filp)
1698{
1699 struct tty_struct *tty = file_tty(filp);
1700 struct tty_struct *o_tty;
1701 int pty_master, tty_closing, o_tty_closing, do_sleep;
1702 int idx;
1703 char buf[64];
1704
1705 if (tty_paranoia_check(tty, inode, __func__))
1706 return 0;
1707
1708 tty_lock(tty);
1709 check_tty_count(tty, __func__);
1710
1711 __tty_fasync(-1, filp, 0);
1712
1713 idx = tty->index;
1714 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1715 tty->driver->subtype == PTY_TYPE_MASTER);
1716 /* Review: parallel close */
1717 o_tty = tty->link;
1718
1719 if (tty_release_checks(tty, o_tty, idx)) {
1720 tty_unlock(tty);
1721 return 0;
1722 }
1723
1724#ifdef TTY_DEBUG_HANGUP
1725 printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1726 tty_name(tty, buf), tty->count);
1727#endif
1728
1729 if (tty->ops->close)
1730 tty->ops->close(tty, filp);
1731
1732 tty_unlock(tty);
1733 /*
1734 * Sanity check: if tty->count is going to zero, there shouldn't be
1735 * any waiters on tty->read_wait or tty->write_wait. We test the
1736 * wait queues and kick everyone out _before_ actually starting to
1737 * close. This ensures that we won't block while releasing the tty
1738 * structure.
1739 *
1740 * The test for the o_tty closing is necessary, since the master and
1741 * slave sides may close in any order. If the slave side closes out
1742 * first, its count will be one, since the master side holds an open.
1743 * Thus this test wouldn't be triggered at the time the slave closes,
1744 * so we do it now.
1745 *
1746 * Note that it's possible for the tty to be opened again while we're
1747 * flushing out waiters. By recalculating the closing flags before
1748 * each iteration we avoid any problems.
1749 */
1750 while (1) {
1751 /* Guard against races with tty->count changes elsewhere and
1752 opens on /dev/tty */
1753
1754 mutex_lock(&tty_mutex);
1755 tty_lock_pair(tty, o_tty);
1756 tty_closing = tty->count <= 1;
1757 o_tty_closing = o_tty &&
1758 (o_tty->count <= (pty_master ? 1 : 0));
1759 do_sleep = 0;
1760
1761 if (tty_closing) {
1762 if (waitqueue_active(&tty->read_wait)) {
1763 wake_up_poll(&tty->read_wait, POLLIN);
1764 do_sleep++;
1765 }
1766 if (waitqueue_active(&tty->write_wait)) {
1767 wake_up_poll(&tty->write_wait, POLLOUT);
1768 do_sleep++;
1769 }
1770 }
1771 if (o_tty_closing) {
1772 if (waitqueue_active(&o_tty->read_wait)) {
1773 wake_up_poll(&o_tty->read_wait, POLLIN);
1774 do_sleep++;
1775 }
1776 if (waitqueue_active(&o_tty->write_wait)) {
1777 wake_up_poll(&o_tty->write_wait, POLLOUT);
1778 do_sleep++;
1779 }
1780 }
1781 if (!do_sleep)
1782 break;
1783
1784 printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1785 __func__, tty_name(tty, buf));
1786 tty_unlock_pair(tty, o_tty);
1787 mutex_unlock(&tty_mutex);
1788 schedule();
1789 }
1790
1791 /*
1792 * The closing flags are now consistent with the open counts on
1793 * both sides, and we've completed the last operation that could
1794 * block, so it's safe to proceed with closing.
1795 *
1796 * We must *not* drop the tty_mutex until we ensure that a further
1797 * entry into tty_open can not pick up this tty.
1798 */
1799 if (pty_master) {
1800 if (--o_tty->count < 0) {
1801 printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1802 __func__, o_tty->count, tty_name(o_tty, buf));
1803 o_tty->count = 0;
1804 }
1805 }
1806 if (--tty->count < 0) {
1807 printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1808 __func__, tty->count, tty_name(tty, buf));
1809 tty->count = 0;
1810 }
1811
1812 /*
1813 * We've decremented tty->count, so we need to remove this file
1814 * descriptor off the tty->tty_files list; this serves two
1815 * purposes:
1816 * - check_tty_count sees the correct number of file descriptors
1817 * associated with this tty.
1818 * - do_tty_hangup no longer sees this file descriptor as
1819 * something that needs to be handled for hangups.
1820 */
1821 tty_del_file(filp);
1822
1823 /*
1824 * Perform some housekeeping before deciding whether to return.
1825 *
1826 * Set the TTY_CLOSING flag if this was the last open. In the
1827 * case of a pty we may have to wait around for the other side
1828 * to close, and TTY_CLOSING makes sure we can't be reopened.
1829 */
1830 if (tty_closing)
1831 set_bit(TTY_CLOSING, &tty->flags);
1832 if (o_tty_closing)
1833 set_bit(TTY_CLOSING, &o_tty->flags);
1834
1835 /*
1836 * If _either_ side is closing, make sure there aren't any
1837 * processes that still think tty or o_tty is their controlling
1838 * tty.
1839 */
1840 if (tty_closing || o_tty_closing) {
1841 read_lock(&tasklist_lock);
1842 session_clear_tty(tty->session);
1843 if (o_tty)
1844 session_clear_tty(o_tty->session);
1845 read_unlock(&tasklist_lock);
1846 }
1847
1848 mutex_unlock(&tty_mutex);
1849 tty_unlock_pair(tty, o_tty);
1850 /* At this point the TTY_CLOSING flag should ensure a dead tty
1851 cannot be re-opened by a racing opener */
1852
1853 /* check whether both sides are closing ... */
1854 if (!tty_closing || (o_tty && !o_tty_closing))
1855 return 0;
1856
1857#ifdef TTY_DEBUG_HANGUP
1858 printk(KERN_DEBUG "%s: %s: final close\n", __func__, tty_name(tty, buf));
1859#endif
1860 /*
1861 * Ask the line discipline code to release its structures
1862 */
1863 tty_ldisc_release(tty, o_tty);
1864
1865 /* Wait for pending work before tty destruction commmences */
1866 tty_flush_works(tty);
1867 if (o_tty)
1868 tty_flush_works(o_tty);
1869
1870#ifdef TTY_DEBUG_HANGUP
1871 printk(KERN_DEBUG "%s: %s: freeing structure...\n", __func__, tty_name(tty, buf));
1872#endif
1873 /*
1874 * The release_tty function takes care of the details of clearing
1875 * the slots and preserving the termios structure. The tty_unlock_pair
1876 * should be safe as we keep a kref while the tty is locked (so the
1877 * unlock never unlocks a freed tty).
1878 */
1879 mutex_lock(&tty_mutex);
1880 release_tty(tty, idx);
1881 mutex_unlock(&tty_mutex);
1882
1883 return 0;
1884}
1885
1886/**
1887 * tty_open_current_tty - get tty of current task for open
1888 * @device: device number
1889 * @filp: file pointer to tty
1890 * @return: tty of the current task iff @device is /dev/tty
1891 *
1892 * We cannot return driver and index like for the other nodes because
1893 * devpts will not work then. It expects inodes to be from devpts FS.
1894 *
1895 * We need to move to returning a refcounted object from all the lookup
1896 * paths including this one.
1897 */
1898static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1899{
1900 struct tty_struct *tty;
1901
1902 if (device != MKDEV(TTYAUX_MAJOR, 0))
1903 return NULL;
1904
1905 tty = get_current_tty();
1906 if (!tty)
1907 return ERR_PTR(-ENXIO);
1908
1909 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1910 /* noctty = 1; */
1911 tty_kref_put(tty);
1912 /* FIXME: we put a reference and return a TTY! */
1913 /* This is only safe because the caller holds tty_mutex */
1914 return tty;
1915}
1916
1917/**
1918 * tty_lookup_driver - lookup a tty driver for a given device file
1919 * @device: device number
1920 * @filp: file pointer to tty
1921 * @noctty: set if the device should not become a controlling tty
1922 * @index: index for the device in the @return driver
1923 * @return: driver for this inode (with increased refcount)
1924 *
1925 * If @return is not erroneous, the caller is responsible to decrement the
1926 * refcount by tty_driver_kref_put.
1927 *
1928 * Locking: tty_mutex protects get_tty_driver
1929 */
1930static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1931 int *noctty, int *index)
1932{
1933 struct tty_driver *driver;
1934
1935 switch (device) {
1936#ifdef CONFIG_VT
1937 case MKDEV(TTY_MAJOR, 0): {
1938 extern struct tty_driver *console_driver;
1939 driver = tty_driver_kref_get(console_driver);
1940 *index = fg_console;
1941 *noctty = 1;
1942 break;
1943 }
1944#endif
1945 case MKDEV(TTYAUX_MAJOR, 1): {
1946 struct tty_driver *console_driver = console_device(index);
1947 if (console_driver) {
1948 driver = tty_driver_kref_get(console_driver);
1949 if (driver) {
1950 /* Don't let /dev/console block */
1951 filp->f_flags |= O_NONBLOCK;
1952 *noctty = 1;
1953 break;
1954 }
1955 }
1956 return ERR_PTR(-ENODEV);
1957 }
1958 default:
1959 driver = get_tty_driver(device, index);
1960 if (!driver)
1961 return ERR_PTR(-ENODEV);
1962 break;
1963 }
1964 return driver;
1965}
1966
1967/**
1968 * tty_open - open a tty device
1969 * @inode: inode of device file
1970 * @filp: file pointer to tty
1971 *
1972 * tty_open and tty_release keep up the tty count that contains the
1973 * number of opens done on a tty. We cannot use the inode-count, as
1974 * different inodes might point to the same tty.
1975 *
1976 * Open-counting is needed for pty masters, as well as for keeping
1977 * track of serial lines: DTR is dropped when the last close happens.
1978 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1979 *
1980 * The termios state of a pty is reset on first open so that
1981 * settings don't persist across reuse.
1982 *
1983 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
1984 * tty->count should protect the rest.
1985 * ->siglock protects ->signal/->sighand
1986 *
1987 * Note: the tty_unlock/lock cases without a ref are only safe due to
1988 * tty_mutex
1989 */
1990
1991static int tty_open(struct inode *inode, struct file *filp)
1992{
1993 struct tty_struct *tty;
1994 int noctty, retval;
1995 struct tty_driver *driver = NULL;
1996 int index;
1997 dev_t device = inode->i_rdev;
1998 unsigned saved_flags = filp->f_flags;
1999
2000 nonseekable_open(inode, filp);
2001
2002retry_open:
2003 retval = tty_alloc_file(filp);
2004 if (retval)
2005 return -ENOMEM;
2006
2007 noctty = filp->f_flags & O_NOCTTY;
2008 index = -1;
2009 retval = 0;
2010
2011 mutex_lock(&tty_mutex);
2012 /* This is protected by the tty_mutex */
2013 tty = tty_open_current_tty(device, filp);
2014 if (IS_ERR(tty)) {
2015 retval = PTR_ERR(tty);
2016 goto err_unlock;
2017 } else if (!tty) {
2018 driver = tty_lookup_driver(device, filp, &noctty, &index);
2019 if (IS_ERR(driver)) {
2020 retval = PTR_ERR(driver);
2021 goto err_unlock;
2022 }
2023
2024 /* check whether we're reopening an existing tty */
2025 tty = tty_driver_lookup_tty(driver, inode, index);
2026 if (IS_ERR(tty)) {
2027 retval = PTR_ERR(tty);
2028 goto err_unlock;
2029 }
2030 }
2031
2032 if (tty) {
2033 tty_lock(tty);
2034 retval = tty_reopen(tty);
2035 if (retval < 0) {
2036 tty_unlock(tty);
2037 tty = ERR_PTR(retval);
2038 }
2039 } else /* Returns with the tty_lock held for now */
2040 tty = tty_init_dev(driver, index);
2041
2042 mutex_unlock(&tty_mutex);
2043 if (driver)
2044 tty_driver_kref_put(driver);
2045 if (IS_ERR(tty)) {
2046 retval = PTR_ERR(tty);
2047 goto err_file;
2048 }
2049
2050 tty_add_file(tty, filp);
2051
2052 check_tty_count(tty, __func__);
2053 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2054 tty->driver->subtype == PTY_TYPE_MASTER)
2055 noctty = 1;
2056#ifdef TTY_DEBUG_HANGUP
2057 printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
2058#endif
2059 if (tty->ops->open)
2060 retval = tty->ops->open(tty, filp);
2061 else
2062 retval = -ENODEV;
2063 filp->f_flags = saved_flags;
2064
2065 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
2066 !capable(CAP_SYS_ADMIN))
2067 retval = -EBUSY;
2068
2069 if (retval) {
2070#ifdef TTY_DEBUG_HANGUP
2071 printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
2072 retval, tty->name);
2073#endif
2074 tty_unlock(tty); /* need to call tty_release without BTM */
2075 tty_release(inode, filp);
2076 if (retval != -ERESTARTSYS)
2077 return retval;
2078
2079 if (signal_pending(current))
2080 return retval;
2081
2082 schedule();
2083 /*
2084 * Need to reset f_op in case a hangup happened.
2085 */
2086 if (filp->f_op == &hung_up_tty_fops)
2087 filp->f_op = &tty_fops;
2088 goto retry_open;
2089 }
2090 clear_bit(TTY_HUPPED, &tty->flags);
2091 tty_unlock(tty);
2092
2093
2094 mutex_lock(&tty_mutex);
2095 tty_lock(tty);
2096 spin_lock_irq(¤t->sighand->siglock);
2097 if (!noctty &&
2098 current->signal->leader &&
2099 !current->signal->tty &&
2100 tty->session == NULL)
2101 __proc_set_tty(current, tty);
2102 spin_unlock_irq(¤t->sighand->siglock);
2103 tty_unlock(tty);
2104 mutex_unlock(&tty_mutex);
2105 return 0;
2106err_unlock:
2107 mutex_unlock(&tty_mutex);
2108 /* after locks to avoid deadlock */
2109 if (!IS_ERR_OR_NULL(driver))
2110 tty_driver_kref_put(driver);
2111err_file:
2112 tty_free_file(filp);
2113 return retval;
2114}
2115
2116
2117
2118/**
2119 * tty_poll - check tty status
2120 * @filp: file being polled
2121 * @wait: poll wait structures to update
2122 *
2123 * Call the line discipline polling method to obtain the poll
2124 * status of the device.
2125 *
2126 * Locking: locks called line discipline but ldisc poll method
2127 * may be re-entered freely by other callers.
2128 */
2129
2130static unsigned int tty_poll(struct file *filp, poll_table *wait)
2131{
2132 struct tty_struct *tty = file_tty(filp);
2133 struct tty_ldisc *ld;
2134 int ret = 0;
2135
2136 if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
2137 return 0;
2138
2139 ld = tty_ldisc_ref_wait(tty);
2140 if (ld->ops->poll)
2141 ret = (ld->ops->poll)(tty, filp, wait);
2142 tty_ldisc_deref(ld);
2143 return ret;
2144}
2145
2146static int __tty_fasync(int fd, struct file *filp, int on)
2147{
2148 struct tty_struct *tty = file_tty(filp);
2149 struct tty_ldisc *ldisc;
2150 unsigned long flags;
2151 int retval = 0;
2152
2153 if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
2154 goto out;
2155
2156 retval = fasync_helper(fd, filp, on, &tty->fasync);
2157 if (retval <= 0)
2158 goto out;
2159
2160 ldisc = tty_ldisc_ref(tty);
2161 if (ldisc) {
2162 if (ldisc->ops->fasync)
2163 ldisc->ops->fasync(tty, on);
2164 tty_ldisc_deref(ldisc);
2165 }
2166
2167 if (on) {
2168 enum pid_type type;
2169 struct pid *pid;
2170
2171 spin_lock_irqsave(&tty->ctrl_lock, flags);
2172 if (tty->pgrp) {
2173 pid = tty->pgrp;
2174 type = PIDTYPE_PGID;
2175 } else {
2176 pid = task_pid(current);
2177 type = PIDTYPE_PID;
2178 }
2179 get_pid(pid);
2180 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2181 retval = __f_setown(filp, pid, type, 0);
2182 put_pid(pid);
2183 }
2184out:
2185 return retval;
2186}
2187
2188static int tty_fasync(int fd, struct file *filp, int on)
2189{
2190 struct tty_struct *tty = file_tty(filp);
2191 int retval;
2192
2193 tty_lock(tty);
2194 retval = __tty_fasync(fd, filp, on);
2195 tty_unlock(tty);
2196
2197 return retval;
2198}
2199
2200/**
2201 * tiocsti - fake input character
2202 * @tty: tty to fake input into
2203 * @p: pointer to character
2204 *
2205 * Fake input to a tty device. Does the necessary locking and
2206 * input management.
2207 *
2208 * FIXME: does not honour flow control ??
2209 *
2210 * Locking:
2211 * Called functions take tty_ldiscs_lock
2212 * current->signal->tty check is safe without locks
2213 *
2214 * FIXME: may race normal receive processing
2215 */
2216
2217static int tiocsti(struct tty_struct *tty, char __user *p)
2218{
2219 char ch, mbz = 0;
2220 struct tty_ldisc *ld;
2221
2222 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2223 return -EPERM;
2224 if (get_user(ch, p))
2225 return -EFAULT;
2226 tty_audit_tiocsti(tty, ch);
2227 ld = tty_ldisc_ref_wait(tty);
2228 ld->ops->receive_buf(tty, &ch, &mbz, 1);
2229 tty_ldisc_deref(ld);
2230 return 0;
2231}
2232
2233/**
2234 * tiocgwinsz - implement window query ioctl
2235 * @tty; tty
2236 * @arg: user buffer for result
2237 *
2238 * Copies the kernel idea of the window size into the user buffer.
2239 *
2240 * Locking: tty->winsize_mutex is taken to ensure the winsize data
2241 * is consistent.
2242 */
2243
2244static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
2245{
2246 int err;
2247
2248 mutex_lock(&tty->winsize_mutex);
2249 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2250 mutex_unlock(&tty->winsize_mutex);
2251
2252 return err ? -EFAULT: 0;
2253}
2254
2255/**
2256 * tty_do_resize - resize event
2257 * @tty: tty being resized
2258 * @rows: rows (character)
2259 * @cols: cols (character)
2260 *
2261 * Update the termios variables and send the necessary signals to
2262 * peform a terminal resize correctly
2263 */
2264
2265int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
2266{
2267 struct pid *pgrp;
2268 unsigned long flags;
2269
2270 /* Lock the tty */
2271 mutex_lock(&tty->winsize_mutex);
2272 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2273 goto done;
2274 /* Get the PID values and reference them so we can
2275 avoid holding the tty ctrl lock while sending signals */
2276 spin_lock_irqsave(&tty->ctrl_lock, flags);
2277 pgrp = get_pid(tty->pgrp);
2278 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2279
2280 if (pgrp)
2281 kill_pgrp(pgrp, SIGWINCH, 1);
2282 put_pid(pgrp);
2283
2284 tty->winsize = *ws;
2285done:
2286 mutex_unlock(&tty->winsize_mutex);
2287 return 0;
2288}
2289EXPORT_SYMBOL(tty_do_resize);
2290
2291/**
2292 * tiocswinsz - implement window size set ioctl
2293 * @tty; tty side of tty
2294 * @arg: user buffer for result
2295 *
2296 * Copies the user idea of the window size to the kernel. Traditionally
2297 * this is just advisory information but for the Linux console it
2298 * actually has driver level meaning and triggers a VC resize.
2299 *
2300 * Locking:
2301 * Driver dependent. The default do_resize method takes the
2302 * tty termios mutex and ctrl_lock. The console takes its own lock
2303 * then calls into the default method.
2304 */
2305
2306static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
2307{
2308 struct winsize tmp_ws;
2309 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2310 return -EFAULT;
2311
2312 if (tty->ops->resize)
2313 return tty->ops->resize(tty, &tmp_ws);
2314 else
2315 return tty_do_resize(tty, &tmp_ws);
2316}
2317
2318/**
2319 * tioccons - allow admin to move logical console
2320 * @file: the file to become console
2321 *
2322 * Allow the administrator to move the redirected console device
2323 *
2324 * Locking: uses redirect_lock to guard the redirect information
2325 */
2326
2327static int tioccons(struct file *file)
2328{
2329 if (!capable(CAP_SYS_ADMIN))
2330 return -EPERM;
2331 if (file->f_op->write == redirected_tty_write) {
2332 struct file *f;
2333 spin_lock(&redirect_lock);
2334 f = redirect;
2335 redirect = NULL;
2336 spin_unlock(&redirect_lock);
2337 if (f)
2338 fput(f);
2339 return 0;
2340 }
2341 spin_lock(&redirect_lock);
2342 if (redirect) {
2343 spin_unlock(&redirect_lock);
2344 return -EBUSY;
2345 }
2346 redirect = get_file(file);
2347 spin_unlock(&redirect_lock);
2348 return 0;
2349}
2350
2351/**
2352 * fionbio - non blocking ioctl
2353 * @file: file to set blocking value
2354 * @p: user parameter
2355 *
2356 * Historical tty interfaces had a blocking control ioctl before
2357 * the generic functionality existed. This piece of history is preserved
2358 * in the expected tty API of posix OS's.
2359 *
2360 * Locking: none, the open file handle ensures it won't go away.
2361 */
2362
2363static int fionbio(struct file *file, int __user *p)
2364{
2365 int nonblock;
2366
2367 if (get_user(nonblock, p))
2368 return -EFAULT;
2369
2370 spin_lock(&file->f_lock);
2371 if (nonblock)
2372 file->f_flags |= O_NONBLOCK;
2373 else
2374 file->f_flags &= ~O_NONBLOCK;
2375 spin_unlock(&file->f_lock);
2376 return 0;
2377}
2378
2379/**
2380 * tiocsctty - set controlling tty
2381 * @tty: tty structure
2382 * @arg: user argument
2383 *
2384 * This ioctl is used to manage job control. It permits a session
2385 * leader to set this tty as the controlling tty for the session.
2386 *
2387 * Locking:
2388 * Takes tty_mutex() to protect tty instance
2389 * Takes tasklist_lock internally to walk sessions
2390 * Takes ->siglock() when updating signal->tty
2391 */
2392
2393static int tiocsctty(struct tty_struct *tty, int arg)
2394{
2395 int ret = 0;
2396 if (current->signal->leader && (task_session(current) == tty->session))
2397 return ret;
2398
2399 mutex_lock(&tty_mutex);
2400 /*
2401 * The process must be a session leader and
2402 * not have a controlling tty already.
2403 */
2404 if (!current->signal->leader || current->signal->tty) {
2405 ret = -EPERM;
2406 goto unlock;
2407 }
2408
2409 if (tty->session) {
2410 /*
2411 * This tty is already the controlling
2412 * tty for another session group!
2413 */
2414 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
2415 /*
2416 * Steal it away
2417 */
2418 read_lock(&tasklist_lock);
2419 session_clear_tty(tty->session);
2420 read_unlock(&tasklist_lock);
2421 } else {
2422 ret = -EPERM;
2423 goto unlock;
2424 }
2425 }
2426 proc_set_tty(current, tty);
2427unlock:
2428 mutex_unlock(&tty_mutex);
2429 return ret;
2430}
2431
2432/**
2433 * tty_get_pgrp - return a ref counted pgrp pid
2434 * @tty: tty to read
2435 *
2436 * Returns a refcounted instance of the pid struct for the process
2437 * group controlling the tty.
2438 */
2439
2440struct pid *tty_get_pgrp(struct tty_struct *tty)
2441{
2442 unsigned long flags;
2443 struct pid *pgrp;
2444
2445 spin_lock_irqsave(&tty->ctrl_lock, flags);
2446 pgrp = get_pid(tty->pgrp);
2447 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2448
2449 return pgrp;
2450}
2451EXPORT_SYMBOL_GPL(tty_get_pgrp);
2452
2453/**
2454 * tiocgpgrp - get process group
2455 * @tty: tty passed by user
2456 * @real_tty: tty side of the tty passed by the user if a pty else the tty
2457 * @p: returned pid
2458 *
2459 * Obtain the process group of the tty. If there is no process group
2460 * return an error.
2461 *
2462 * Locking: none. Reference to current->signal->tty is safe.
2463 */
2464
2465static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2466{
2467 struct pid *pid;
2468 int ret;
2469 /*
2470 * (tty == real_tty) is a cheap way of
2471 * testing if the tty is NOT a master pty.
2472 */
2473 if (tty == real_tty && current->signal->tty != real_tty)
2474 return -ENOTTY;
2475 pid = tty_get_pgrp(real_tty);
2476 ret = put_user(pid_vnr(pid), p);
2477 put_pid(pid);
2478 return ret;
2479}
2480
2481/**
2482 * tiocspgrp - attempt to set process group
2483 * @tty: tty passed by user
2484 * @real_tty: tty side device matching tty passed by user
2485 * @p: pid pointer
2486 *
2487 * Set the process group of the tty to the session passed. Only
2488 * permitted where the tty session is our session.
2489 *
2490 * Locking: RCU, ctrl lock
2491 */
2492
2493static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2494{
2495 struct pid *pgrp;
2496 pid_t pgrp_nr;
2497 int retval = tty_check_change(real_tty);
2498 unsigned long flags;
2499
2500 if (retval == -EIO)
2501 return -ENOTTY;
2502 if (retval)
2503 return retval;
2504 if (!current->signal->tty ||
2505 (current->signal->tty != real_tty) ||
2506 (real_tty->session != task_session(current)))
2507 return -ENOTTY;
2508 if (get_user(pgrp_nr, p))
2509 return -EFAULT;
2510 if (pgrp_nr < 0)
2511 return -EINVAL;
2512 rcu_read_lock();
2513 pgrp = find_vpid(pgrp_nr);
2514 retval = -ESRCH;
2515 if (!pgrp)
2516 goto out_unlock;
2517 retval = -EPERM;
2518 if (session_of_pgrp(pgrp) != task_session(current))
2519 goto out_unlock;
2520 retval = 0;
2521 spin_lock_irqsave(&tty->ctrl_lock, flags);
2522 put_pid(real_tty->pgrp);
2523 real_tty->pgrp = get_pid(pgrp);
2524 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2525out_unlock:
2526 rcu_read_unlock();
2527 return retval;
2528}
2529
2530/**
2531 * tiocgsid - get session id
2532 * @tty: tty passed by user
2533 * @real_tty: tty side of the tty passed by the user if a pty else the tty
2534 * @p: pointer to returned session id
2535 *
2536 * Obtain the session id of the tty. If there is no session
2537 * return an error.
2538 *
2539 * Locking: none. Reference to current->signal->tty is safe.
2540 */
2541
2542static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2543{
2544 /*
2545 * (tty == real_tty) is a cheap way of
2546 * testing if the tty is NOT a master pty.
2547 */
2548 if (tty == real_tty && current->signal->tty != real_tty)
2549 return -ENOTTY;
2550 if (!real_tty->session)
2551 return -ENOTTY;
2552 return put_user(pid_vnr(real_tty->session), p);
2553}
2554
2555/**
2556 * tiocsetd - set line discipline
2557 * @tty: tty device
2558 * @p: pointer to user data
2559 *
2560 * Set the line discipline according to user request.
2561 *
2562 * Locking: see tty_set_ldisc, this function is just a helper
2563 */
2564
2565static int tiocsetd(struct tty_struct *tty, int __user *p)
2566{
2567 int ldisc;
2568 int ret;
2569
2570 if (get_user(ldisc, p))
2571 return -EFAULT;
2572
2573 ret = tty_set_ldisc(tty, ldisc);
2574
2575 return ret;
2576}
2577
2578/**
2579 * send_break - performed time break
2580 * @tty: device to break on
2581 * @duration: timeout in mS
2582 *
2583 * Perform a timed break on hardware that lacks its own driver level
2584 * timed break functionality.
2585 *
2586 * Locking:
2587 * atomic_write_lock serializes
2588 *
2589 */
2590
2591static int send_break(struct tty_struct *tty, unsigned int duration)
2592{
2593 int retval;
2594
2595 if (tty->ops->break_ctl == NULL)
2596 return 0;
2597
2598 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2599 retval = tty->ops->break_ctl(tty, duration);
2600 else {
2601 /* Do the work ourselves */
2602 if (tty_write_lock(tty, 0) < 0)
2603 return -EINTR;
2604 retval = tty->ops->break_ctl(tty, -1);
2605 if (retval)
2606 goto out;
2607 if (!signal_pending(current))
2608 msleep_interruptible(duration);
2609 retval = tty->ops->break_ctl(tty, 0);
2610out:
2611 tty_write_unlock(tty);
2612 if (signal_pending(current))
2613 retval = -EINTR;
2614 }
2615 return retval;
2616}
2617
2618/**
2619 * tty_tiocmget - get modem status
2620 * @tty: tty device
2621 * @file: user file pointer
2622 * @p: pointer to result
2623 *
2624 * Obtain the modem status bits from the tty driver if the feature
2625 * is supported. Return -EINVAL if it is not available.
2626 *
2627 * Locking: none (up to the driver)
2628 */
2629
2630static int tty_tiocmget(struct tty_struct *tty, int __user *p)
2631{
2632 int retval = -EINVAL;
2633
2634 if (tty->ops->tiocmget) {
2635 retval = tty->ops->tiocmget(tty);
2636
2637 if (retval >= 0)
2638 retval = put_user(retval, p);
2639 }
2640 return retval;
2641}
2642
2643/**
2644 * tty_tiocmset - set modem status
2645 * @tty: tty device
2646 * @cmd: command - clear bits, set bits or set all
2647 * @p: pointer to desired bits
2648 *
2649 * Set the modem status bits from the tty driver if the feature
2650 * is supported. Return -EINVAL if it is not available.
2651 *
2652 * Locking: none (up to the driver)
2653 */
2654
2655static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
2656 unsigned __user *p)
2657{
2658 int retval;
2659 unsigned int set, clear, val;
2660
2661 if (tty->ops->tiocmset == NULL)
2662 return -EINVAL;
2663
2664 retval = get_user(val, p);
2665 if (retval)
2666 return retval;
2667 set = clear = 0;
2668 switch (cmd) {
2669 case TIOCMBIS:
2670 set = val;
2671 break;
2672 case TIOCMBIC:
2673 clear = val;
2674 break;
2675 case TIOCMSET:
2676 set = val;
2677 clear = ~val;
2678 break;
2679 }
2680 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2681 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2682 return tty->ops->tiocmset(tty, set, clear);
2683}
2684
2685static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2686{
2687 int retval = -EINVAL;
2688 struct serial_icounter_struct icount;
2689 memset(&icount, 0, sizeof(icount));
2690 if (tty->ops->get_icount)
2691 retval = tty->ops->get_icount(tty, &icount);
2692 if (retval != 0)
2693 return retval;
2694 if (copy_to_user(arg, &icount, sizeof(icount)))
2695 return -EFAULT;
2696 return 0;
2697}
2698
2699struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2700{
2701 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2702 tty->driver->subtype == PTY_TYPE_MASTER)
2703 tty = tty->link;
2704 return tty;
2705}
2706EXPORT_SYMBOL(tty_pair_get_tty);
2707
2708struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2709{
2710 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2711 tty->driver->subtype == PTY_TYPE_MASTER)
2712 return tty;
2713 return tty->link;
2714}
2715EXPORT_SYMBOL(tty_pair_get_pty);
2716
2717/*
2718 * Split this up, as gcc can choke on it otherwise..
2719 */
2720long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2721{
2722 struct tty_struct *tty = file_tty(file);
2723 struct tty_struct *real_tty;
2724 void __user *p = (void __user *)arg;
2725 int retval;
2726 struct tty_ldisc *ld;
2727
2728 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2729 return -EINVAL;
2730
2731 real_tty = tty_pair_get_tty(tty);
2732
2733 /*
2734 * Factor out some common prep work
2735 */
2736 switch (cmd) {
2737 case TIOCSETD:
2738 case TIOCSBRK:
2739 case TIOCCBRK:
2740 case TCSBRK:
2741 case TCSBRKP:
2742 retval = tty_check_change(tty);
2743 if (retval)
2744 return retval;
2745 if (cmd != TIOCCBRK) {
2746 tty_wait_until_sent(tty, 0);
2747 if (signal_pending(current))
2748 return -EINTR;
2749 }
2750 break;
2751 }
2752
2753 /*
2754 * Now do the stuff.
2755 */
2756 switch (cmd) {
2757 case TIOCSTI:
2758 return tiocsti(tty, p);
2759 case TIOCGWINSZ:
2760 return tiocgwinsz(real_tty, p);
2761 case TIOCSWINSZ:
2762 return tiocswinsz(real_tty, p);
2763 case TIOCCONS:
2764 return real_tty != tty ? -EINVAL : tioccons(file);
2765 case FIONBIO:
2766 return fionbio(file, p);
2767 case TIOCEXCL:
2768 set_bit(TTY_EXCLUSIVE, &tty->flags);
2769 return 0;
2770 case TIOCNXCL:
2771 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2772 return 0;
2773 case TIOCGEXCL:
2774 {
2775 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2776 return put_user(excl, (int __user *)p);
2777 }
2778 case TIOCNOTTY:
2779 if (current->signal->tty != tty)
2780 return -ENOTTY;
2781 no_tty();
2782 return 0;
2783 case TIOCSCTTY:
2784 return tiocsctty(tty, arg);
2785 case TIOCGPGRP:
2786 return tiocgpgrp(tty, real_tty, p);
2787 case TIOCSPGRP:
2788 return tiocspgrp(tty, real_tty, p);
2789 case TIOCGSID:
2790 return tiocgsid(tty, real_tty, p);
2791 case TIOCGETD:
2792 return put_user(tty->ldisc->ops->num, (int __user *)p);
2793 case TIOCSETD:
2794 return tiocsetd(tty, p);
2795 case TIOCVHANGUP:
2796 if (!capable(CAP_SYS_ADMIN))
2797 return -EPERM;
2798 tty_vhangup(tty);
2799 return 0;
2800 case TIOCGDEV:
2801 {
2802 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2803 return put_user(ret, (unsigned int __user *)p);
2804 }
2805 /*
2806 * Break handling
2807 */
2808 case TIOCSBRK: /* Turn break on, unconditionally */
2809 if (tty->ops->break_ctl)
2810 return tty->ops->break_ctl(tty, -1);
2811 return 0;
2812 case TIOCCBRK: /* Turn break off, unconditionally */
2813 if (tty->ops->break_ctl)
2814 return tty->ops->break_ctl(tty, 0);
2815 return 0;
2816 case TCSBRK: /* SVID version: non-zero arg --> no break */
2817 /* non-zero arg means wait for all output data
2818 * to be sent (performed above) but don't send break.
2819 * This is used by the tcdrain() termios function.
2820 */
2821 if (!arg)
2822 return send_break(tty, 250);
2823 return 0;
2824 case TCSBRKP: /* support for POSIX tcsendbreak() */
2825 return send_break(tty, arg ? arg*100 : 250);
2826
2827 case TIOCMGET:
2828 return tty_tiocmget(tty, p);
2829 case TIOCMSET:
2830 case TIOCMBIC:
2831 case TIOCMBIS:
2832 return tty_tiocmset(tty, cmd, p);
2833 case TIOCGICOUNT:
2834 retval = tty_tiocgicount(tty, p);
2835 /* For the moment allow fall through to the old method */
2836 if (retval != -EINVAL)
2837 return retval;
2838 break;
2839 case TCFLSH:
2840 switch (arg) {
2841 case TCIFLUSH:
2842 case TCIOFLUSH:
2843 /* flush tty buffer and allow ldisc to process ioctl */
2844 tty_buffer_flush(tty);
2845 break;
2846 }
2847 break;
2848 }
2849 if (tty->ops->ioctl) {
2850 retval = (tty->ops->ioctl)(tty, cmd, arg);
2851 if (retval != -ENOIOCTLCMD)
2852 return retval;
2853 }
2854 ld = tty_ldisc_ref_wait(tty);
2855 retval = -EINVAL;
2856 if (ld->ops->ioctl) {
2857 retval = ld->ops->ioctl(tty, file, cmd, arg);
2858 if (retval == -ENOIOCTLCMD)
2859 retval = -ENOTTY;
2860 }
2861 tty_ldisc_deref(ld);
2862 return retval;
2863}
2864
2865#ifdef CONFIG_COMPAT
2866static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2867 unsigned long arg)
2868{
2869 struct tty_struct *tty = file_tty(file);
2870 struct tty_ldisc *ld;
2871 int retval = -ENOIOCTLCMD;
2872
2873 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2874 return -EINVAL;
2875
2876 if (tty->ops->compat_ioctl) {
2877 retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
2878 if (retval != -ENOIOCTLCMD)
2879 return retval;
2880 }
2881
2882 ld = tty_ldisc_ref_wait(tty);
2883 if (ld->ops->compat_ioctl)
2884 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2885 else
2886 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
2887 tty_ldisc_deref(ld);
2888
2889 return retval;
2890}
2891#endif
2892
2893static int this_tty(const void *t, struct file *file, unsigned fd)
2894{
2895 if (likely(file->f_op->read != tty_read))
2896 return 0;
2897 return file_tty(file) != t ? 0 : fd + 1;
2898}
2899
2900/*
2901 * This implements the "Secure Attention Key" --- the idea is to
2902 * prevent trojan horses by killing all processes associated with this
2903 * tty when the user hits the "Secure Attention Key". Required for
2904 * super-paranoid applications --- see the Orange Book for more details.
2905 *
2906 * This code could be nicer; ideally it should send a HUP, wait a few
2907 * seconds, then send a INT, and then a KILL signal. But you then
2908 * have to coordinate with the init process, since all processes associated
2909 * with the current tty must be dead before the new getty is allowed
2910 * to spawn.
2911 *
2912 * Now, if it would be correct ;-/ The current code has a nasty hole -
2913 * it doesn't catch files in flight. We may send the descriptor to ourselves
2914 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2915 *
2916 * Nasty bug: do_SAK is being called in interrupt context. This can
2917 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2918 */
2919void __do_SAK(struct tty_struct *tty)
2920{
2921#ifdef TTY_SOFT_SAK
2922 tty_hangup(tty);
2923#else
2924 struct task_struct *g, *p;
2925 struct pid *session;
2926 int i;
2927
2928 if (!tty)
2929 return;
2930 session = tty->session;
2931
2932 tty_ldisc_flush(tty);
2933
2934 tty_driver_flush_buffer(tty);
2935
2936 read_lock(&tasklist_lock);
2937 /* Kill the entire session */
2938 do_each_pid_task(session, PIDTYPE_SID, p) {
2939 printk(KERN_NOTICE "SAK: killed process %d"
2940 " (%s): task_session(p)==tty->session\n",
2941 task_pid_nr(p), p->comm);
2942 send_sig(SIGKILL, p, 1);
2943 } while_each_pid_task(session, PIDTYPE_SID, p);
2944 /* Now kill any processes that happen to have the
2945 * tty open.
2946 */
2947 do_each_thread(g, p) {
2948 if (p->signal->tty == tty) {
2949 printk(KERN_NOTICE "SAK: killed process %d"
2950 " (%s): task_session(p)==tty->session\n",
2951 task_pid_nr(p), p->comm);
2952 send_sig(SIGKILL, p, 1);
2953 continue;
2954 }
2955 task_lock(p);
2956 i = iterate_fd(p->files, 0, this_tty, tty);
2957 if (i != 0) {
2958 printk(KERN_NOTICE "SAK: killed process %d"
2959 " (%s): fd#%d opened to the tty\n",
2960 task_pid_nr(p), p->comm, i - 1);
2961 force_sig(SIGKILL, p);
2962 }
2963 task_unlock(p);
2964 } while_each_thread(g, p);
2965 read_unlock(&tasklist_lock);
2966#endif
2967}
2968
2969static void do_SAK_work(struct work_struct *work)
2970{
2971 struct tty_struct *tty =
2972 container_of(work, struct tty_struct, SAK_work);
2973 __do_SAK(tty);
2974}
2975
2976/*
2977 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2978 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2979 * the values which we write to it will be identical to the values which it
2980 * already has. --akpm
2981 */
2982void do_SAK(struct tty_struct *tty)
2983{
2984 if (!tty)
2985 return;
2986 schedule_work(&tty->SAK_work);
2987}
2988
2989EXPORT_SYMBOL(do_SAK);
2990
2991static int dev_match_devt(struct device *dev, const void *data)
2992{
2993 const dev_t *devt = data;
2994 return dev->devt == *devt;
2995}
2996
2997/* Must put_device() after it's unused! */
2998static struct device *tty_get_device(struct tty_struct *tty)
2999{
3000 dev_t devt = tty_devnum(tty);
3001 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
3002}
3003
3004
3005/**
3006 * initialize_tty_struct
3007 * @tty: tty to initialize
3008 *
3009 * This subroutine initializes a tty structure that has been newly
3010 * allocated.
3011 *
3012 * Locking: none - tty in question must not be exposed at this point
3013 */
3014
3015void initialize_tty_struct(struct tty_struct *tty,
3016 struct tty_driver *driver, int idx)
3017{
3018 memset(tty, 0, sizeof(struct tty_struct));
3019 kref_init(&tty->kref);
3020 tty->magic = TTY_MAGIC;
3021 tty_ldisc_init(tty);
3022 tty->session = NULL;
3023 tty->pgrp = NULL;
3024 mutex_init(&tty->legacy_mutex);
3025 mutex_init(&tty->throttle_mutex);
3026 init_rwsem(&tty->termios_rwsem);
3027 mutex_init(&tty->winsize_mutex);
3028 init_ldsem(&tty->ldisc_sem);
3029 init_waitqueue_head(&tty->write_wait);
3030 init_waitqueue_head(&tty->read_wait);
3031 INIT_WORK(&tty->hangup_work, do_tty_hangup);
3032 mutex_init(&tty->atomic_write_lock);
3033 spin_lock_init(&tty->ctrl_lock);
3034 INIT_LIST_HEAD(&tty->tty_files);
3035 INIT_WORK(&tty->SAK_work, do_SAK_work);
3036
3037 tty->driver = driver;
3038 tty->ops = driver->ops;
3039 tty->index = idx;
3040 tty_line_name(driver, idx, tty->name);
3041 tty->dev = tty_get_device(tty);
3042}
3043
3044/**
3045 * deinitialize_tty_struct
3046 * @tty: tty to deinitialize
3047 *
3048 * This subroutine deinitializes a tty structure that has been newly
3049 * allocated but tty_release cannot be called on that yet.
3050 *
3051 * Locking: none - tty in question must not be exposed at this point
3052 */
3053void deinitialize_tty_struct(struct tty_struct *tty)
3054{
3055 tty_ldisc_deinit(tty);
3056}
3057
3058/**
3059 * tty_put_char - write one character to a tty
3060 * @tty: tty
3061 * @ch: character
3062 *
3063 * Write one byte to the tty using the provided put_char method
3064 * if present. Returns the number of characters successfully output.
3065 *
3066 * Note: the specific put_char operation in the driver layer may go
3067 * away soon. Don't call it directly, use this method
3068 */
3069
3070int tty_put_char(struct tty_struct *tty, unsigned char ch)
3071{
3072 if (tty->ops->put_char)
3073 return tty->ops->put_char(tty, ch);
3074 return tty->ops->write(tty, &ch, 1);
3075}
3076EXPORT_SYMBOL_GPL(tty_put_char);
3077
3078struct class *tty_class;
3079
3080static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3081 unsigned int index, unsigned int count)
3082{
3083 /* init here, since reused cdevs cause crashes */
3084 cdev_init(&driver->cdevs[index], &tty_fops);
3085 driver->cdevs[index].owner = driver->owner;
3086 return cdev_add(&driver->cdevs[index], dev, count);
3087}
3088
3089/**
3090 * tty_register_device - register a tty device
3091 * @driver: the tty driver that describes the tty device
3092 * @index: the index in the tty driver for this tty device
3093 * @device: a struct device that is associated with this tty device.
3094 * This field is optional, if there is no known struct device
3095 * for this tty device it can be set to NULL safely.
3096 *
3097 * Returns a pointer to the struct device for this tty device
3098 * (or ERR_PTR(-EFOO) on error).
3099 *
3100 * This call is required to be made to register an individual tty device
3101 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3102 * that bit is not set, this function should not be called by a tty
3103 * driver.
3104 *
3105 * Locking: ??
3106 */
3107
3108struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3109 struct device *device)
3110{
3111 return tty_register_device_attr(driver, index, device, NULL, NULL);
3112}
3113EXPORT_SYMBOL(tty_register_device);
3114
3115static void tty_device_create_release(struct device *dev)
3116{
3117 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3118 kfree(dev);
3119}
3120
3121/**
3122 * tty_register_device_attr - register a tty device
3123 * @driver: the tty driver that describes the tty device
3124 * @index: the index in the tty driver for this tty device
3125 * @device: a struct device that is associated with this tty device.
3126 * This field is optional, if there is no known struct device
3127 * for this tty device it can be set to NULL safely.
3128 * @drvdata: Driver data to be set to device.
3129 * @attr_grp: Attribute group to be set on device.
3130 *
3131 * Returns a pointer to the struct device for this tty device
3132 * (or ERR_PTR(-EFOO) on error).
3133 *
3134 * This call is required to be made to register an individual tty device
3135 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3136 * that bit is not set, this function should not be called by a tty
3137 * driver.
3138 *
3139 * Locking: ??
3140 */
3141struct device *tty_register_device_attr(struct tty_driver *driver,
3142 unsigned index, struct device *device,
3143 void *drvdata,
3144 const struct attribute_group **attr_grp)
3145{
3146 char name[64];
3147 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3148 struct device *dev = NULL;
3149 int retval = -ENODEV;
3150 bool cdev = false;
3151
3152 if (index >= driver->num) {
3153 printk(KERN_ERR "Attempt to register invalid tty line number "
3154 " (%d).\n", index);
3155 return ERR_PTR(-EINVAL);
3156 }
3157
3158 if (driver->type == TTY_DRIVER_TYPE_PTY)
3159 pty_line_name(driver, index, name);
3160 else
3161 tty_line_name(driver, index, name);
3162
3163 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3164 retval = tty_cdev_add(driver, devt, index, 1);
3165 if (retval)
3166 goto error;
3167 cdev = true;
3168 }
3169
3170 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3171 if (!dev) {
3172 retval = -ENOMEM;
3173 goto error;
3174 }
3175
3176 dev->devt = devt;
3177 dev->class = tty_class;
3178 dev->parent = device;
3179 dev->release = tty_device_create_release;
3180 dev_set_name(dev, "%s", name);
3181 dev->groups = attr_grp;
3182 dev_set_drvdata(dev, drvdata);
3183
3184 retval = device_register(dev);
3185 if (retval)
3186 goto error;
3187
3188 return dev;
3189
3190error:
3191 put_device(dev);
3192 if (cdev)
3193 cdev_del(&driver->cdevs[index]);
3194 return ERR_PTR(retval);
3195}
3196EXPORT_SYMBOL_GPL(tty_register_device_attr);
3197
3198/**
3199 * tty_unregister_device - unregister a tty device
3200 * @driver: the tty driver that describes the tty device
3201 * @index: the index in the tty driver for this tty device
3202 *
3203 * If a tty device is registered with a call to tty_register_device() then
3204 * this function must be called when the tty device is gone.
3205 *
3206 * Locking: ??
3207 */
3208
3209void tty_unregister_device(struct tty_driver *driver, unsigned index)
3210{
3211 device_destroy(tty_class,
3212 MKDEV(driver->major, driver->minor_start) + index);
3213 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
3214 cdev_del(&driver->cdevs[index]);
3215}
3216EXPORT_SYMBOL(tty_unregister_device);
3217
3218/**
3219 * __tty_alloc_driver -- allocate tty driver
3220 * @lines: count of lines this driver can handle at most
3221 * @owner: module which is repsonsible for this driver
3222 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3223 *
3224 * This should not be called directly, some of the provided macros should be
3225 * used instead. Use IS_ERR and friends on @retval.
3226 */
3227struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3228 unsigned long flags)
3229{
3230 struct tty_driver *driver;
3231 unsigned int cdevs = 1;
3232 int err;
3233
3234 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
3235 return ERR_PTR(-EINVAL);
3236
3237 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
3238 if (!driver)
3239 return ERR_PTR(-ENOMEM);
3240
3241 kref_init(&driver->kref);
3242 driver->magic = TTY_DRIVER_MAGIC;
3243 driver->num = lines;
3244 driver->owner = owner;
3245 driver->flags = flags;
3246
3247 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3248 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3249 GFP_KERNEL);
3250 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3251 GFP_KERNEL);
3252 if (!driver->ttys || !driver->termios) {
3253 err = -ENOMEM;
3254 goto err_free_all;
3255 }
3256 }
3257
3258 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3259 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3260 GFP_KERNEL);
3261 if (!driver->ports) {
3262 err = -ENOMEM;
3263 goto err_free_all;
3264 }
3265 cdevs = lines;
3266 }
3267
3268 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3269 if (!driver->cdevs) {
3270 err = -ENOMEM;
3271 goto err_free_all;
3272 }
3273
3274 return driver;
3275err_free_all:
3276 kfree(driver->ports);
3277 kfree(driver->ttys);
3278 kfree(driver->termios);
3279 kfree(driver);
3280 return ERR_PTR(err);
3281}
3282EXPORT_SYMBOL(__tty_alloc_driver);
3283
3284static void destruct_tty_driver(struct kref *kref)
3285{
3286 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3287 int i;
3288 struct ktermios *tp;
3289
3290 if (driver->flags & TTY_DRIVER_INSTALLED) {
3291 /*
3292 * Free the termios and termios_locked structures because
3293 * we don't want to get memory leaks when modular tty
3294 * drivers are removed from the kernel.
3295 */
3296 for (i = 0; i < driver->num; i++) {
3297 tp = driver->termios[i];
3298 if (tp) {
3299 driver->termios[i] = NULL;
3300 kfree(tp);
3301 }
3302 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3303 tty_unregister_device(driver, i);
3304 }
3305 proc_tty_unregister_driver(driver);
3306 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3307 cdev_del(&driver->cdevs[0]);
3308 }
3309 kfree(driver->cdevs);
3310 kfree(driver->ports);
3311 kfree(driver->termios);
3312 kfree(driver->ttys);
3313 kfree(driver);
3314}
3315
3316void tty_driver_kref_put(struct tty_driver *driver)
3317{
3318 kref_put(&driver->kref, destruct_tty_driver);
3319}
3320EXPORT_SYMBOL(tty_driver_kref_put);
3321
3322void tty_set_operations(struct tty_driver *driver,
3323 const struct tty_operations *op)
3324{
3325 driver->ops = op;
3326};
3327EXPORT_SYMBOL(tty_set_operations);
3328
3329void put_tty_driver(struct tty_driver *d)
3330{
3331 tty_driver_kref_put(d);
3332}
3333EXPORT_SYMBOL(put_tty_driver);
3334
3335/*
3336 * Called by a tty driver to register itself.
3337 */
3338int tty_register_driver(struct tty_driver *driver)
3339{
3340 int error;
3341 int i;
3342 dev_t dev;
3343 struct device *d;
3344
3345 if (!driver->major) {
3346 error = alloc_chrdev_region(&dev, driver->minor_start,
3347 driver->num, driver->name);
3348 if (!error) {
3349 driver->major = MAJOR(dev);
3350 driver->minor_start = MINOR(dev);
3351 }
3352 } else {
3353 dev = MKDEV(driver->major, driver->minor_start);
3354 error = register_chrdev_region(dev, driver->num, driver->name);
3355 }
3356 if (error < 0)
3357 goto err;
3358
3359 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3360 error = tty_cdev_add(driver, dev, 0, driver->num);
3361 if (error)
3362 goto err_unreg_char;
3363 }
3364
3365 mutex_lock(&tty_mutex);
3366 list_add(&driver->tty_drivers, &tty_drivers);
3367 mutex_unlock(&tty_mutex);
3368
3369 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
3370 for (i = 0; i < driver->num; i++) {
3371 d = tty_register_device(driver, i, NULL);
3372 if (IS_ERR(d)) {
3373 error = PTR_ERR(d);
3374 goto err_unreg_devs;
3375 }
3376 }
3377 }
3378 proc_tty_register_driver(driver);
3379 driver->flags |= TTY_DRIVER_INSTALLED;
3380 return 0;
3381
3382err_unreg_devs:
3383 for (i--; i >= 0; i--)
3384 tty_unregister_device(driver, i);
3385
3386 mutex_lock(&tty_mutex);
3387 list_del(&driver->tty_drivers);
3388 mutex_unlock(&tty_mutex);
3389
3390err_unreg_char:
3391 unregister_chrdev_region(dev, driver->num);
3392err:
3393 return error;
3394}
3395EXPORT_SYMBOL(tty_register_driver);
3396
3397/*
3398 * Called by a tty driver to unregister itself.
3399 */
3400int tty_unregister_driver(struct tty_driver *driver)
3401{
3402#if 0
3403 /* FIXME */
3404 if (driver->refcount)
3405 return -EBUSY;
3406#endif
3407 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3408 driver->num);
3409 mutex_lock(&tty_mutex);
3410 list_del(&driver->tty_drivers);
3411 mutex_unlock(&tty_mutex);
3412 return 0;
3413}
3414
3415EXPORT_SYMBOL(tty_unregister_driver);
3416
3417dev_t tty_devnum(struct tty_struct *tty)
3418{
3419 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3420}
3421EXPORT_SYMBOL(tty_devnum);
3422
3423void proc_clear_tty(struct task_struct *p)
3424{
3425 unsigned long flags;
3426 struct tty_struct *tty;
3427 spin_lock_irqsave(&p->sighand->siglock, flags);
3428 tty = p->signal->tty;
3429 p->signal->tty = NULL;
3430 spin_unlock_irqrestore(&p->sighand->siglock, flags);
3431 tty_kref_put(tty);
3432}
3433
3434/* Called under the sighand lock */
3435
3436static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3437{
3438 if (tty) {
3439 unsigned long flags;
3440 /* We should not have a session or pgrp to put here but.... */
3441 spin_lock_irqsave(&tty->ctrl_lock, flags);
3442 put_pid(tty->session);
3443 put_pid(tty->pgrp);
3444 tty->pgrp = get_pid(task_pgrp(tsk));
3445 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3446 tty->session = get_pid(task_session(tsk));
3447 if (tsk->signal->tty) {
3448 printk(KERN_DEBUG "tty not NULL!!\n");
3449 tty_kref_put(tsk->signal->tty);
3450 }
3451 }
3452 put_pid(tsk->signal->tty_old_pgrp);
3453 tsk->signal->tty = tty_kref_get(tty);
3454 tsk->signal->tty_old_pgrp = NULL;
3455}
3456
3457static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3458{
3459 spin_lock_irq(&tsk->sighand->siglock);
3460 __proc_set_tty(tsk, tty);
3461 spin_unlock_irq(&tsk->sighand->siglock);
3462}
3463
3464struct tty_struct *get_current_tty(void)
3465{
3466 struct tty_struct *tty;
3467 unsigned long flags;
3468
3469 spin_lock_irqsave(¤t->sighand->siglock, flags);
3470 tty = tty_kref_get(current->signal->tty);
3471 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
3472 return tty;
3473}
3474EXPORT_SYMBOL_GPL(get_current_tty);
3475
3476void tty_default_fops(struct file_operations *fops)
3477{
3478 *fops = tty_fops;
3479}
3480
3481/*
3482 * Initialize the console device. This is called *early*, so
3483 * we can't necessarily depend on lots of kernel help here.
3484 * Just do some early initializations, and do the complex setup
3485 * later.
3486 */
3487void __init console_init(void)
3488{
3489 initcall_t *call;
3490
3491 /* Setup the default TTY line discipline. */
3492 tty_ldisc_begin();
3493
3494 /*
3495 * set up the console device so that later boot sequences can
3496 * inform about problems etc..
3497 */
3498 call = __con_initcall_start;
3499 while (call < __con_initcall_end) {
3500 (*call)();
3501 call++;
3502 }
3503}
3504
3505static char *tty_devnode(struct device *dev, umode_t *mode)
3506{
3507 if (!mode)
3508 return NULL;
3509 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3510 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3511 *mode = 0666;
3512 return NULL;
3513}
3514
3515static int __init tty_class_init(void)
3516{
3517 tty_class = class_create(THIS_MODULE, "tty");
3518 if (IS_ERR(tty_class))
3519 return PTR_ERR(tty_class);
3520 tty_class->devnode = tty_devnode;
3521 return 0;
3522}
3523
3524postcore_initcall(tty_class_init);
3525
3526/* 3/2004 jmc: why do these devices exist? */
3527static struct cdev tty_cdev, console_cdev;
3528
3529static ssize_t show_cons_active(struct device *dev,
3530 struct device_attribute *attr, char *buf)
3531{
3532 struct console *cs[16];
3533 int i = 0;
3534 struct console *c;
3535 ssize_t count = 0;
3536
3537 console_lock();
3538 for_each_console(c) {
3539 if (!c->device)
3540 continue;
3541 if (!c->write)
3542 continue;
3543 if ((c->flags & CON_ENABLED) == 0)
3544 continue;
3545 cs[i++] = c;
3546 if (i >= ARRAY_SIZE(cs))
3547 break;
3548 }
3549 while (i--) {
3550 int index = cs[i]->index;
3551 struct tty_driver *drv = cs[i]->device(cs[i], &index);
3552
3553 /* don't resolve tty0 as some programs depend on it */
3554 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
3555 count += tty_line_name(drv, index, buf + count);
3556 else
3557 count += sprintf(buf + count, "%s%d",
3558 cs[i]->name, cs[i]->index);
3559
3560 count += sprintf(buf + count, "%c", i ? ' ':'\n');
3561 }
3562 console_unlock();
3563
3564 return count;
3565}
3566static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3567
3568static struct device *consdev;
3569
3570void console_sysfs_notify(void)
3571{
3572 if (consdev)
3573 sysfs_notify(&consdev->kobj, NULL, "active");
3574}
3575
3576/*
3577 * Ok, now we can initialize the rest of the tty devices and can count
3578 * on memory allocations, interrupts etc..
3579 */
3580int __init tty_init(void)
3581{
3582 cdev_init(&tty_cdev, &tty_fops);
3583 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3584 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3585 panic("Couldn't register /dev/tty driver\n");
3586 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3587
3588 cdev_init(&console_cdev, &console_fops);
3589 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3590 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3591 panic("Couldn't register /dev/console driver\n");
3592 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
3593 "console");
3594 if (IS_ERR(consdev))
3595 consdev = NULL;
3596 else
3597 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
3598
3599#ifdef CONFIG_VT
3600 vty_init(&console_fops);
3601#endif
3602 return 0;
3603}
3604
1/*
2 * Copyright (C) 1991, 1992 Linus Torvalds
3 */
4
5/*
6 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
7 * or rs-channels. It also implements echoing, cooked mode etc.
8 *
9 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
10 *
11 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
12 * tty_struct and tty_queue structures. Previously there was an array
13 * of 256 tty_struct's which was statically allocated, and the
14 * tty_queue structures were allocated at boot time. Both are now
15 * dynamically allocated only when the tty is open.
16 *
17 * Also restructured routines so that there is more of a separation
18 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
19 * the low-level tty routines (serial.c, pty.c, console.c). This
20 * makes for cleaner and more compact code. -TYT, 9/17/92
21 *
22 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
23 * which can be dynamically activated and de-activated by the line
24 * discipline handling modules (like SLIP).
25 *
26 * NOTE: pay no attention to the line discipline code (yet); its
27 * interface is still subject to change in this version...
28 * -- TYT, 1/31/92
29 *
30 * Added functionality to the OPOST tty handling. No delays, but all
31 * other bits should be there.
32 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
33 *
34 * Rewrote canonical mode and added more termios flags.
35 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
36 *
37 * Reorganized FASYNC support so mouse code can share it.
38 * -- ctm@ardi.com, 9Sep95
39 *
40 * New TIOCLINUX variants added.
41 * -- mj@k332.feld.cvut.cz, 19-Nov-95
42 *
43 * Restrict vt switching via ioctl()
44 * -- grif@cs.ucr.edu, 5-Dec-95
45 *
46 * Move console and virtual terminal code to more appropriate files,
47 * implement CONFIG_VT and generalize console device interface.
48 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
49 *
50 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
51 * -- Bill Hawes <whawes@star.net>, June 97
52 *
53 * Added devfs support.
54 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
55 *
56 * Added support for a Unix98-style ptmx device.
57 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
58 *
59 * Reduced memory usage for older ARM systems
60 * -- Russell King <rmk@arm.linux.org.uk>
61 *
62 * Move do_SAK() into process context. Less stack use in devfs functions.
63 * alloc_tty_struct() always uses kmalloc()
64 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
65 */
66
67#include <linux/types.h>
68#include <linux/major.h>
69#include <linux/errno.h>
70#include <linux/signal.h>
71#include <linux/fcntl.h>
72#include <linux/sched.h>
73#include <linux/interrupt.h>
74#include <linux/tty.h>
75#include <linux/tty_driver.h>
76#include <linux/tty_flip.h>
77#include <linux/devpts_fs.h>
78#include <linux/file.h>
79#include <linux/fdtable.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/device.h>
92#include <linux/wait.h>
93#include <linux/bitops.h>
94#include <linux/delay.h>
95#include <linux/seq_file.h>
96#include <linux/serial.h>
97#include <linux/ratelimit.h>
98
99#include <linux/uaccess.h>
100
101#include <linux/kbd_kern.h>
102#include <linux/vt_kern.h>
103#include <linux/selection.h>
104
105#include <linux/kmod.h>
106#include <linux/nsproxy.h>
107
108#undef TTY_DEBUG_HANGUP
109
110#define TTY_PARANOIA_CHECK 1
111#define CHECK_TTY_COUNT 1
112
113struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
119 .c_cc = INIT_C_CC,
120 .c_ispeed = 38400,
121 .c_ospeed = 38400
122};
123
124EXPORT_SYMBOL(tty_std_termios);
125
126/* This list gets poked at by procfs and various bits of boot up code. This
127 could do with some rationalisation such as pulling the tty proc function
128 into this file */
129
130LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131
132/* Mutex to protect creating and releasing a tty. This is shared with
133 vt.c for deeply disgusting hack reasons */
134DEFINE_MUTEX(tty_mutex);
135EXPORT_SYMBOL(tty_mutex);
136
137/* Spinlock to protect the tty->tty_files list */
138DEFINE_SPINLOCK(tty_files_lock);
139
140static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
141static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
142ssize_t redirected_tty_write(struct file *, const char __user *,
143 size_t, loff_t *);
144static unsigned int tty_poll(struct file *, poll_table *);
145static int tty_open(struct inode *, struct file *);
146long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
147#ifdef CONFIG_COMPAT
148static long tty_compat_ioctl(struct file *file, unsigned int cmd,
149 unsigned long arg);
150#else
151#define tty_compat_ioctl NULL
152#endif
153static int __tty_fasync(int fd, struct file *filp, int on);
154static int tty_fasync(int fd, struct file *filp, int on);
155static void release_tty(struct tty_struct *tty, int idx);
156static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
157static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
158
159/**
160 * alloc_tty_struct - allocate a tty object
161 *
162 * Return a new empty tty structure. The data fields have not
163 * been initialized in any way but has been zeroed
164 *
165 * Locking: none
166 */
167
168struct tty_struct *alloc_tty_struct(void)
169{
170 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
171}
172
173/**
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
182void free_tty_struct(struct tty_struct *tty)
183{
184 if (tty->dev)
185 put_device(tty->dev);
186 kfree(tty->write_buf);
187 tty_buffer_free_all(tty);
188 kfree(tty);
189}
190
191static inline struct tty_struct *file_tty(struct file *file)
192{
193 return ((struct tty_file_private *)file->private_data)->tty;
194}
195
196int tty_alloc_file(struct file *file)
197{
198 struct tty_file_private *priv;
199
200 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
201 if (!priv)
202 return -ENOMEM;
203
204 file->private_data = priv;
205
206 return 0;
207}
208
209/* Associate a new file with the tty structure */
210void tty_add_file(struct tty_struct *tty, struct file *file)
211{
212 struct tty_file_private *priv = file->private_data;
213
214 priv->tty = tty;
215 priv->file = file;
216
217 spin_lock(&tty_files_lock);
218 list_add(&priv->list, &tty->tty_files);
219 spin_unlock(&tty_files_lock);
220}
221
222/**
223 * tty_free_file - free file->private_data
224 *
225 * This shall be used only for fail path handling when tty_add_file was not
226 * called yet.
227 */
228void tty_free_file(struct file *file)
229{
230 struct tty_file_private *priv = file->private_data;
231
232 file->private_data = NULL;
233 kfree(priv);
234}
235
236/* Delete file from its tty */
237void tty_del_file(struct file *file)
238{
239 struct tty_file_private *priv = file->private_data;
240
241 spin_lock(&tty_files_lock);
242 list_del(&priv->list);
243 spin_unlock(&tty_files_lock);
244 tty_free_file(file);
245}
246
247
248#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
249
250/**
251 * tty_name - return tty naming
252 * @tty: tty structure
253 * @buf: buffer for output
254 *
255 * Convert a tty structure into a name. The name reflects the kernel
256 * naming policy and if udev is in use may not reflect user space
257 *
258 * Locking: none
259 */
260
261char *tty_name(struct tty_struct *tty, char *buf)
262{
263 if (!tty) /* Hmm. NULL pointer. That's fun. */
264 strcpy(buf, "NULL tty");
265 else
266 strcpy(buf, tty->name);
267 return buf;
268}
269
270EXPORT_SYMBOL(tty_name);
271
272int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
273 const char *routine)
274{
275#ifdef TTY_PARANOIA_CHECK
276 if (!tty) {
277 printk(KERN_WARNING
278 "null TTY for (%d:%d) in %s\n",
279 imajor(inode), iminor(inode), routine);
280 return 1;
281 }
282 if (tty->magic != TTY_MAGIC) {
283 printk(KERN_WARNING
284 "bad magic number for tty struct (%d:%d) in %s\n",
285 imajor(inode), iminor(inode), routine);
286 return 1;
287 }
288#endif
289 return 0;
290}
291
292static int check_tty_count(struct tty_struct *tty, const char *routine)
293{
294#ifdef CHECK_TTY_COUNT
295 struct list_head *p;
296 int count = 0;
297
298 spin_lock(&tty_files_lock);
299 list_for_each(p, &tty->tty_files) {
300 count++;
301 }
302 spin_unlock(&tty_files_lock);
303 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
304 tty->driver->subtype == PTY_TYPE_SLAVE &&
305 tty->link && tty->link->count)
306 count++;
307 if (tty->count != count) {
308 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
309 "!= #fd's(%d) in %s\n",
310 tty->name, tty->count, count, routine);
311 return count;
312 }
313#endif
314 return 0;
315}
316
317/**
318 * get_tty_driver - find device of a tty
319 * @dev_t: device identifier
320 * @index: returns the index of the tty
321 *
322 * This routine returns a tty driver structure, given a device number
323 * and also passes back the index number.
324 *
325 * Locking: caller must hold tty_mutex
326 */
327
328static struct tty_driver *get_tty_driver(dev_t device, int *index)
329{
330 struct tty_driver *p;
331
332 list_for_each_entry(p, &tty_drivers, tty_drivers) {
333 dev_t base = MKDEV(p->major, p->minor_start);
334 if (device < base || device >= base + p->num)
335 continue;
336 *index = device - base;
337 return tty_driver_kref_get(p);
338 }
339 return NULL;
340}
341
342#ifdef CONFIG_CONSOLE_POLL
343
344/**
345 * tty_find_polling_driver - find device of a polled tty
346 * @name: name string to match
347 * @line: pointer to resulting tty line nr
348 *
349 * This routine returns a tty driver structure, given a name
350 * and the condition that the tty driver is capable of polled
351 * operation.
352 */
353struct tty_driver *tty_find_polling_driver(char *name, int *line)
354{
355 struct tty_driver *p, *res = NULL;
356 int tty_line = 0;
357 int len;
358 char *str, *stp;
359
360 for (str = name; *str; str++)
361 if ((*str >= '0' && *str <= '9') || *str == ',')
362 break;
363 if (!*str)
364 return NULL;
365
366 len = str - name;
367 tty_line = simple_strtoul(str, &str, 10);
368
369 mutex_lock(&tty_mutex);
370 /* Search through the tty devices to look for a match */
371 list_for_each_entry(p, &tty_drivers, tty_drivers) {
372 if (strncmp(name, p->name, len) != 0)
373 continue;
374 stp = str;
375 if (*stp == ',')
376 stp++;
377 if (*stp == '\0')
378 stp = NULL;
379
380 if (tty_line >= 0 && tty_line < p->num && p->ops &&
381 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
382 res = tty_driver_kref_get(p);
383 *line = tty_line;
384 break;
385 }
386 }
387 mutex_unlock(&tty_mutex);
388
389 return res;
390}
391EXPORT_SYMBOL_GPL(tty_find_polling_driver);
392#endif
393
394/**
395 * tty_check_change - check for POSIX terminal changes
396 * @tty: tty to check
397 *
398 * If we try to write to, or set the state of, a terminal and we're
399 * not in the foreground, send a SIGTTOU. If the signal is blocked or
400 * ignored, go ahead and perform the operation. (POSIX 7.2)
401 *
402 * Locking: ctrl_lock
403 */
404
405int tty_check_change(struct tty_struct *tty)
406{
407 unsigned long flags;
408 int ret = 0;
409
410 if (current->signal->tty != tty)
411 return 0;
412
413 spin_lock_irqsave(&tty->ctrl_lock, flags);
414
415 if (!tty->pgrp) {
416 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
417 goto out_unlock;
418 }
419 if (task_pgrp(current) == tty->pgrp)
420 goto out_unlock;
421 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
422 if (is_ignored(SIGTTOU))
423 goto out;
424 if (is_current_pgrp_orphaned()) {
425 ret = -EIO;
426 goto out;
427 }
428 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
429 set_thread_flag(TIF_SIGPENDING);
430 ret = -ERESTARTSYS;
431out:
432 return ret;
433out_unlock:
434 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
435 return ret;
436}
437
438EXPORT_SYMBOL(tty_check_change);
439
440static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
441 size_t count, loff_t *ppos)
442{
443 return 0;
444}
445
446static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
447 size_t count, loff_t *ppos)
448{
449 return -EIO;
450}
451
452/* No kernel lock held - none needed ;) */
453static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
454{
455 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
456}
457
458static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
459 unsigned long arg)
460{
461 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
462}
463
464static long hung_up_tty_compat_ioctl(struct file *file,
465 unsigned int cmd, unsigned long arg)
466{
467 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
468}
469
470static const struct file_operations tty_fops = {
471 .llseek = no_llseek,
472 .read = tty_read,
473 .write = tty_write,
474 .poll = tty_poll,
475 .unlocked_ioctl = tty_ioctl,
476 .compat_ioctl = tty_compat_ioctl,
477 .open = tty_open,
478 .release = tty_release,
479 .fasync = tty_fasync,
480};
481
482static const struct file_operations console_fops = {
483 .llseek = no_llseek,
484 .read = tty_read,
485 .write = redirected_tty_write,
486 .poll = tty_poll,
487 .unlocked_ioctl = tty_ioctl,
488 .compat_ioctl = tty_compat_ioctl,
489 .open = tty_open,
490 .release = tty_release,
491 .fasync = tty_fasync,
492};
493
494static const struct file_operations hung_up_tty_fops = {
495 .llseek = no_llseek,
496 .read = hung_up_tty_read,
497 .write = hung_up_tty_write,
498 .poll = hung_up_tty_poll,
499 .unlocked_ioctl = hung_up_tty_ioctl,
500 .compat_ioctl = hung_up_tty_compat_ioctl,
501 .release = tty_release,
502};
503
504static DEFINE_SPINLOCK(redirect_lock);
505static struct file *redirect;
506
507/**
508 * tty_wakeup - request more data
509 * @tty: terminal
510 *
511 * Internal and external helper for wakeups of tty. This function
512 * informs the line discipline if present that the driver is ready
513 * to receive more output data.
514 */
515
516void tty_wakeup(struct tty_struct *tty)
517{
518 struct tty_ldisc *ld;
519
520 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
521 ld = tty_ldisc_ref(tty);
522 if (ld) {
523 if (ld->ops->write_wakeup)
524 ld->ops->write_wakeup(tty);
525 tty_ldisc_deref(ld);
526 }
527 }
528 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
529}
530
531EXPORT_SYMBOL_GPL(tty_wakeup);
532
533/**
534 * __tty_hangup - actual handler for hangup events
535 * @work: tty device
536 *
537 * This can be called by the "eventd" kernel thread. That is process
538 * synchronous but doesn't hold any locks, so we need to make sure we
539 * have the appropriate locks for what we're doing.
540 *
541 * The hangup event clears any pending redirections onto the hung up
542 * device. It ensures future writes will error and it does the needed
543 * line discipline hangup and signal delivery. The tty object itself
544 * remains intact.
545 *
546 * Locking:
547 * BTM
548 * redirect lock for undoing redirection
549 * file list lock for manipulating list of ttys
550 * tty_ldisc_lock from called functions
551 * termios_mutex resetting termios data
552 * tasklist_lock to walk task list for hangup event
553 * ->siglock to protect ->signal/->sighand
554 */
555void __tty_hangup(struct tty_struct *tty)
556{
557 struct file *cons_filp = NULL;
558 struct file *filp, *f = NULL;
559 struct task_struct *p;
560 struct tty_file_private *priv;
561 int closecount = 0, n;
562 unsigned long flags;
563 int refs = 0;
564
565 if (!tty)
566 return;
567
568
569 spin_lock(&redirect_lock);
570 if (redirect && file_tty(redirect) == tty) {
571 f = redirect;
572 redirect = NULL;
573 }
574 spin_unlock(&redirect_lock);
575
576 tty_lock();
577
578 /* some functions below drop BTM, so we need this bit */
579 set_bit(TTY_HUPPING, &tty->flags);
580
581 /* inuse_filps is protected by the single tty lock,
582 this really needs to change if we want to flush the
583 workqueue with the lock held */
584 check_tty_count(tty, "tty_hangup");
585
586 spin_lock(&tty_files_lock);
587 /* This breaks for file handles being sent over AF_UNIX sockets ? */
588 list_for_each_entry(priv, &tty->tty_files, list) {
589 filp = priv->file;
590 if (filp->f_op->write == redirected_tty_write)
591 cons_filp = filp;
592 if (filp->f_op->write != tty_write)
593 continue;
594 closecount++;
595 __tty_fasync(-1, filp, 0); /* can't block */
596 filp->f_op = &hung_up_tty_fops;
597 }
598 spin_unlock(&tty_files_lock);
599
600 /*
601 * it drops BTM and thus races with reopen
602 * we protect the race by TTY_HUPPING
603 */
604 tty_ldisc_hangup(tty);
605
606 read_lock(&tasklist_lock);
607 if (tty->session) {
608 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
609 spin_lock_irq(&p->sighand->siglock);
610 if (p->signal->tty == tty) {
611 p->signal->tty = NULL;
612 /* We defer the dereferences outside fo
613 the tasklist lock */
614 refs++;
615 }
616 if (!p->signal->leader) {
617 spin_unlock_irq(&p->sighand->siglock);
618 continue;
619 }
620 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
621 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
622 put_pid(p->signal->tty_old_pgrp); /* A noop */
623 spin_lock_irqsave(&tty->ctrl_lock, flags);
624 if (tty->pgrp)
625 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
626 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
627 spin_unlock_irq(&p->sighand->siglock);
628 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
629 }
630 read_unlock(&tasklist_lock);
631
632 spin_lock_irqsave(&tty->ctrl_lock, flags);
633 clear_bit(TTY_THROTTLED, &tty->flags);
634 clear_bit(TTY_PUSH, &tty->flags);
635 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
636 put_pid(tty->session);
637 put_pid(tty->pgrp);
638 tty->session = NULL;
639 tty->pgrp = NULL;
640 tty->ctrl_status = 0;
641 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
642
643 /* Account for the p->signal references we killed */
644 while (refs--)
645 tty_kref_put(tty);
646
647 /*
648 * If one of the devices matches a console pointer, we
649 * cannot just call hangup() because that will cause
650 * tty->count and state->count to go out of sync.
651 * So we just call close() the right number of times.
652 */
653 if (cons_filp) {
654 if (tty->ops->close)
655 for (n = 0; n < closecount; n++)
656 tty->ops->close(tty, cons_filp);
657 } else if (tty->ops->hangup)
658 (tty->ops->hangup)(tty);
659 /*
660 * We don't want to have driver/ldisc interactions beyond
661 * the ones we did here. The driver layer expects no
662 * calls after ->hangup() from the ldisc side. However we
663 * can't yet guarantee all that.
664 */
665 set_bit(TTY_HUPPED, &tty->flags);
666 clear_bit(TTY_HUPPING, &tty->flags);
667 tty_ldisc_enable(tty);
668
669 tty_unlock();
670
671 if (f)
672 fput(f);
673}
674
675static void do_tty_hangup(struct work_struct *work)
676{
677 struct tty_struct *tty =
678 container_of(work, struct tty_struct, hangup_work);
679
680 __tty_hangup(tty);
681}
682
683/**
684 * tty_hangup - trigger a hangup event
685 * @tty: tty to hangup
686 *
687 * A carrier loss (virtual or otherwise) has occurred on this like
688 * schedule a hangup sequence to run after this event.
689 */
690
691void tty_hangup(struct tty_struct *tty)
692{
693#ifdef TTY_DEBUG_HANGUP
694 char buf[64];
695 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
696#endif
697 schedule_work(&tty->hangup_work);
698}
699
700EXPORT_SYMBOL(tty_hangup);
701
702/**
703 * tty_vhangup - process vhangup
704 * @tty: tty to hangup
705 *
706 * The user has asked via system call for the terminal to be hung up.
707 * We do this synchronously so that when the syscall returns the process
708 * is complete. That guarantee is necessary for security reasons.
709 */
710
711void tty_vhangup(struct tty_struct *tty)
712{
713#ifdef TTY_DEBUG_HANGUP
714 char buf[64];
715
716 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
717#endif
718 __tty_hangup(tty);
719}
720
721EXPORT_SYMBOL(tty_vhangup);
722
723
724/**
725 * tty_vhangup_self - process vhangup for own ctty
726 *
727 * Perform a vhangup on the current controlling tty
728 */
729
730void tty_vhangup_self(void)
731{
732 struct tty_struct *tty;
733
734 tty = get_current_tty();
735 if (tty) {
736 tty_vhangup(tty);
737 tty_kref_put(tty);
738 }
739}
740
741/**
742 * tty_hung_up_p - was tty hung up
743 * @filp: file pointer of tty
744 *
745 * Return true if the tty has been subject to a vhangup or a carrier
746 * loss
747 */
748
749int tty_hung_up_p(struct file *filp)
750{
751 return (filp->f_op == &hung_up_tty_fops);
752}
753
754EXPORT_SYMBOL(tty_hung_up_p);
755
756static void session_clear_tty(struct pid *session)
757{
758 struct task_struct *p;
759 do_each_pid_task(session, PIDTYPE_SID, p) {
760 proc_clear_tty(p);
761 } while_each_pid_task(session, PIDTYPE_SID, p);
762}
763
764/**
765 * disassociate_ctty - disconnect controlling tty
766 * @on_exit: true if exiting so need to "hang up" the session
767 *
768 * This function is typically called only by the session leader, when
769 * it wants to disassociate itself from its controlling tty.
770 *
771 * It performs the following functions:
772 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
773 * (2) Clears the tty from being controlling the session
774 * (3) Clears the controlling tty for all processes in the
775 * session group.
776 *
777 * The argument on_exit is set to 1 if called when a process is
778 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
779 *
780 * Locking:
781 * BTM is taken for hysterical raisins, and held when
782 * called from no_tty().
783 * tty_mutex is taken to protect tty
784 * ->siglock is taken to protect ->signal/->sighand
785 * tasklist_lock is taken to walk process list for sessions
786 * ->siglock is taken to protect ->signal/->sighand
787 */
788
789void disassociate_ctty(int on_exit)
790{
791 struct tty_struct *tty;
792
793 if (!current->signal->leader)
794 return;
795
796 tty = get_current_tty();
797 if (tty) {
798 struct pid *tty_pgrp = get_pid(tty->pgrp);
799 if (on_exit) {
800 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
801 tty_vhangup(tty);
802 }
803 tty_kref_put(tty);
804 if (tty_pgrp) {
805 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
806 if (!on_exit)
807 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
808 put_pid(tty_pgrp);
809 }
810 } else if (on_exit) {
811 struct pid *old_pgrp;
812 spin_lock_irq(¤t->sighand->siglock);
813 old_pgrp = current->signal->tty_old_pgrp;
814 current->signal->tty_old_pgrp = NULL;
815 spin_unlock_irq(¤t->sighand->siglock);
816 if (old_pgrp) {
817 kill_pgrp(old_pgrp, SIGHUP, on_exit);
818 kill_pgrp(old_pgrp, SIGCONT, on_exit);
819 put_pid(old_pgrp);
820 }
821 return;
822 }
823
824 spin_lock_irq(¤t->sighand->siglock);
825 put_pid(current->signal->tty_old_pgrp);
826 current->signal->tty_old_pgrp = NULL;
827 spin_unlock_irq(¤t->sighand->siglock);
828
829 tty = get_current_tty();
830 if (tty) {
831 unsigned long flags;
832 spin_lock_irqsave(&tty->ctrl_lock, flags);
833 put_pid(tty->session);
834 put_pid(tty->pgrp);
835 tty->session = NULL;
836 tty->pgrp = NULL;
837 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
838 tty_kref_put(tty);
839 } else {
840#ifdef TTY_DEBUG_HANGUP
841 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
842 " = NULL", tty);
843#endif
844 }
845
846 /* Now clear signal->tty under the lock */
847 read_lock(&tasklist_lock);
848 session_clear_tty(task_session(current));
849 read_unlock(&tasklist_lock);
850}
851
852/**
853 *
854 * no_tty - Ensure the current process does not have a controlling tty
855 */
856void no_tty(void)
857{
858 /* FIXME: Review locking here. The tty_lock never covered any race
859 between a new association and proc_clear_tty but possible we need
860 to protect against this anyway */
861 struct task_struct *tsk = current;
862 disassociate_ctty(0);
863 proc_clear_tty(tsk);
864}
865
866
867/**
868 * stop_tty - propagate flow control
869 * @tty: tty to stop
870 *
871 * Perform flow control to the driver. For PTY/TTY pairs we
872 * must also propagate the TIOCKPKT status. May be called
873 * on an already stopped device and will not re-call the driver
874 * method.
875 *
876 * This functionality is used by both the line disciplines for
877 * halting incoming flow and by the driver. It may therefore be
878 * called from any context, may be under the tty atomic_write_lock
879 * but not always.
880 *
881 * Locking:
882 * Uses the tty control lock internally
883 */
884
885void stop_tty(struct tty_struct *tty)
886{
887 unsigned long flags;
888 spin_lock_irqsave(&tty->ctrl_lock, flags);
889 if (tty->stopped) {
890 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
891 return;
892 }
893 tty->stopped = 1;
894 if (tty->link && tty->link->packet) {
895 tty->ctrl_status &= ~TIOCPKT_START;
896 tty->ctrl_status |= TIOCPKT_STOP;
897 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
898 }
899 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
900 if (tty->ops->stop)
901 (tty->ops->stop)(tty);
902}
903
904EXPORT_SYMBOL(stop_tty);
905
906/**
907 * start_tty - propagate flow control
908 * @tty: tty to start
909 *
910 * Start a tty that has been stopped if at all possible. Perform
911 * any necessary wakeups and propagate the TIOCPKT status. If this
912 * is the tty was previous stopped and is being started then the
913 * driver start method is invoked and the line discipline woken.
914 *
915 * Locking:
916 * ctrl_lock
917 */
918
919void start_tty(struct tty_struct *tty)
920{
921 unsigned long flags;
922 spin_lock_irqsave(&tty->ctrl_lock, flags);
923 if (!tty->stopped || tty->flow_stopped) {
924 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
925 return;
926 }
927 tty->stopped = 0;
928 if (tty->link && tty->link->packet) {
929 tty->ctrl_status &= ~TIOCPKT_STOP;
930 tty->ctrl_status |= TIOCPKT_START;
931 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
932 }
933 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
934 if (tty->ops->start)
935 (tty->ops->start)(tty);
936 /* If we have a running line discipline it may need kicking */
937 tty_wakeup(tty);
938}
939
940EXPORT_SYMBOL(start_tty);
941
942/**
943 * tty_read - read method for tty device files
944 * @file: pointer to tty file
945 * @buf: user buffer
946 * @count: size of user buffer
947 * @ppos: unused
948 *
949 * Perform the read system call function on this terminal device. Checks
950 * for hung up devices before calling the line discipline method.
951 *
952 * Locking:
953 * Locks the line discipline internally while needed. Multiple
954 * read calls may be outstanding in parallel.
955 */
956
957static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
958 loff_t *ppos)
959{
960 int i;
961 struct inode *inode = file->f_path.dentry->d_inode;
962 struct tty_struct *tty = file_tty(file);
963 struct tty_ldisc *ld;
964
965 if (tty_paranoia_check(tty, inode, "tty_read"))
966 return -EIO;
967 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
968 return -EIO;
969
970 /* We want to wait for the line discipline to sort out in this
971 situation */
972 ld = tty_ldisc_ref_wait(tty);
973 if (ld->ops->read)
974 i = (ld->ops->read)(tty, file, buf, count);
975 else
976 i = -EIO;
977 tty_ldisc_deref(ld);
978 if (i > 0)
979 inode->i_atime = current_fs_time(inode->i_sb);
980 return i;
981}
982
983void tty_write_unlock(struct tty_struct *tty)
984 __releases(&tty->atomic_write_lock)
985{
986 mutex_unlock(&tty->atomic_write_lock);
987 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
988}
989
990int tty_write_lock(struct tty_struct *tty, int ndelay)
991 __acquires(&tty->atomic_write_lock)
992{
993 if (!mutex_trylock(&tty->atomic_write_lock)) {
994 if (ndelay)
995 return -EAGAIN;
996 if (mutex_lock_interruptible(&tty->atomic_write_lock))
997 return -ERESTARTSYS;
998 }
999 return 0;
1000}
1001
1002/*
1003 * Split writes up in sane blocksizes to avoid
1004 * denial-of-service type attacks
1005 */
1006static inline ssize_t do_tty_write(
1007 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1008 struct tty_struct *tty,
1009 struct file *file,
1010 const char __user *buf,
1011 size_t count)
1012{
1013 ssize_t ret, written = 0;
1014 unsigned int chunk;
1015
1016 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1017 if (ret < 0)
1018 return ret;
1019
1020 /*
1021 * We chunk up writes into a temporary buffer. This
1022 * simplifies low-level drivers immensely, since they
1023 * don't have locking issues and user mode accesses.
1024 *
1025 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1026 * big chunk-size..
1027 *
1028 * The default chunk-size is 2kB, because the NTTY
1029 * layer has problems with bigger chunks. It will
1030 * claim to be able to handle more characters than
1031 * it actually does.
1032 *
1033 * FIXME: This can probably go away now except that 64K chunks
1034 * are too likely to fail unless switched to vmalloc...
1035 */
1036 chunk = 2048;
1037 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1038 chunk = 65536;
1039 if (count < chunk)
1040 chunk = count;
1041
1042 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1043 if (tty->write_cnt < chunk) {
1044 unsigned char *buf_chunk;
1045
1046 if (chunk < 1024)
1047 chunk = 1024;
1048
1049 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1050 if (!buf_chunk) {
1051 ret = -ENOMEM;
1052 goto out;
1053 }
1054 kfree(tty->write_buf);
1055 tty->write_cnt = chunk;
1056 tty->write_buf = buf_chunk;
1057 }
1058
1059 /* Do the write .. */
1060 for (;;) {
1061 size_t size = count;
1062 if (size > chunk)
1063 size = chunk;
1064 ret = -EFAULT;
1065 if (copy_from_user(tty->write_buf, buf, size))
1066 break;
1067 ret = write(tty, file, tty->write_buf, size);
1068 if (ret <= 0)
1069 break;
1070 written += ret;
1071 buf += ret;
1072 count -= ret;
1073 if (!count)
1074 break;
1075 ret = -ERESTARTSYS;
1076 if (signal_pending(current))
1077 break;
1078 cond_resched();
1079 }
1080 if (written) {
1081 struct inode *inode = file->f_path.dentry->d_inode;
1082 inode->i_mtime = current_fs_time(inode->i_sb);
1083 ret = written;
1084 }
1085out:
1086 tty_write_unlock(tty);
1087 return ret;
1088}
1089
1090/**
1091 * tty_write_message - write a message to a certain tty, not just the console.
1092 * @tty: the destination tty_struct
1093 * @msg: the message to write
1094 *
1095 * This is used for messages that need to be redirected to a specific tty.
1096 * We don't put it into the syslog queue right now maybe in the future if
1097 * really needed.
1098 *
1099 * We must still hold the BTM and test the CLOSING flag for the moment.
1100 */
1101
1102void tty_write_message(struct tty_struct *tty, char *msg)
1103{
1104 if (tty) {
1105 mutex_lock(&tty->atomic_write_lock);
1106 tty_lock();
1107 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
1108 tty_unlock();
1109 tty->ops->write(tty, msg, strlen(msg));
1110 } else
1111 tty_unlock();
1112 tty_write_unlock(tty);
1113 }
1114 return;
1115}
1116
1117
1118/**
1119 * tty_write - write method for tty device file
1120 * @file: tty file pointer
1121 * @buf: user data to write
1122 * @count: bytes to write
1123 * @ppos: unused
1124 *
1125 * Write data to a tty device via the line discipline.
1126 *
1127 * Locking:
1128 * Locks the line discipline as required
1129 * Writes to the tty driver are serialized by the atomic_write_lock
1130 * and are then processed in chunks to the device. The line discipline
1131 * write method will not be invoked in parallel for each device.
1132 */
1133
1134static ssize_t tty_write(struct file *file, const char __user *buf,
1135 size_t count, loff_t *ppos)
1136{
1137 struct inode *inode = file->f_path.dentry->d_inode;
1138 struct tty_struct *tty = file_tty(file);
1139 struct tty_ldisc *ld;
1140 ssize_t ret;
1141
1142 if (tty_paranoia_check(tty, inode, "tty_write"))
1143 return -EIO;
1144 if (!tty || !tty->ops->write ||
1145 (test_bit(TTY_IO_ERROR, &tty->flags)))
1146 return -EIO;
1147 /* Short term debug to catch buggy drivers */
1148 if (tty->ops->write_room == NULL)
1149 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1150 tty->driver->name);
1151 ld = tty_ldisc_ref_wait(tty);
1152 if (!ld->ops->write)
1153 ret = -EIO;
1154 else
1155 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
1156 tty_ldisc_deref(ld);
1157 return ret;
1158}
1159
1160ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1161 size_t count, loff_t *ppos)
1162{
1163 struct file *p = NULL;
1164
1165 spin_lock(&redirect_lock);
1166 if (redirect) {
1167 get_file(redirect);
1168 p = redirect;
1169 }
1170 spin_unlock(&redirect_lock);
1171
1172 if (p) {
1173 ssize_t res;
1174 res = vfs_write(p, buf, count, &p->f_pos);
1175 fput(p);
1176 return res;
1177 }
1178 return tty_write(file, buf, count, ppos);
1179}
1180
1181static char ptychar[] = "pqrstuvwxyzabcde";
1182
1183/**
1184 * pty_line_name - generate name for a pty
1185 * @driver: the tty driver in use
1186 * @index: the minor number
1187 * @p: output buffer of at least 6 bytes
1188 *
1189 * Generate a name from a driver reference and write it to the output
1190 * buffer.
1191 *
1192 * Locking: None
1193 */
1194static void pty_line_name(struct tty_driver *driver, int index, char *p)
1195{
1196 int i = index + driver->name_base;
1197 /* ->name is initialized to "ttyp", but "tty" is expected */
1198 sprintf(p, "%s%c%x",
1199 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1200 ptychar[i >> 4 & 0xf], i & 0xf);
1201}
1202
1203/**
1204 * tty_line_name - generate name for a tty
1205 * @driver: the tty driver in use
1206 * @index: the minor number
1207 * @p: output buffer of at least 7 bytes
1208 *
1209 * Generate a name from a driver reference and write it to the output
1210 * buffer.
1211 *
1212 * Locking: None
1213 */
1214static void tty_line_name(struct tty_driver *driver, int index, char *p)
1215{
1216 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1217}
1218
1219/**
1220 * tty_driver_lookup_tty() - find an existing tty, if any
1221 * @driver: the driver for the tty
1222 * @idx: the minor number
1223 *
1224 * Return the tty, if found or ERR_PTR() otherwise.
1225 *
1226 * Locking: tty_mutex must be held. If tty is found, the mutex must
1227 * be held until the 'fast-open' is also done. Will change once we
1228 * have refcounting in the driver and per driver locking
1229 */
1230static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
1231 struct inode *inode, int idx)
1232{
1233 if (driver->ops->lookup)
1234 return driver->ops->lookup(driver, inode, idx);
1235
1236 return driver->ttys[idx];
1237}
1238
1239/**
1240 * tty_init_termios - helper for termios setup
1241 * @tty: the tty to set up
1242 *
1243 * Initialise the termios structures for this tty. Thus runs under
1244 * the tty_mutex currently so we can be relaxed about ordering.
1245 */
1246
1247int tty_init_termios(struct tty_struct *tty)
1248{
1249 struct ktermios *tp;
1250 int idx = tty->index;
1251
1252 tp = tty->driver->termios[idx];
1253 if (tp == NULL) {
1254 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1255 if (tp == NULL)
1256 return -ENOMEM;
1257 memcpy(tp, &tty->driver->init_termios,
1258 sizeof(struct ktermios));
1259 tty->driver->termios[idx] = tp;
1260 }
1261 tty->termios = tp;
1262 tty->termios_locked = tp + 1;
1263
1264 /* Compatibility until drivers always set this */
1265 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1266 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1267 return 0;
1268}
1269EXPORT_SYMBOL_GPL(tty_init_termios);
1270
1271int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1272{
1273 int ret = tty_init_termios(tty);
1274 if (ret)
1275 return ret;
1276
1277 tty_driver_kref_get(driver);
1278 tty->count++;
1279 driver->ttys[tty->index] = tty;
1280 return 0;
1281}
1282EXPORT_SYMBOL_GPL(tty_standard_install);
1283
1284/**
1285 * tty_driver_install_tty() - install a tty entry in the driver
1286 * @driver: the driver for the tty
1287 * @tty: the tty
1288 *
1289 * Install a tty object into the driver tables. The tty->index field
1290 * will be set by the time this is called. This method is responsible
1291 * for ensuring any need additional structures are allocated and
1292 * configured.
1293 *
1294 * Locking: tty_mutex for now
1295 */
1296static int tty_driver_install_tty(struct tty_driver *driver,
1297 struct tty_struct *tty)
1298{
1299 return driver->ops->install ? driver->ops->install(driver, tty) :
1300 tty_standard_install(driver, tty);
1301}
1302
1303/**
1304 * tty_driver_remove_tty() - remove a tty from the driver tables
1305 * @driver: the driver for the tty
1306 * @idx: the minor number
1307 *
1308 * Remvoe a tty object from the driver tables. The tty->index field
1309 * will be set by the time this is called.
1310 *
1311 * Locking: tty_mutex for now
1312 */
1313void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
1314{
1315 if (driver->ops->remove)
1316 driver->ops->remove(driver, tty);
1317 else
1318 driver->ttys[tty->index] = NULL;
1319}
1320
1321/*
1322 * tty_reopen() - fast re-open of an open tty
1323 * @tty - the tty to open
1324 *
1325 * Return 0 on success, -errno on error.
1326 *
1327 * Locking: tty_mutex must be held from the time the tty was found
1328 * till this open completes.
1329 */
1330static int tty_reopen(struct tty_struct *tty)
1331{
1332 struct tty_driver *driver = tty->driver;
1333
1334 if (test_bit(TTY_CLOSING, &tty->flags) ||
1335 test_bit(TTY_HUPPING, &tty->flags) ||
1336 test_bit(TTY_LDISC_CHANGING, &tty->flags))
1337 return -EIO;
1338
1339 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1340 driver->subtype == PTY_TYPE_MASTER) {
1341 /*
1342 * special case for PTY masters: only one open permitted,
1343 * and the slave side open count is incremented as well.
1344 */
1345 if (tty->count)
1346 return -EIO;
1347
1348 tty->link->count++;
1349 }
1350 tty->count++;
1351
1352 mutex_lock(&tty->ldisc_mutex);
1353 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
1354 mutex_unlock(&tty->ldisc_mutex);
1355
1356 return 0;
1357}
1358
1359/**
1360 * tty_init_dev - initialise a tty device
1361 * @driver: tty driver we are opening a device on
1362 * @idx: device index
1363 * @ret_tty: returned tty structure
1364 *
1365 * Prepare a tty device. This may not be a "new" clean device but
1366 * could also be an active device. The pty drivers require special
1367 * handling because of this.
1368 *
1369 * Locking:
1370 * The function is called under the tty_mutex, which
1371 * protects us from the tty struct or driver itself going away.
1372 *
1373 * On exit the tty device has the line discipline attached and
1374 * a reference count of 1. If a pair was created for pty/tty use
1375 * and the other was a pty master then it too has a reference count of 1.
1376 *
1377 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1378 * failed open. The new code protects the open with a mutex, so it's
1379 * really quite straightforward. The mutex locking can probably be
1380 * relaxed for the (most common) case of reopening a tty.
1381 */
1382
1383struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
1384{
1385 struct tty_struct *tty;
1386 int retval;
1387
1388 /*
1389 * First time open is complex, especially for PTY devices.
1390 * This code guarantees that either everything succeeds and the
1391 * TTY is ready for operation, or else the table slots are vacated
1392 * and the allocated memory released. (Except that the termios
1393 * and locked termios may be retained.)
1394 */
1395
1396 if (!try_module_get(driver->owner))
1397 return ERR_PTR(-ENODEV);
1398
1399 tty = alloc_tty_struct();
1400 if (!tty) {
1401 retval = -ENOMEM;
1402 goto err_module_put;
1403 }
1404 initialize_tty_struct(tty, driver, idx);
1405
1406 retval = tty_driver_install_tty(driver, tty);
1407 if (retval < 0)
1408 goto err_deinit_tty;
1409
1410 /*
1411 * Structures all installed ... call the ldisc open routines.
1412 * If we fail here just call release_tty to clean up. No need
1413 * to decrement the use counts, as release_tty doesn't care.
1414 */
1415 retval = tty_ldisc_setup(tty, tty->link);
1416 if (retval)
1417 goto err_release_tty;
1418 return tty;
1419
1420err_deinit_tty:
1421 deinitialize_tty_struct(tty);
1422 free_tty_struct(tty);
1423err_module_put:
1424 module_put(driver->owner);
1425 return ERR_PTR(retval);
1426
1427 /* call the tty release_tty routine to clean out this slot */
1428err_release_tty:
1429 printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
1430 "clearing slot %d\n", idx);
1431 release_tty(tty, idx);
1432 return ERR_PTR(retval);
1433}
1434
1435void tty_free_termios(struct tty_struct *tty)
1436{
1437 struct ktermios *tp;
1438 int idx = tty->index;
1439 /* Kill this flag and push into drivers for locking etc */
1440 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1441 /* FIXME: Locking on ->termios array */
1442 tp = tty->termios;
1443 tty->driver->termios[idx] = NULL;
1444 kfree(tp);
1445 }
1446}
1447EXPORT_SYMBOL(tty_free_termios);
1448
1449void tty_shutdown(struct tty_struct *tty)
1450{
1451 tty_driver_remove_tty(tty->driver, tty);
1452 tty_free_termios(tty);
1453}
1454EXPORT_SYMBOL(tty_shutdown);
1455
1456/**
1457 * release_one_tty - release tty structure memory
1458 * @kref: kref of tty we are obliterating
1459 *
1460 * Releases memory associated with a tty structure, and clears out the
1461 * driver table slots. This function is called when a device is no longer
1462 * in use. It also gets called when setup of a device fails.
1463 *
1464 * Locking:
1465 * tty_mutex - sometimes only
1466 * takes the file list lock internally when working on the list
1467 * of ttys that the driver keeps.
1468 *
1469 * This method gets called from a work queue so that the driver private
1470 * cleanup ops can sleep (needed for USB at least)
1471 */
1472static void release_one_tty(struct work_struct *work)
1473{
1474 struct tty_struct *tty =
1475 container_of(work, struct tty_struct, hangup_work);
1476 struct tty_driver *driver = tty->driver;
1477
1478 if (tty->ops->cleanup)
1479 tty->ops->cleanup(tty);
1480
1481 tty->magic = 0;
1482 tty_driver_kref_put(driver);
1483 module_put(driver->owner);
1484
1485 spin_lock(&tty_files_lock);
1486 list_del_init(&tty->tty_files);
1487 spin_unlock(&tty_files_lock);
1488
1489 put_pid(tty->pgrp);
1490 put_pid(tty->session);
1491 free_tty_struct(tty);
1492}
1493
1494static void queue_release_one_tty(struct kref *kref)
1495{
1496 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1497
1498 if (tty->ops->shutdown)
1499 tty->ops->shutdown(tty);
1500 else
1501 tty_shutdown(tty);
1502
1503 /* The hangup queue is now free so we can reuse it rather than
1504 waste a chunk of memory for each port */
1505 INIT_WORK(&tty->hangup_work, release_one_tty);
1506 schedule_work(&tty->hangup_work);
1507}
1508
1509/**
1510 * tty_kref_put - release a tty kref
1511 * @tty: tty device
1512 *
1513 * Release a reference to a tty device and if need be let the kref
1514 * layer destruct the object for us
1515 */
1516
1517void tty_kref_put(struct tty_struct *tty)
1518{
1519 if (tty)
1520 kref_put(&tty->kref, queue_release_one_tty);
1521}
1522EXPORT_SYMBOL(tty_kref_put);
1523
1524/**
1525 * release_tty - release tty structure memory
1526 *
1527 * Release both @tty and a possible linked partner (think pty pair),
1528 * and decrement the refcount of the backing module.
1529 *
1530 * Locking:
1531 * tty_mutex - sometimes only
1532 * takes the file list lock internally when working on the list
1533 * of ttys that the driver keeps.
1534 * FIXME: should we require tty_mutex is held here ??
1535 *
1536 */
1537static void release_tty(struct tty_struct *tty, int idx)
1538{
1539 /* This should always be true but check for the moment */
1540 WARN_ON(tty->index != idx);
1541
1542 if (tty->link)
1543 tty_kref_put(tty->link);
1544 tty_kref_put(tty);
1545}
1546
1547/**
1548 * tty_release_checks - check a tty before real release
1549 * @tty: tty to check
1550 * @o_tty: link of @tty (if any)
1551 * @idx: index of the tty
1552 *
1553 * Performs some paranoid checking before true release of the @tty.
1554 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1555 */
1556static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,
1557 int idx)
1558{
1559#ifdef TTY_PARANOIA_CHECK
1560 if (idx < 0 || idx >= tty->driver->num) {
1561 printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1562 __func__, tty->name);
1563 return -1;
1564 }
1565
1566 /* not much to check for devpts */
1567 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1568 return 0;
1569
1570 if (tty != tty->driver->ttys[idx]) {
1571 printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1572 __func__, idx, tty->name);
1573 return -1;
1574 }
1575 if (tty->termios != tty->driver->termios[idx]) {
1576 printk(KERN_DEBUG "%s: driver.termios[%d] not termios for (%s)\n",
1577 __func__, idx, tty->name);
1578 return -1;
1579 }
1580 if (tty->driver->other) {
1581 if (o_tty != tty->driver->other->ttys[idx]) {
1582 printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1583 __func__, idx, tty->name);
1584 return -1;
1585 }
1586 if (o_tty->termios != tty->driver->other->termios[idx]) {
1587 printk(KERN_DEBUG "%s: other->termios[%d] not o_termios for (%s)\n",
1588 __func__, idx, tty->name);
1589 return -1;
1590 }
1591 if (o_tty->link != tty) {
1592 printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
1593 return -1;
1594 }
1595 }
1596#endif
1597 return 0;
1598}
1599
1600/**
1601 * tty_release - vfs callback for close
1602 * @inode: inode of tty
1603 * @filp: file pointer for handle to tty
1604 *
1605 * Called the last time each file handle is closed that references
1606 * this tty. There may however be several such references.
1607 *
1608 * Locking:
1609 * Takes bkl. See tty_release_dev
1610 *
1611 * Even releasing the tty structures is a tricky business.. We have
1612 * to be very careful that the structures are all released at the
1613 * same time, as interrupts might otherwise get the wrong pointers.
1614 *
1615 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1616 * lead to double frees or releasing memory still in use.
1617 */
1618
1619int tty_release(struct inode *inode, struct file *filp)
1620{
1621 struct tty_struct *tty = file_tty(filp);
1622 struct tty_struct *o_tty;
1623 int pty_master, tty_closing, o_tty_closing, do_sleep;
1624 int devpts;
1625 int idx;
1626 char buf[64];
1627
1628 if (tty_paranoia_check(tty, inode, __func__))
1629 return 0;
1630
1631 tty_lock();
1632 check_tty_count(tty, __func__);
1633
1634 __tty_fasync(-1, filp, 0);
1635
1636 idx = tty->index;
1637 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1638 tty->driver->subtype == PTY_TYPE_MASTER);
1639 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1640 o_tty = tty->link;
1641
1642 if (tty_release_checks(tty, o_tty, idx)) {
1643 tty_unlock();
1644 return 0;
1645 }
1646
1647#ifdef TTY_DEBUG_HANGUP
1648 printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1649 tty_name(tty, buf), tty->count);
1650#endif
1651
1652 if (tty->ops->close)
1653 tty->ops->close(tty, filp);
1654
1655 tty_unlock();
1656 /*
1657 * Sanity check: if tty->count is going to zero, there shouldn't be
1658 * any waiters on tty->read_wait or tty->write_wait. We test the
1659 * wait queues and kick everyone out _before_ actually starting to
1660 * close. This ensures that we won't block while releasing the tty
1661 * structure.
1662 *
1663 * The test for the o_tty closing is necessary, since the master and
1664 * slave sides may close in any order. If the slave side closes out
1665 * first, its count will be one, since the master side holds an open.
1666 * Thus this test wouldn't be triggered at the time the slave closes,
1667 * so we do it now.
1668 *
1669 * Note that it's possible for the tty to be opened again while we're
1670 * flushing out waiters. By recalculating the closing flags before
1671 * each iteration we avoid any problems.
1672 */
1673 while (1) {
1674 /* Guard against races with tty->count changes elsewhere and
1675 opens on /dev/tty */
1676
1677 mutex_lock(&tty_mutex);
1678 tty_lock();
1679 tty_closing = tty->count <= 1;
1680 o_tty_closing = o_tty &&
1681 (o_tty->count <= (pty_master ? 1 : 0));
1682 do_sleep = 0;
1683
1684 if (tty_closing) {
1685 if (waitqueue_active(&tty->read_wait)) {
1686 wake_up_poll(&tty->read_wait, POLLIN);
1687 do_sleep++;
1688 }
1689 if (waitqueue_active(&tty->write_wait)) {
1690 wake_up_poll(&tty->write_wait, POLLOUT);
1691 do_sleep++;
1692 }
1693 }
1694 if (o_tty_closing) {
1695 if (waitqueue_active(&o_tty->read_wait)) {
1696 wake_up_poll(&o_tty->read_wait, POLLIN);
1697 do_sleep++;
1698 }
1699 if (waitqueue_active(&o_tty->write_wait)) {
1700 wake_up_poll(&o_tty->write_wait, POLLOUT);
1701 do_sleep++;
1702 }
1703 }
1704 if (!do_sleep)
1705 break;
1706
1707 printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1708 __func__, tty_name(tty, buf));
1709 tty_unlock();
1710 mutex_unlock(&tty_mutex);
1711 schedule();
1712 }
1713
1714 /*
1715 * The closing flags are now consistent with the open counts on
1716 * both sides, and we've completed the last operation that could
1717 * block, so it's safe to proceed with closing.
1718 */
1719 if (pty_master) {
1720 if (--o_tty->count < 0) {
1721 printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1722 __func__, o_tty->count, tty_name(o_tty, buf));
1723 o_tty->count = 0;
1724 }
1725 }
1726 if (--tty->count < 0) {
1727 printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1728 __func__, tty->count, tty_name(tty, buf));
1729 tty->count = 0;
1730 }
1731
1732 /*
1733 * We've decremented tty->count, so we need to remove this file
1734 * descriptor off the tty->tty_files list; this serves two
1735 * purposes:
1736 * - check_tty_count sees the correct number of file descriptors
1737 * associated with this tty.
1738 * - do_tty_hangup no longer sees this file descriptor as
1739 * something that needs to be handled for hangups.
1740 */
1741 tty_del_file(filp);
1742
1743 /*
1744 * Perform some housekeeping before deciding whether to return.
1745 *
1746 * Set the TTY_CLOSING flag if this was the last open. In the
1747 * case of a pty we may have to wait around for the other side
1748 * to close, and TTY_CLOSING makes sure we can't be reopened.
1749 */
1750 if (tty_closing)
1751 set_bit(TTY_CLOSING, &tty->flags);
1752 if (o_tty_closing)
1753 set_bit(TTY_CLOSING, &o_tty->flags);
1754
1755 /*
1756 * If _either_ side is closing, make sure there aren't any
1757 * processes that still think tty or o_tty is their controlling
1758 * tty.
1759 */
1760 if (tty_closing || o_tty_closing) {
1761 read_lock(&tasklist_lock);
1762 session_clear_tty(tty->session);
1763 if (o_tty)
1764 session_clear_tty(o_tty->session);
1765 read_unlock(&tasklist_lock);
1766 }
1767
1768 mutex_unlock(&tty_mutex);
1769
1770 /* check whether both sides are closing ... */
1771 if (!tty_closing || (o_tty && !o_tty_closing)) {
1772 tty_unlock();
1773 return 0;
1774 }
1775
1776#ifdef TTY_DEBUG_HANGUP
1777 printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__);
1778#endif
1779 /*
1780 * Ask the line discipline code to release its structures
1781 */
1782 tty_ldisc_release(tty, o_tty);
1783 /*
1784 * The release_tty function takes care of the details of clearing
1785 * the slots and preserving the termios structure.
1786 */
1787 release_tty(tty, idx);
1788
1789 /* Make this pty number available for reallocation */
1790 if (devpts)
1791 devpts_kill_index(inode, idx);
1792 tty_unlock();
1793 return 0;
1794}
1795
1796/**
1797 * tty_open_current_tty - get tty of current task for open
1798 * @device: device number
1799 * @filp: file pointer to tty
1800 * @return: tty of the current task iff @device is /dev/tty
1801 *
1802 * We cannot return driver and index like for the other nodes because
1803 * devpts will not work then. It expects inodes to be from devpts FS.
1804 *
1805 * We need to move to returning a refcounted object from all the lookup
1806 * paths including this one.
1807 */
1808static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1809{
1810 struct tty_struct *tty;
1811
1812 if (device != MKDEV(TTYAUX_MAJOR, 0))
1813 return NULL;
1814
1815 tty = get_current_tty();
1816 if (!tty)
1817 return ERR_PTR(-ENXIO);
1818
1819 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1820 /* noctty = 1; */
1821 tty_kref_put(tty);
1822 /* FIXME: we put a reference and return a TTY! */
1823 /* This is only safe because the caller holds tty_mutex */
1824 return tty;
1825}
1826
1827/**
1828 * tty_lookup_driver - lookup a tty driver for a given device file
1829 * @device: device number
1830 * @filp: file pointer to tty
1831 * @noctty: set if the device should not become a controlling tty
1832 * @index: index for the device in the @return driver
1833 * @return: driver for this inode (with increased refcount)
1834 *
1835 * If @return is not erroneous, the caller is responsible to decrement the
1836 * refcount by tty_driver_kref_put.
1837 *
1838 * Locking: tty_mutex protects get_tty_driver
1839 */
1840static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1841 int *noctty, int *index)
1842{
1843 struct tty_driver *driver;
1844
1845 switch (device) {
1846#ifdef CONFIG_VT
1847 case MKDEV(TTY_MAJOR, 0): {
1848 extern struct tty_driver *console_driver;
1849 driver = tty_driver_kref_get(console_driver);
1850 *index = fg_console;
1851 *noctty = 1;
1852 break;
1853 }
1854#endif
1855 case MKDEV(TTYAUX_MAJOR, 1): {
1856 struct tty_driver *console_driver = console_device(index);
1857 if (console_driver) {
1858 driver = tty_driver_kref_get(console_driver);
1859 if (driver) {
1860 /* Don't let /dev/console block */
1861 filp->f_flags |= O_NONBLOCK;
1862 *noctty = 1;
1863 break;
1864 }
1865 }
1866 return ERR_PTR(-ENODEV);
1867 }
1868 default:
1869 driver = get_tty_driver(device, index);
1870 if (!driver)
1871 return ERR_PTR(-ENODEV);
1872 break;
1873 }
1874 return driver;
1875}
1876
1877/**
1878 * tty_open - open a tty device
1879 * @inode: inode of device file
1880 * @filp: file pointer to tty
1881 *
1882 * tty_open and tty_release keep up the tty count that contains the
1883 * number of opens done on a tty. We cannot use the inode-count, as
1884 * different inodes might point to the same tty.
1885 *
1886 * Open-counting is needed for pty masters, as well as for keeping
1887 * track of serial lines: DTR is dropped when the last close happens.
1888 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1889 *
1890 * The termios state of a pty is reset on first open so that
1891 * settings don't persist across reuse.
1892 *
1893 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
1894 * tty->count should protect the rest.
1895 * ->siglock protects ->signal/->sighand
1896 */
1897
1898static int tty_open(struct inode *inode, struct file *filp)
1899{
1900 struct tty_struct *tty;
1901 int noctty, retval;
1902 struct tty_driver *driver = NULL;
1903 int index;
1904 dev_t device = inode->i_rdev;
1905 unsigned saved_flags = filp->f_flags;
1906
1907 nonseekable_open(inode, filp);
1908
1909retry_open:
1910 retval = tty_alloc_file(filp);
1911 if (retval)
1912 return -ENOMEM;
1913
1914 noctty = filp->f_flags & O_NOCTTY;
1915 index = -1;
1916 retval = 0;
1917
1918 mutex_lock(&tty_mutex);
1919 tty_lock();
1920
1921 tty = tty_open_current_tty(device, filp);
1922 if (IS_ERR(tty)) {
1923 retval = PTR_ERR(tty);
1924 goto err_unlock;
1925 } else if (!tty) {
1926 driver = tty_lookup_driver(device, filp, &noctty, &index);
1927 if (IS_ERR(driver)) {
1928 retval = PTR_ERR(driver);
1929 goto err_unlock;
1930 }
1931
1932 /* check whether we're reopening an existing tty */
1933 tty = tty_driver_lookup_tty(driver, inode, index);
1934 if (IS_ERR(tty)) {
1935 retval = PTR_ERR(tty);
1936 goto err_unlock;
1937 }
1938 }
1939
1940 if (tty) {
1941 retval = tty_reopen(tty);
1942 if (retval)
1943 tty = ERR_PTR(retval);
1944 } else
1945 tty = tty_init_dev(driver, index);
1946
1947 mutex_unlock(&tty_mutex);
1948 if (driver)
1949 tty_driver_kref_put(driver);
1950 if (IS_ERR(tty)) {
1951 tty_unlock();
1952 retval = PTR_ERR(tty);
1953 goto err_file;
1954 }
1955
1956 tty_add_file(tty, filp);
1957
1958 check_tty_count(tty, __func__);
1959 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1960 tty->driver->subtype == PTY_TYPE_MASTER)
1961 noctty = 1;
1962#ifdef TTY_DEBUG_HANGUP
1963 printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
1964#endif
1965 if (tty->ops->open)
1966 retval = tty->ops->open(tty, filp);
1967 else
1968 retval = -ENODEV;
1969 filp->f_flags = saved_flags;
1970
1971 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1972 !capable(CAP_SYS_ADMIN))
1973 retval = -EBUSY;
1974
1975 if (retval) {
1976#ifdef TTY_DEBUG_HANGUP
1977 printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
1978 retval, tty->name);
1979#endif
1980 tty_unlock(); /* need to call tty_release without BTM */
1981 tty_release(inode, filp);
1982 if (retval != -ERESTARTSYS)
1983 return retval;
1984
1985 if (signal_pending(current))
1986 return retval;
1987
1988 schedule();
1989 /*
1990 * Need to reset f_op in case a hangup happened.
1991 */
1992 tty_lock();
1993 if (filp->f_op == &hung_up_tty_fops)
1994 filp->f_op = &tty_fops;
1995 tty_unlock();
1996 goto retry_open;
1997 }
1998 tty_unlock();
1999
2000
2001 mutex_lock(&tty_mutex);
2002 tty_lock();
2003 spin_lock_irq(¤t->sighand->siglock);
2004 if (!noctty &&
2005 current->signal->leader &&
2006 !current->signal->tty &&
2007 tty->session == NULL)
2008 __proc_set_tty(current, tty);
2009 spin_unlock_irq(¤t->sighand->siglock);
2010 tty_unlock();
2011 mutex_unlock(&tty_mutex);
2012 return 0;
2013err_unlock:
2014 tty_unlock();
2015 mutex_unlock(&tty_mutex);
2016 /* after locks to avoid deadlock */
2017 if (!IS_ERR_OR_NULL(driver))
2018 tty_driver_kref_put(driver);
2019err_file:
2020 tty_free_file(filp);
2021 return retval;
2022}
2023
2024
2025
2026/**
2027 * tty_poll - check tty status
2028 * @filp: file being polled
2029 * @wait: poll wait structures to update
2030 *
2031 * Call the line discipline polling method to obtain the poll
2032 * status of the device.
2033 *
2034 * Locking: locks called line discipline but ldisc poll method
2035 * may be re-entered freely by other callers.
2036 */
2037
2038static unsigned int tty_poll(struct file *filp, poll_table *wait)
2039{
2040 struct tty_struct *tty = file_tty(filp);
2041 struct tty_ldisc *ld;
2042 int ret = 0;
2043
2044 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
2045 return 0;
2046
2047 ld = tty_ldisc_ref_wait(tty);
2048 if (ld->ops->poll)
2049 ret = (ld->ops->poll)(tty, filp, wait);
2050 tty_ldisc_deref(ld);
2051 return ret;
2052}
2053
2054static int __tty_fasync(int fd, struct file *filp, int on)
2055{
2056 struct tty_struct *tty = file_tty(filp);
2057 unsigned long flags;
2058 int retval = 0;
2059
2060 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
2061 goto out;
2062
2063 retval = fasync_helper(fd, filp, on, &tty->fasync);
2064 if (retval <= 0)
2065 goto out;
2066
2067 if (on) {
2068 enum pid_type type;
2069 struct pid *pid;
2070 if (!waitqueue_active(&tty->read_wait))
2071 tty->minimum_to_wake = 1;
2072 spin_lock_irqsave(&tty->ctrl_lock, flags);
2073 if (tty->pgrp) {
2074 pid = tty->pgrp;
2075 type = PIDTYPE_PGID;
2076 } else {
2077 pid = task_pid(current);
2078 type = PIDTYPE_PID;
2079 }
2080 get_pid(pid);
2081 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2082 retval = __f_setown(filp, pid, type, 0);
2083 put_pid(pid);
2084 if (retval)
2085 goto out;
2086 } else {
2087 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2088 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2089 }
2090 retval = 0;
2091out:
2092 return retval;
2093}
2094
2095static int tty_fasync(int fd, struct file *filp, int on)
2096{
2097 int retval;
2098 tty_lock();
2099 retval = __tty_fasync(fd, filp, on);
2100 tty_unlock();
2101 return retval;
2102}
2103
2104/**
2105 * tiocsti - fake input character
2106 * @tty: tty to fake input into
2107 * @p: pointer to character
2108 *
2109 * Fake input to a tty device. Does the necessary locking and
2110 * input management.
2111 *
2112 * FIXME: does not honour flow control ??
2113 *
2114 * Locking:
2115 * Called functions take tty_ldisc_lock
2116 * current->signal->tty check is safe without locks
2117 *
2118 * FIXME: may race normal receive processing
2119 */
2120
2121static int tiocsti(struct tty_struct *tty, char __user *p)
2122{
2123 char ch, mbz = 0;
2124 struct tty_ldisc *ld;
2125
2126 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2127 return -EPERM;
2128 if (get_user(ch, p))
2129 return -EFAULT;
2130 tty_audit_tiocsti(tty, ch);
2131 ld = tty_ldisc_ref_wait(tty);
2132 ld->ops->receive_buf(tty, &ch, &mbz, 1);
2133 tty_ldisc_deref(ld);
2134 return 0;
2135}
2136
2137/**
2138 * tiocgwinsz - implement window query ioctl
2139 * @tty; tty
2140 * @arg: user buffer for result
2141 *
2142 * Copies the kernel idea of the window size into the user buffer.
2143 *
2144 * Locking: tty->termios_mutex is taken to ensure the winsize data
2145 * is consistent.
2146 */
2147
2148static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
2149{
2150 int err;
2151
2152 mutex_lock(&tty->termios_mutex);
2153 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2154 mutex_unlock(&tty->termios_mutex);
2155
2156 return err ? -EFAULT: 0;
2157}
2158
2159/**
2160 * tty_do_resize - resize event
2161 * @tty: tty being resized
2162 * @rows: rows (character)
2163 * @cols: cols (character)
2164 *
2165 * Update the termios variables and send the necessary signals to
2166 * peform a terminal resize correctly
2167 */
2168
2169int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
2170{
2171 struct pid *pgrp;
2172 unsigned long flags;
2173
2174 /* Lock the tty */
2175 mutex_lock(&tty->termios_mutex);
2176 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2177 goto done;
2178 /* Get the PID values and reference them so we can
2179 avoid holding the tty ctrl lock while sending signals */
2180 spin_lock_irqsave(&tty->ctrl_lock, flags);
2181 pgrp = get_pid(tty->pgrp);
2182 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2183
2184 if (pgrp)
2185 kill_pgrp(pgrp, SIGWINCH, 1);
2186 put_pid(pgrp);
2187
2188 tty->winsize = *ws;
2189done:
2190 mutex_unlock(&tty->termios_mutex);
2191 return 0;
2192}
2193
2194/**
2195 * tiocswinsz - implement window size set ioctl
2196 * @tty; tty side of tty
2197 * @arg: user buffer for result
2198 *
2199 * Copies the user idea of the window size to the kernel. Traditionally
2200 * this is just advisory information but for the Linux console it
2201 * actually has driver level meaning and triggers a VC resize.
2202 *
2203 * Locking:
2204 * Driver dependent. The default do_resize method takes the
2205 * tty termios mutex and ctrl_lock. The console takes its own lock
2206 * then calls into the default method.
2207 */
2208
2209static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
2210{
2211 struct winsize tmp_ws;
2212 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2213 return -EFAULT;
2214
2215 if (tty->ops->resize)
2216 return tty->ops->resize(tty, &tmp_ws);
2217 else
2218 return tty_do_resize(tty, &tmp_ws);
2219}
2220
2221/**
2222 * tioccons - allow admin to move logical console
2223 * @file: the file to become console
2224 *
2225 * Allow the administrator to move the redirected console device
2226 *
2227 * Locking: uses redirect_lock to guard the redirect information
2228 */
2229
2230static int tioccons(struct file *file)
2231{
2232 if (!capable(CAP_SYS_ADMIN))
2233 return -EPERM;
2234 if (file->f_op->write == redirected_tty_write) {
2235 struct file *f;
2236 spin_lock(&redirect_lock);
2237 f = redirect;
2238 redirect = NULL;
2239 spin_unlock(&redirect_lock);
2240 if (f)
2241 fput(f);
2242 return 0;
2243 }
2244 spin_lock(&redirect_lock);
2245 if (redirect) {
2246 spin_unlock(&redirect_lock);
2247 return -EBUSY;
2248 }
2249 get_file(file);
2250 redirect = file;
2251 spin_unlock(&redirect_lock);
2252 return 0;
2253}
2254
2255/**
2256 * fionbio - non blocking ioctl
2257 * @file: file to set blocking value
2258 * @p: user parameter
2259 *
2260 * Historical tty interfaces had a blocking control ioctl before
2261 * the generic functionality existed. This piece of history is preserved
2262 * in the expected tty API of posix OS's.
2263 *
2264 * Locking: none, the open file handle ensures it won't go away.
2265 */
2266
2267static int fionbio(struct file *file, int __user *p)
2268{
2269 int nonblock;
2270
2271 if (get_user(nonblock, p))
2272 return -EFAULT;
2273
2274 spin_lock(&file->f_lock);
2275 if (nonblock)
2276 file->f_flags |= O_NONBLOCK;
2277 else
2278 file->f_flags &= ~O_NONBLOCK;
2279 spin_unlock(&file->f_lock);
2280 return 0;
2281}
2282
2283/**
2284 * tiocsctty - set controlling tty
2285 * @tty: tty structure
2286 * @arg: user argument
2287 *
2288 * This ioctl is used to manage job control. It permits a session
2289 * leader to set this tty as the controlling tty for the session.
2290 *
2291 * Locking:
2292 * Takes tty_mutex() to protect tty instance
2293 * Takes tasklist_lock internally to walk sessions
2294 * Takes ->siglock() when updating signal->tty
2295 */
2296
2297static int tiocsctty(struct tty_struct *tty, int arg)
2298{
2299 int ret = 0;
2300 if (current->signal->leader && (task_session(current) == tty->session))
2301 return ret;
2302
2303 mutex_lock(&tty_mutex);
2304 /*
2305 * The process must be a session leader and
2306 * not have a controlling tty already.
2307 */
2308 if (!current->signal->leader || current->signal->tty) {
2309 ret = -EPERM;
2310 goto unlock;
2311 }
2312
2313 if (tty->session) {
2314 /*
2315 * This tty is already the controlling
2316 * tty for another session group!
2317 */
2318 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
2319 /*
2320 * Steal it away
2321 */
2322 read_lock(&tasklist_lock);
2323 session_clear_tty(tty->session);
2324 read_unlock(&tasklist_lock);
2325 } else {
2326 ret = -EPERM;
2327 goto unlock;
2328 }
2329 }
2330 proc_set_tty(current, tty);
2331unlock:
2332 mutex_unlock(&tty_mutex);
2333 return ret;
2334}
2335
2336/**
2337 * tty_get_pgrp - return a ref counted pgrp pid
2338 * @tty: tty to read
2339 *
2340 * Returns a refcounted instance of the pid struct for the process
2341 * group controlling the tty.
2342 */
2343
2344struct pid *tty_get_pgrp(struct tty_struct *tty)
2345{
2346 unsigned long flags;
2347 struct pid *pgrp;
2348
2349 spin_lock_irqsave(&tty->ctrl_lock, flags);
2350 pgrp = get_pid(tty->pgrp);
2351 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2352
2353 return pgrp;
2354}
2355EXPORT_SYMBOL_GPL(tty_get_pgrp);
2356
2357/**
2358 * tiocgpgrp - get process group
2359 * @tty: tty passed by user
2360 * @real_tty: tty side of the tty passed by the user if a pty else the tty
2361 * @p: returned pid
2362 *
2363 * Obtain the process group of the tty. If there is no process group
2364 * return an error.
2365 *
2366 * Locking: none. Reference to current->signal->tty is safe.
2367 */
2368
2369static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2370{
2371 struct pid *pid;
2372 int ret;
2373 /*
2374 * (tty == real_tty) is a cheap way of
2375 * testing if the tty is NOT a master pty.
2376 */
2377 if (tty == real_tty && current->signal->tty != real_tty)
2378 return -ENOTTY;
2379 pid = tty_get_pgrp(real_tty);
2380 ret = put_user(pid_vnr(pid), p);
2381 put_pid(pid);
2382 return ret;
2383}
2384
2385/**
2386 * tiocspgrp - attempt to set process group
2387 * @tty: tty passed by user
2388 * @real_tty: tty side device matching tty passed by user
2389 * @p: pid pointer
2390 *
2391 * Set the process group of the tty to the session passed. Only
2392 * permitted where the tty session is our session.
2393 *
2394 * Locking: RCU, ctrl lock
2395 */
2396
2397static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2398{
2399 struct pid *pgrp;
2400 pid_t pgrp_nr;
2401 int retval = tty_check_change(real_tty);
2402 unsigned long flags;
2403
2404 if (retval == -EIO)
2405 return -ENOTTY;
2406 if (retval)
2407 return retval;
2408 if (!current->signal->tty ||
2409 (current->signal->tty != real_tty) ||
2410 (real_tty->session != task_session(current)))
2411 return -ENOTTY;
2412 if (get_user(pgrp_nr, p))
2413 return -EFAULT;
2414 if (pgrp_nr < 0)
2415 return -EINVAL;
2416 rcu_read_lock();
2417 pgrp = find_vpid(pgrp_nr);
2418 retval = -ESRCH;
2419 if (!pgrp)
2420 goto out_unlock;
2421 retval = -EPERM;
2422 if (session_of_pgrp(pgrp) != task_session(current))
2423 goto out_unlock;
2424 retval = 0;
2425 spin_lock_irqsave(&tty->ctrl_lock, flags);
2426 put_pid(real_tty->pgrp);
2427 real_tty->pgrp = get_pid(pgrp);
2428 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2429out_unlock:
2430 rcu_read_unlock();
2431 return retval;
2432}
2433
2434/**
2435 * tiocgsid - get session id
2436 * @tty: tty passed by user
2437 * @real_tty: tty side of the tty passed by the user if a pty else the tty
2438 * @p: pointer to returned session id
2439 *
2440 * Obtain the session id of the tty. If there is no session
2441 * return an error.
2442 *
2443 * Locking: none. Reference to current->signal->tty is safe.
2444 */
2445
2446static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2447{
2448 /*
2449 * (tty == real_tty) is a cheap way of
2450 * testing if the tty is NOT a master pty.
2451 */
2452 if (tty == real_tty && current->signal->tty != real_tty)
2453 return -ENOTTY;
2454 if (!real_tty->session)
2455 return -ENOTTY;
2456 return put_user(pid_vnr(real_tty->session), p);
2457}
2458
2459/**
2460 * tiocsetd - set line discipline
2461 * @tty: tty device
2462 * @p: pointer to user data
2463 *
2464 * Set the line discipline according to user request.
2465 *
2466 * Locking: see tty_set_ldisc, this function is just a helper
2467 */
2468
2469static int tiocsetd(struct tty_struct *tty, int __user *p)
2470{
2471 int ldisc;
2472 int ret;
2473
2474 if (get_user(ldisc, p))
2475 return -EFAULT;
2476
2477 ret = tty_set_ldisc(tty, ldisc);
2478
2479 return ret;
2480}
2481
2482/**
2483 * send_break - performed time break
2484 * @tty: device to break on
2485 * @duration: timeout in mS
2486 *
2487 * Perform a timed break on hardware that lacks its own driver level
2488 * timed break functionality.
2489 *
2490 * Locking:
2491 * atomic_write_lock serializes
2492 *
2493 */
2494
2495static int send_break(struct tty_struct *tty, unsigned int duration)
2496{
2497 int retval;
2498
2499 if (tty->ops->break_ctl == NULL)
2500 return 0;
2501
2502 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2503 retval = tty->ops->break_ctl(tty, duration);
2504 else {
2505 /* Do the work ourselves */
2506 if (tty_write_lock(tty, 0) < 0)
2507 return -EINTR;
2508 retval = tty->ops->break_ctl(tty, -1);
2509 if (retval)
2510 goto out;
2511 if (!signal_pending(current))
2512 msleep_interruptible(duration);
2513 retval = tty->ops->break_ctl(tty, 0);
2514out:
2515 tty_write_unlock(tty);
2516 if (signal_pending(current))
2517 retval = -EINTR;
2518 }
2519 return retval;
2520}
2521
2522/**
2523 * tty_tiocmget - get modem status
2524 * @tty: tty device
2525 * @file: user file pointer
2526 * @p: pointer to result
2527 *
2528 * Obtain the modem status bits from the tty driver if the feature
2529 * is supported. Return -EINVAL if it is not available.
2530 *
2531 * Locking: none (up to the driver)
2532 */
2533
2534static int tty_tiocmget(struct tty_struct *tty, int __user *p)
2535{
2536 int retval = -EINVAL;
2537
2538 if (tty->ops->tiocmget) {
2539 retval = tty->ops->tiocmget(tty);
2540
2541 if (retval >= 0)
2542 retval = put_user(retval, p);
2543 }
2544 return retval;
2545}
2546
2547/**
2548 * tty_tiocmset - set modem status
2549 * @tty: tty device
2550 * @cmd: command - clear bits, set bits or set all
2551 * @p: pointer to desired bits
2552 *
2553 * Set the modem status bits from the tty driver if the feature
2554 * is supported. Return -EINVAL if it is not available.
2555 *
2556 * Locking: none (up to the driver)
2557 */
2558
2559static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
2560 unsigned __user *p)
2561{
2562 int retval;
2563 unsigned int set, clear, val;
2564
2565 if (tty->ops->tiocmset == NULL)
2566 return -EINVAL;
2567
2568 retval = get_user(val, p);
2569 if (retval)
2570 return retval;
2571 set = clear = 0;
2572 switch (cmd) {
2573 case TIOCMBIS:
2574 set = val;
2575 break;
2576 case TIOCMBIC:
2577 clear = val;
2578 break;
2579 case TIOCMSET:
2580 set = val;
2581 clear = ~val;
2582 break;
2583 }
2584 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2585 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2586 return tty->ops->tiocmset(tty, set, clear);
2587}
2588
2589static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2590{
2591 int retval = -EINVAL;
2592 struct serial_icounter_struct icount;
2593 memset(&icount, 0, sizeof(icount));
2594 if (tty->ops->get_icount)
2595 retval = tty->ops->get_icount(tty, &icount);
2596 if (retval != 0)
2597 return retval;
2598 if (copy_to_user(arg, &icount, sizeof(icount)))
2599 return -EFAULT;
2600 return 0;
2601}
2602
2603struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2604{
2605 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2606 tty->driver->subtype == PTY_TYPE_MASTER)
2607 tty = tty->link;
2608 return tty;
2609}
2610EXPORT_SYMBOL(tty_pair_get_tty);
2611
2612struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2613{
2614 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2615 tty->driver->subtype == PTY_TYPE_MASTER)
2616 return tty;
2617 return tty->link;
2618}
2619EXPORT_SYMBOL(tty_pair_get_pty);
2620
2621/*
2622 * Split this up, as gcc can choke on it otherwise..
2623 */
2624long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2625{
2626 struct tty_struct *tty = file_tty(file);
2627 struct tty_struct *real_tty;
2628 void __user *p = (void __user *)arg;
2629 int retval;
2630 struct tty_ldisc *ld;
2631 struct inode *inode = file->f_dentry->d_inode;
2632
2633 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2634 return -EINVAL;
2635
2636 real_tty = tty_pair_get_tty(tty);
2637
2638 /*
2639 * Factor out some common prep work
2640 */
2641 switch (cmd) {
2642 case TIOCSETD:
2643 case TIOCSBRK:
2644 case TIOCCBRK:
2645 case TCSBRK:
2646 case TCSBRKP:
2647 retval = tty_check_change(tty);
2648 if (retval)
2649 return retval;
2650 if (cmd != TIOCCBRK) {
2651 tty_wait_until_sent(tty, 0);
2652 if (signal_pending(current))
2653 return -EINTR;
2654 }
2655 break;
2656 }
2657
2658 /*
2659 * Now do the stuff.
2660 */
2661 switch (cmd) {
2662 case TIOCSTI:
2663 return tiocsti(tty, p);
2664 case TIOCGWINSZ:
2665 return tiocgwinsz(real_tty, p);
2666 case TIOCSWINSZ:
2667 return tiocswinsz(real_tty, p);
2668 case TIOCCONS:
2669 return real_tty != tty ? -EINVAL : tioccons(file);
2670 case FIONBIO:
2671 return fionbio(file, p);
2672 case TIOCEXCL:
2673 set_bit(TTY_EXCLUSIVE, &tty->flags);
2674 return 0;
2675 case TIOCNXCL:
2676 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2677 return 0;
2678 case TIOCNOTTY:
2679 if (current->signal->tty != tty)
2680 return -ENOTTY;
2681 no_tty();
2682 return 0;
2683 case TIOCSCTTY:
2684 return tiocsctty(tty, arg);
2685 case TIOCGPGRP:
2686 return tiocgpgrp(tty, real_tty, p);
2687 case TIOCSPGRP:
2688 return tiocspgrp(tty, real_tty, p);
2689 case TIOCGSID:
2690 return tiocgsid(tty, real_tty, p);
2691 case TIOCGETD:
2692 return put_user(tty->ldisc->ops->num, (int __user *)p);
2693 case TIOCSETD:
2694 return tiocsetd(tty, p);
2695 case TIOCVHANGUP:
2696 if (!capable(CAP_SYS_ADMIN))
2697 return -EPERM;
2698 tty_vhangup(tty);
2699 return 0;
2700 case TIOCGDEV:
2701 {
2702 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2703 return put_user(ret, (unsigned int __user *)p);
2704 }
2705 /*
2706 * Break handling
2707 */
2708 case TIOCSBRK: /* Turn break on, unconditionally */
2709 if (tty->ops->break_ctl)
2710 return tty->ops->break_ctl(tty, -1);
2711 return 0;
2712 case TIOCCBRK: /* Turn break off, unconditionally */
2713 if (tty->ops->break_ctl)
2714 return tty->ops->break_ctl(tty, 0);
2715 return 0;
2716 case TCSBRK: /* SVID version: non-zero arg --> no break */
2717 /* non-zero arg means wait for all output data
2718 * to be sent (performed above) but don't send break.
2719 * This is used by the tcdrain() termios function.
2720 */
2721 if (!arg)
2722 return send_break(tty, 250);
2723 return 0;
2724 case TCSBRKP: /* support for POSIX tcsendbreak() */
2725 return send_break(tty, arg ? arg*100 : 250);
2726
2727 case TIOCMGET:
2728 return tty_tiocmget(tty, p);
2729 case TIOCMSET:
2730 case TIOCMBIC:
2731 case TIOCMBIS:
2732 return tty_tiocmset(tty, cmd, p);
2733 case TIOCGICOUNT:
2734 retval = tty_tiocgicount(tty, p);
2735 /* For the moment allow fall through to the old method */
2736 if (retval != -EINVAL)
2737 return retval;
2738 break;
2739 case TCFLSH:
2740 switch (arg) {
2741 case TCIFLUSH:
2742 case TCIOFLUSH:
2743 /* flush tty buffer and allow ldisc to process ioctl */
2744 tty_buffer_flush(tty);
2745 break;
2746 }
2747 break;
2748 }
2749 if (tty->ops->ioctl) {
2750 retval = (tty->ops->ioctl)(tty, cmd, arg);
2751 if (retval != -ENOIOCTLCMD)
2752 return retval;
2753 }
2754 ld = tty_ldisc_ref_wait(tty);
2755 retval = -EINVAL;
2756 if (ld->ops->ioctl) {
2757 retval = ld->ops->ioctl(tty, file, cmd, arg);
2758 if (retval == -ENOIOCTLCMD)
2759 retval = -EINVAL;
2760 }
2761 tty_ldisc_deref(ld);
2762 return retval;
2763}
2764
2765#ifdef CONFIG_COMPAT
2766static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2767 unsigned long arg)
2768{
2769 struct inode *inode = file->f_dentry->d_inode;
2770 struct tty_struct *tty = file_tty(file);
2771 struct tty_ldisc *ld;
2772 int retval = -ENOIOCTLCMD;
2773
2774 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2775 return -EINVAL;
2776
2777 if (tty->ops->compat_ioctl) {
2778 retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
2779 if (retval != -ENOIOCTLCMD)
2780 return retval;
2781 }
2782
2783 ld = tty_ldisc_ref_wait(tty);
2784 if (ld->ops->compat_ioctl)
2785 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2786 else
2787 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
2788 tty_ldisc_deref(ld);
2789
2790 return retval;
2791}
2792#endif
2793
2794/*
2795 * This implements the "Secure Attention Key" --- the idea is to
2796 * prevent trojan horses by killing all processes associated with this
2797 * tty when the user hits the "Secure Attention Key". Required for
2798 * super-paranoid applications --- see the Orange Book for more details.
2799 *
2800 * This code could be nicer; ideally it should send a HUP, wait a few
2801 * seconds, then send a INT, and then a KILL signal. But you then
2802 * have to coordinate with the init process, since all processes associated
2803 * with the current tty must be dead before the new getty is allowed
2804 * to spawn.
2805 *
2806 * Now, if it would be correct ;-/ The current code has a nasty hole -
2807 * it doesn't catch files in flight. We may send the descriptor to ourselves
2808 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2809 *
2810 * Nasty bug: do_SAK is being called in interrupt context. This can
2811 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2812 */
2813void __do_SAK(struct tty_struct *tty)
2814{
2815#ifdef TTY_SOFT_SAK
2816 tty_hangup(tty);
2817#else
2818 struct task_struct *g, *p;
2819 struct pid *session;
2820 int i;
2821 struct file *filp;
2822 struct fdtable *fdt;
2823
2824 if (!tty)
2825 return;
2826 session = tty->session;
2827
2828 tty_ldisc_flush(tty);
2829
2830 tty_driver_flush_buffer(tty);
2831
2832 read_lock(&tasklist_lock);
2833 /* Kill the entire session */
2834 do_each_pid_task(session, PIDTYPE_SID, p) {
2835 printk(KERN_NOTICE "SAK: killed process %d"
2836 " (%s): task_session(p)==tty->session\n",
2837 task_pid_nr(p), p->comm);
2838 send_sig(SIGKILL, p, 1);
2839 } while_each_pid_task(session, PIDTYPE_SID, p);
2840 /* Now kill any processes that happen to have the
2841 * tty open.
2842 */
2843 do_each_thread(g, p) {
2844 if (p->signal->tty == tty) {
2845 printk(KERN_NOTICE "SAK: killed process %d"
2846 " (%s): task_session(p)==tty->session\n",
2847 task_pid_nr(p), p->comm);
2848 send_sig(SIGKILL, p, 1);
2849 continue;
2850 }
2851 task_lock(p);
2852 if (p->files) {
2853 /*
2854 * We don't take a ref to the file, so we must
2855 * hold ->file_lock instead.
2856 */
2857 spin_lock(&p->files->file_lock);
2858 fdt = files_fdtable(p->files);
2859 for (i = 0; i < fdt->max_fds; i++) {
2860 filp = fcheck_files(p->files, i);
2861 if (!filp)
2862 continue;
2863 if (filp->f_op->read == tty_read &&
2864 file_tty(filp) == tty) {
2865 printk(KERN_NOTICE "SAK: killed process %d"
2866 " (%s): fd#%d opened to the tty\n",
2867 task_pid_nr(p), p->comm, i);
2868 force_sig(SIGKILL, p);
2869 break;
2870 }
2871 }
2872 spin_unlock(&p->files->file_lock);
2873 }
2874 task_unlock(p);
2875 } while_each_thread(g, p);
2876 read_unlock(&tasklist_lock);
2877#endif
2878}
2879
2880static void do_SAK_work(struct work_struct *work)
2881{
2882 struct tty_struct *tty =
2883 container_of(work, struct tty_struct, SAK_work);
2884 __do_SAK(tty);
2885}
2886
2887/*
2888 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2889 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2890 * the values which we write to it will be identical to the values which it
2891 * already has. --akpm
2892 */
2893void do_SAK(struct tty_struct *tty)
2894{
2895 if (!tty)
2896 return;
2897 schedule_work(&tty->SAK_work);
2898}
2899
2900EXPORT_SYMBOL(do_SAK);
2901
2902static int dev_match_devt(struct device *dev, void *data)
2903{
2904 dev_t *devt = data;
2905 return dev->devt == *devt;
2906}
2907
2908/* Must put_device() after it's unused! */
2909static struct device *tty_get_device(struct tty_struct *tty)
2910{
2911 dev_t devt = tty_devnum(tty);
2912 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2913}
2914
2915
2916/**
2917 * initialize_tty_struct
2918 * @tty: tty to initialize
2919 *
2920 * This subroutine initializes a tty structure that has been newly
2921 * allocated.
2922 *
2923 * Locking: none - tty in question must not be exposed at this point
2924 */
2925
2926void initialize_tty_struct(struct tty_struct *tty,
2927 struct tty_driver *driver, int idx)
2928{
2929 memset(tty, 0, sizeof(struct tty_struct));
2930 kref_init(&tty->kref);
2931 tty->magic = TTY_MAGIC;
2932 tty_ldisc_init(tty);
2933 tty->session = NULL;
2934 tty->pgrp = NULL;
2935 tty->overrun_time = jiffies;
2936 tty_buffer_init(tty);
2937 mutex_init(&tty->termios_mutex);
2938 mutex_init(&tty->ldisc_mutex);
2939 init_waitqueue_head(&tty->write_wait);
2940 init_waitqueue_head(&tty->read_wait);
2941 INIT_WORK(&tty->hangup_work, do_tty_hangup);
2942 mutex_init(&tty->atomic_read_lock);
2943 mutex_init(&tty->atomic_write_lock);
2944 mutex_init(&tty->output_lock);
2945 mutex_init(&tty->echo_lock);
2946 spin_lock_init(&tty->read_lock);
2947 spin_lock_init(&tty->ctrl_lock);
2948 INIT_LIST_HEAD(&tty->tty_files);
2949 INIT_WORK(&tty->SAK_work, do_SAK_work);
2950
2951 tty->driver = driver;
2952 tty->ops = driver->ops;
2953 tty->index = idx;
2954 tty_line_name(driver, idx, tty->name);
2955 tty->dev = tty_get_device(tty);
2956}
2957
2958/**
2959 * deinitialize_tty_struct
2960 * @tty: tty to deinitialize
2961 *
2962 * This subroutine deinitializes a tty structure that has been newly
2963 * allocated but tty_release cannot be called on that yet.
2964 *
2965 * Locking: none - tty in question must not be exposed at this point
2966 */
2967void deinitialize_tty_struct(struct tty_struct *tty)
2968{
2969 tty_ldisc_deinit(tty);
2970}
2971
2972/**
2973 * tty_put_char - write one character to a tty
2974 * @tty: tty
2975 * @ch: character
2976 *
2977 * Write one byte to the tty using the provided put_char method
2978 * if present. Returns the number of characters successfully output.
2979 *
2980 * Note: the specific put_char operation in the driver layer may go
2981 * away soon. Don't call it directly, use this method
2982 */
2983
2984int tty_put_char(struct tty_struct *tty, unsigned char ch)
2985{
2986 if (tty->ops->put_char)
2987 return tty->ops->put_char(tty, ch);
2988 return tty->ops->write(tty, &ch, 1);
2989}
2990EXPORT_SYMBOL_GPL(tty_put_char);
2991
2992struct class *tty_class;
2993
2994/**
2995 * tty_register_device - register a tty device
2996 * @driver: the tty driver that describes the tty device
2997 * @index: the index in the tty driver for this tty device
2998 * @device: a struct device that is associated with this tty device.
2999 * This field is optional, if there is no known struct device
3000 * for this tty device it can be set to NULL safely.
3001 *
3002 * Returns a pointer to the struct device for this tty device
3003 * (or ERR_PTR(-EFOO) on error).
3004 *
3005 * This call is required to be made to register an individual tty device
3006 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3007 * that bit is not set, this function should not be called by a tty
3008 * driver.
3009 *
3010 * Locking: ??
3011 */
3012
3013struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3014 struct device *device)
3015{
3016 char name[64];
3017 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3018
3019 if (index >= driver->num) {
3020 printk(KERN_ERR "Attempt to register invalid tty line number "
3021 " (%d).\n", index);
3022 return ERR_PTR(-EINVAL);
3023 }
3024
3025 if (driver->type == TTY_DRIVER_TYPE_PTY)
3026 pty_line_name(driver, index, name);
3027 else
3028 tty_line_name(driver, index, name);
3029
3030 return device_create(tty_class, device, dev, NULL, name);
3031}
3032EXPORT_SYMBOL(tty_register_device);
3033
3034/**
3035 * tty_unregister_device - unregister a tty device
3036 * @driver: the tty driver that describes the tty device
3037 * @index: the index in the tty driver for this tty device
3038 *
3039 * If a tty device is registered with a call to tty_register_device() then
3040 * this function must be called when the tty device is gone.
3041 *
3042 * Locking: ??
3043 */
3044
3045void tty_unregister_device(struct tty_driver *driver, unsigned index)
3046{
3047 device_destroy(tty_class,
3048 MKDEV(driver->major, driver->minor_start) + index);
3049}
3050EXPORT_SYMBOL(tty_unregister_device);
3051
3052struct tty_driver *__alloc_tty_driver(int lines, struct module *owner)
3053{
3054 struct tty_driver *driver;
3055
3056 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
3057 if (driver) {
3058 kref_init(&driver->kref);
3059 driver->magic = TTY_DRIVER_MAGIC;
3060 driver->num = lines;
3061 driver->owner = owner;
3062 /* later we'll move allocation of tables here */
3063 }
3064 return driver;
3065}
3066EXPORT_SYMBOL(__alloc_tty_driver);
3067
3068static void destruct_tty_driver(struct kref *kref)
3069{
3070 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3071 int i;
3072 struct ktermios *tp;
3073 void *p;
3074
3075 if (driver->flags & TTY_DRIVER_INSTALLED) {
3076 /*
3077 * Free the termios and termios_locked structures because
3078 * we don't want to get memory leaks when modular tty
3079 * drivers are removed from the kernel.
3080 */
3081 for (i = 0; i < driver->num; i++) {
3082 tp = driver->termios[i];
3083 if (tp) {
3084 driver->termios[i] = NULL;
3085 kfree(tp);
3086 }
3087 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3088 tty_unregister_device(driver, i);
3089 }
3090 p = driver->ttys;
3091 proc_tty_unregister_driver(driver);
3092 driver->ttys = NULL;
3093 driver->termios = NULL;
3094 kfree(p);
3095 cdev_del(&driver->cdev);
3096 }
3097 kfree(driver);
3098}
3099
3100void tty_driver_kref_put(struct tty_driver *driver)
3101{
3102 kref_put(&driver->kref, destruct_tty_driver);
3103}
3104EXPORT_SYMBOL(tty_driver_kref_put);
3105
3106void tty_set_operations(struct tty_driver *driver,
3107 const struct tty_operations *op)
3108{
3109 driver->ops = op;
3110};
3111EXPORT_SYMBOL(tty_set_operations);
3112
3113void put_tty_driver(struct tty_driver *d)
3114{
3115 tty_driver_kref_put(d);
3116}
3117EXPORT_SYMBOL(put_tty_driver);
3118
3119/*
3120 * Called by a tty driver to register itself.
3121 */
3122int tty_register_driver(struct tty_driver *driver)
3123{
3124 int error;
3125 int i;
3126 dev_t dev;
3127 void **p = NULL;
3128 struct device *d;
3129
3130 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
3131 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
3132 if (!p)
3133 return -ENOMEM;
3134 }
3135
3136 if (!driver->major) {
3137 error = alloc_chrdev_region(&dev, driver->minor_start,
3138 driver->num, driver->name);
3139 if (!error) {
3140 driver->major = MAJOR(dev);
3141 driver->minor_start = MINOR(dev);
3142 }
3143 } else {
3144 dev = MKDEV(driver->major, driver->minor_start);
3145 error = register_chrdev_region(dev, driver->num, driver->name);
3146 }
3147 if (error < 0) {
3148 kfree(p);
3149 return error;
3150 }
3151
3152 if (p) {
3153 driver->ttys = (struct tty_struct **)p;
3154 driver->termios = (struct ktermios **)(p + driver->num);
3155 } else {
3156 driver->ttys = NULL;
3157 driver->termios = NULL;
3158 }
3159
3160 cdev_init(&driver->cdev, &tty_fops);
3161 driver->cdev.owner = driver->owner;
3162 error = cdev_add(&driver->cdev, dev, driver->num);
3163 if (error) {
3164 unregister_chrdev_region(dev, driver->num);
3165 driver->ttys = NULL;
3166 driver->termios = NULL;
3167 kfree(p);
3168 return error;
3169 }
3170
3171 mutex_lock(&tty_mutex);
3172 list_add(&driver->tty_drivers, &tty_drivers);
3173 mutex_unlock(&tty_mutex);
3174
3175 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
3176 for (i = 0; i < driver->num; i++) {
3177 d = tty_register_device(driver, i, NULL);
3178 if (IS_ERR(d)) {
3179 error = PTR_ERR(d);
3180 goto err;
3181 }
3182 }
3183 }
3184 proc_tty_register_driver(driver);
3185 driver->flags |= TTY_DRIVER_INSTALLED;
3186 return 0;
3187
3188err:
3189 for (i--; i >= 0; i--)
3190 tty_unregister_device(driver, i);
3191
3192 mutex_lock(&tty_mutex);
3193 list_del(&driver->tty_drivers);
3194 mutex_unlock(&tty_mutex);
3195
3196 unregister_chrdev_region(dev, driver->num);
3197 driver->ttys = NULL;
3198 driver->termios = NULL;
3199 kfree(p);
3200 return error;
3201}
3202
3203EXPORT_SYMBOL(tty_register_driver);
3204
3205/*
3206 * Called by a tty driver to unregister itself.
3207 */
3208int tty_unregister_driver(struct tty_driver *driver)
3209{
3210#if 0
3211 /* FIXME */
3212 if (driver->refcount)
3213 return -EBUSY;
3214#endif
3215 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3216 driver->num);
3217 mutex_lock(&tty_mutex);
3218 list_del(&driver->tty_drivers);
3219 mutex_unlock(&tty_mutex);
3220 return 0;
3221}
3222
3223EXPORT_SYMBOL(tty_unregister_driver);
3224
3225dev_t tty_devnum(struct tty_struct *tty)
3226{
3227 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3228}
3229EXPORT_SYMBOL(tty_devnum);
3230
3231void proc_clear_tty(struct task_struct *p)
3232{
3233 unsigned long flags;
3234 struct tty_struct *tty;
3235 spin_lock_irqsave(&p->sighand->siglock, flags);
3236 tty = p->signal->tty;
3237 p->signal->tty = NULL;
3238 spin_unlock_irqrestore(&p->sighand->siglock, flags);
3239 tty_kref_put(tty);
3240}
3241
3242/* Called under the sighand lock */
3243
3244static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3245{
3246 if (tty) {
3247 unsigned long flags;
3248 /* We should not have a session or pgrp to put here but.... */
3249 spin_lock_irqsave(&tty->ctrl_lock, flags);
3250 put_pid(tty->session);
3251 put_pid(tty->pgrp);
3252 tty->pgrp = get_pid(task_pgrp(tsk));
3253 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3254 tty->session = get_pid(task_session(tsk));
3255 if (tsk->signal->tty) {
3256 printk(KERN_DEBUG "tty not NULL!!\n");
3257 tty_kref_put(tsk->signal->tty);
3258 }
3259 }
3260 put_pid(tsk->signal->tty_old_pgrp);
3261 tsk->signal->tty = tty_kref_get(tty);
3262 tsk->signal->tty_old_pgrp = NULL;
3263}
3264
3265static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3266{
3267 spin_lock_irq(&tsk->sighand->siglock);
3268 __proc_set_tty(tsk, tty);
3269 spin_unlock_irq(&tsk->sighand->siglock);
3270}
3271
3272struct tty_struct *get_current_tty(void)
3273{
3274 struct tty_struct *tty;
3275 unsigned long flags;
3276
3277 spin_lock_irqsave(¤t->sighand->siglock, flags);
3278 tty = tty_kref_get(current->signal->tty);
3279 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
3280 return tty;
3281}
3282EXPORT_SYMBOL_GPL(get_current_tty);
3283
3284void tty_default_fops(struct file_operations *fops)
3285{
3286 *fops = tty_fops;
3287}
3288
3289/*
3290 * Initialize the console device. This is called *early*, so
3291 * we can't necessarily depend on lots of kernel help here.
3292 * Just do some early initializations, and do the complex setup
3293 * later.
3294 */
3295void __init console_init(void)
3296{
3297 initcall_t *call;
3298
3299 /* Setup the default TTY line discipline. */
3300 tty_ldisc_begin();
3301
3302 /*
3303 * set up the console device so that later boot sequences can
3304 * inform about problems etc..
3305 */
3306 call = __con_initcall_start;
3307 while (call < __con_initcall_end) {
3308 (*call)();
3309 call++;
3310 }
3311}
3312
3313static char *tty_devnode(struct device *dev, umode_t *mode)
3314{
3315 if (!mode)
3316 return NULL;
3317 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3318 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3319 *mode = 0666;
3320 return NULL;
3321}
3322
3323static int __init tty_class_init(void)
3324{
3325 tty_class = class_create(THIS_MODULE, "tty");
3326 if (IS_ERR(tty_class))
3327 return PTR_ERR(tty_class);
3328 tty_class->devnode = tty_devnode;
3329 return 0;
3330}
3331
3332postcore_initcall(tty_class_init);
3333
3334/* 3/2004 jmc: why do these devices exist? */
3335static struct cdev tty_cdev, console_cdev;
3336
3337static ssize_t show_cons_active(struct device *dev,
3338 struct device_attribute *attr, char *buf)
3339{
3340 struct console *cs[16];
3341 int i = 0;
3342 struct console *c;
3343 ssize_t count = 0;
3344
3345 console_lock();
3346 for_each_console(c) {
3347 if (!c->device)
3348 continue;
3349 if (!c->write)
3350 continue;
3351 if ((c->flags & CON_ENABLED) == 0)
3352 continue;
3353 cs[i++] = c;
3354 if (i >= ARRAY_SIZE(cs))
3355 break;
3356 }
3357 while (i--)
3358 count += sprintf(buf + count, "%s%d%c",
3359 cs[i]->name, cs[i]->index, i ? ' ':'\n');
3360 console_unlock();
3361
3362 return count;
3363}
3364static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3365
3366static struct device *consdev;
3367
3368void console_sysfs_notify(void)
3369{
3370 if (consdev)
3371 sysfs_notify(&consdev->kobj, NULL, "active");
3372}
3373
3374/*
3375 * Ok, now we can initialize the rest of the tty devices and can count
3376 * on memory allocations, interrupts etc..
3377 */
3378int __init tty_init(void)
3379{
3380 cdev_init(&tty_cdev, &tty_fops);
3381 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3382 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3383 panic("Couldn't register /dev/tty driver\n");
3384 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3385
3386 cdev_init(&console_cdev, &console_fops);
3387 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3388 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3389 panic("Couldn't register /dev/console driver\n");
3390 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
3391 "console");
3392 if (IS_ERR(consdev))
3393 consdev = NULL;
3394 else
3395 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
3396
3397#ifdef CONFIG_VT
3398 vty_init(&console_fops);
3399#endif
3400 return 0;
3401}
3402