blob: 224f271d8cbe06868d69ce415339efa30f110d55 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/char/tty_io.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
8 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9 * or rs-channels. It also implements echoing, cooked mode etc.
10 *
11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12 *
13 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14 * tty_struct and tty_queue structures. Previously there was an array
15 * of 256 tty_struct's which was statically allocated, and the
16 * tty_queue structures were allocated at boot time. Both are now
17 * dynamically allocated only when the tty is open.
18 *
19 * Also restructured routines so that there is more of a separation
20 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21 * the low-level tty routines (serial.c, pty.c, console.c). This
Alan Cox37bdfb02008-02-08 04:18:47 -080022 * makes for cleaner and more compact code. -TYT, 9/17/92
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 *
24 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25 * which can be dynamically activated and de-activated by the line
26 * discipline handling modules (like SLIP).
27 *
28 * NOTE: pay no attention to the line discipline code (yet); its
29 * interface is still subject to change in this version...
30 * -- TYT, 1/31/92
31 *
32 * Added functionality to the OPOST tty handling. No delays, but all
33 * other bits should be there.
34 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
35 *
36 * Rewrote canonical mode and added more termios flags.
37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38 *
39 * Reorganized FASYNC support so mouse code can share it.
40 * -- ctm@ardi.com, 9Sep95
41 *
42 * New TIOCLINUX variants added.
43 * -- mj@k332.feld.cvut.cz, 19-Nov-95
Alan Cox37bdfb02008-02-08 04:18:47 -080044 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * Restrict vt switching via ioctl()
46 * -- grif@cs.ucr.edu, 5-Dec-95
47 *
48 * Move console and virtual terminal code to more appropriate files,
49 * implement CONFIG_VT and generalize console device interface.
50 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
51 *
Alan Coxd81ed102008-10-13 10:41:42 +010052 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 * -- Bill Hawes <whawes@star.net>, June 97
54 *
55 * Added devfs support.
56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
57 *
58 * Added support for a Unix98-style ptmx device.
59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
60 *
61 * Reduced memory usage for older ARM systems
62 * -- Russell King <rmk@arm.linux.org.uk>
63 *
64 * Move do_SAK() into process context. Less stack use in devfs functions.
Alan Cox37bdfb02008-02-08 04:18:47 -080065 * alloc_tty_struct() always uses kmalloc()
66 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 */
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/types.h>
70#include <linux/major.h>
71#include <linux/errno.h>
72#include <linux/signal.h>
73#include <linux/fcntl.h>
74#include <linux/sched.h>
75#include <linux/interrupt.h>
76#include <linux/tty.h>
77#include <linux/tty_driver.h>
78#include <linux/tty_flip.h>
79#include <linux/devpts_fs.h>
80#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040081#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#include <linux/console.h>
83#include <linux/timer.h>
84#include <linux/ctype.h>
85#include <linux/kd.h>
86#include <linux/mm.h>
87#include <linux/string.h>
88#include <linux/slab.h>
89#include <linux/poll.h>
90#include <linux/proc_fs.h>
91#include <linux/init.h>
92#include <linux/module.h>
93#include <linux/smp_lock.h>
94#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#include <linux/wait.h>
96#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070097#include <linux/delay.h>
Alan Coxa352def2008-07-16 21:53:12 +010098#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Alan Coxa352def2008-07-16 21:53:12 +0100100#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#include <asm/system.h>
102
103#include <linux/kbd_kern.h>
104#include <linux/vt_kern.h>
105#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107#include <linux/kmod.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700108#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110#undef TTY_DEBUG_HANGUP
111
112#define TTY_PARANOIA_CHECK 1
113#define CHECK_TTY_COUNT 1
114
Alan Coxedc6afc2006-12-08 02:38:44 -0800115struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 .c_iflag = ICRNL | IXON,
117 .c_oflag = OPOST | ONLCR,
118 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
119 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
120 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800121 .c_cc = INIT_C_CC,
122 .c_ispeed = 38400,
123 .c_ospeed = 38400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124};
125
126EXPORT_SYMBOL(tty_std_termios);
127
128/* This list gets poked at by procfs and various bits of boot up code. This
129 could do with some rationalisation such as pulling the tty proc function
130 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132LIST_HEAD(tty_drivers); /* linked list of tty drivers */
133
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800134/* Mutex to protect creating and releasing a tty. This is shared with
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 vt.c for deeply disgusting hack reasons */
Ingo Molnar70522e12006-03-23 03:00:31 -0800136DEFINE_MUTEX(tty_mutex);
Alan Coxde2a84f2006-09-29 02:00:57 -0700137EXPORT_SYMBOL(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
140static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800141ssize_t redirected_tty_write(struct file *, const char __user *,
142 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143static unsigned int tty_poll(struct file *, poll_table *);
144static int tty_open(struct inode *, struct file *);
145static int tty_release(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700146long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700147#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800148static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700149 unsigned long arg);
150#else
151#define tty_compat_ioctl NULL
152#endif
Alan Cox37bdfb02008-02-08 04:18:47 -0800153static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800154static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700155static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700156static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Alan Coxaf9b8972006-08-27 01:24:01 -0700158/**
159 * alloc_tty_struct - allocate a tty object
160 *
161 * Return a new empty tty structure. The data fields have not
162 * been initialized in any way but has been zeroed
163 *
164 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700165 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Alan Coxbf970ee2008-10-13 10:42:39 +0100167struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Alan Cox1266b1e2006-09-29 02:00:40 -0700169 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170}
171
Alan Coxaf9b8972006-08-27 01:24:01 -0700172/**
173 * free_tty_struct - free a disused tty
174 * @tty: tty struct to free
175 *
176 * Free the write buffers, tty queue and tty memory itself.
177 *
178 * Locking: none. Must be called after tty is definitely unused
179 */
180
Alan Coxbf970ee2008-10-13 10:42:39 +0100181void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182{
183 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800184 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 kfree(tty);
186}
187
188#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
189
Alan Coxaf9b8972006-08-27 01:24:01 -0700190/**
191 * tty_name - return tty naming
192 * @tty: tty structure
193 * @buf: buffer for output
194 *
195 * Convert a tty structure into a name. The name reflects the kernel
196 * naming policy and if udev is in use may not reflect user space
197 *
198 * Locking: none
199 */
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201char *tty_name(struct tty_struct *tty, char *buf)
202{
203 if (!tty) /* Hmm. NULL pointer. That's fun. */
204 strcpy(buf, "NULL tty");
205 else
206 strcpy(buf, tty->name);
207 return buf;
208}
209
210EXPORT_SYMBOL(tty_name);
211
Andrew Mortond769a662005-05-05 16:15:50 -0700212int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 const char *routine)
214{
215#ifdef TTY_PARANOIA_CHECK
216 if (!tty) {
217 printk(KERN_WARNING
218 "null TTY for (%d:%d) in %s\n",
219 imajor(inode), iminor(inode), routine);
220 return 1;
221 }
222 if (tty->magic != TTY_MAGIC) {
223 printk(KERN_WARNING
224 "bad magic number for tty struct (%d:%d) in %s\n",
225 imajor(inode), iminor(inode), routine);
226 return 1;
227 }
228#endif
229 return 0;
230}
231
232static int check_tty_count(struct tty_struct *tty, const char *routine)
233{
234#ifdef CHECK_TTY_COUNT
235 struct list_head *p;
236 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 file_list_lock();
239 list_for_each(p, &tty->tty_files) {
240 count++;
241 }
242 file_list_unlock();
243 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
244 tty->driver->subtype == PTY_TYPE_SLAVE &&
245 tty->link && tty->link->count)
246 count++;
247 if (tty->count != count) {
248 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
249 "!= #fd's(%d) in %s\n",
250 tty->name, tty->count, count, routine);
251 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253#endif
254 return 0;
255}
256
Alan Coxaf9b8972006-08-27 01:24:01 -0700257/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700258 * get_tty_driver - find device of a tty
259 * @dev_t: device identifier
260 * @index: returns the index of the tty
261 *
262 * This routine returns a tty driver structure, given a device number
263 * and also passes back the index number.
264 *
265 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268static struct tty_driver *get_tty_driver(dev_t device, int *index)
269{
270 struct tty_driver *p;
271
272 list_for_each_entry(p, &tty_drivers, tty_drivers) {
273 dev_t base = MKDEV(p->major, p->minor_start);
274 if (device < base || device >= base + p->num)
275 continue;
276 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100277 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 }
279 return NULL;
280}
281
Jason Wesself2d937f2008-04-17 20:05:37 +0200282#ifdef CONFIG_CONSOLE_POLL
283
284/**
285 * tty_find_polling_driver - find device of a polled tty
286 * @name: name string to match
287 * @line: pointer to resulting tty line nr
288 *
289 * This routine returns a tty driver structure, given a name
290 * and the condition that the tty driver is capable of polled
291 * operation.
292 */
293struct tty_driver *tty_find_polling_driver(char *name, int *line)
294{
295 struct tty_driver *p, *res = NULL;
296 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500297 int len;
Jason Wesself2d937f2008-04-17 20:05:37 +0200298 char *str;
299
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500300 for (str = name; *str; str++)
301 if ((*str >= '0' && *str <= '9') || *str == ',')
302 break;
303 if (!*str)
304 return NULL;
305
306 len = str - name;
307 tty_line = simple_strtoul(str, &str, 10);
308
Jason Wesself2d937f2008-04-17 20:05:37 +0200309 mutex_lock(&tty_mutex);
310 /* Search through the tty devices to look for a match */
311 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500312 if (strncmp(name, p->name, len) != 0)
313 continue;
Jason Wesself2d937f2008-04-17 20:05:37 +0200314 if (*str == ',')
315 str++;
316 if (*str == '\0')
Harvey Harrison8da56302008-04-28 14:13:20 -0700317 str = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200318
Alan Coxf34d7a52008-04-30 00:54:13 -0700319 if (tty_line >= 0 && tty_line <= p->num && p->ops &&
320 p->ops->poll_init && !p->ops->poll_init(p, tty_line, str)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100321 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200322 *line = tty_line;
323 break;
324 }
325 }
326 mutex_unlock(&tty_mutex);
327
328 return res;
329}
330EXPORT_SYMBOL_GPL(tty_find_polling_driver);
331#endif
332
Alan Coxaf9b8972006-08-27 01:24:01 -0700333/**
334 * tty_check_change - check for POSIX terminal changes
335 * @tty: tty to check
336 *
337 * If we try to write to, or set the state of, a terminal and we're
338 * not in the foreground, send a SIGTTOU. If the signal is blocked or
339 * ignored, go ahead and perform the operation. (POSIX 7.2)
340 *
Alan Cox978e5952008-04-30 00:53:59 -0700341 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700343
Alan Cox37bdfb02008-02-08 04:18:47 -0800344int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345{
Alan Cox47f86832008-04-30 00:53:30 -0700346 unsigned long flags;
347 int ret = 0;
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 if (current->signal->tty != tty)
350 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700351
352 spin_lock_irqsave(&tty->ctrl_lock, flags);
353
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800354 if (!tty->pgrp) {
355 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700356 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800358 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700359 goto out_unlock;
360 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700362 goto out;
363 if (is_current_pgrp_orphaned()) {
364 ret = -EIO;
365 goto out;
366 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700367 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
368 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700369 ret = -ERESTARTSYS;
370out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700371 return ret;
372out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700373 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
374 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375}
376
377EXPORT_SYMBOL(tty_check_change);
378
Alan Cox37bdfb02008-02-08 04:18:47 -0800379static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 size_t count, loff_t *ppos)
381{
382 return 0;
383}
384
Alan Cox37bdfb02008-02-08 04:18:47 -0800385static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 size_t count, loff_t *ppos)
387{
388 return -EIO;
389}
390
391/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800392static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
394 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
395}
396
Alan Cox04f378b2008-04-30 00:53:29 -0700397static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
398 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700399{
400 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
401}
402
Alan Cox37bdfb02008-02-08 04:18:47 -0800403static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700404 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
406 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
407}
408
Arjan van de Ven62322d22006-07-03 00:24:21 -0700409static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 .llseek = no_llseek,
411 .read = tty_read,
412 .write = tty_write,
413 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700414 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700415 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 .open = tty_open,
417 .release = tty_release,
418 .fasync = tty_fasync,
419};
420
Arjan van de Ven62322d22006-07-03 00:24:21 -0700421static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 .llseek = no_llseek,
423 .read = tty_read,
424 .write = redirected_tty_write,
425 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700426 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700427 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 .open = tty_open,
429 .release = tty_release,
430 .fasync = tty_fasync,
431};
432
Arjan van de Ven62322d22006-07-03 00:24:21 -0700433static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 .llseek = no_llseek,
435 .read = hung_up_tty_read,
436 .write = hung_up_tty_write,
437 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700438 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700439 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 .release = tty_release,
441};
442
443static DEFINE_SPINLOCK(redirect_lock);
444static struct file *redirect;
445
446/**
447 * tty_wakeup - request more data
448 * @tty: terminal
449 *
450 * Internal and external helper for wakeups of tty. This function
451 * informs the line discipline if present that the driver is ready
452 * to receive more output data.
453 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455void tty_wakeup(struct tty_struct *tty)
456{
457 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
460 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800461 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100462 if (ld->ops->write_wakeup)
463 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 tty_ldisc_deref(ld);
465 }
466 }
467 wake_up_interruptible(&tty->write_wait);
468}
469
470EXPORT_SYMBOL_GPL(tty_wakeup);
471
472/**
473 * tty_ldisc_flush - flush line discipline queue
474 * @tty: tty
475 *
476 * Flush the line discipline queue (if any) for this tty. If there
477 * is no line discipline active this is a no-op.
478 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480void tty_ldisc_flush(struct tty_struct *tty)
481{
482 struct tty_ldisc *ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800483 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100484 if (ld->ops->flush_buffer)
485 ld->ops->flush_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 tty_ldisc_deref(ld);
487 }
Paul Fulghumc5c34d42007-05-12 10:36:55 -0700488 tty_buffer_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489}
490
491EXPORT_SYMBOL_GPL(tty_ldisc_flush);
Alan Coxedc6afc2006-12-08 02:38:44 -0800492
493/**
494 * tty_reset_termios - reset terminal state
495 * @tty: tty to reset
496 *
497 * Restore a terminal to the driver default state
498 */
499
500static void tty_reset_termios(struct tty_struct *tty)
501{
502 mutex_lock(&tty->termios_mutex);
503 *tty->termios = tty->driver->init_termios;
504 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
505 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
506 mutex_unlock(&tty->termios_mutex);
507}
Alan Cox37bdfb02008-02-08 04:18:47 -0800508
Alan Coxaf9b8972006-08-27 01:24:01 -0700509/**
510 * do_tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000511 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700512 *
Alan Cox1bad8792008-07-22 23:38:04 +0100513 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700514 * synchronous but doesn't hold any locks, so we need to make sure we
515 * have the appropriate locks for what we're doing.
516 *
517 * The hangup event clears any pending redirections onto the hung up
518 * device. It ensures future writes will error and it does the needed
519 * line discipline hangup and signal delivery. The tty object itself
520 * remains intact.
521 *
522 * Locking:
523 * BKL
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800524 * redirect lock for undoing redirection
525 * file list lock for manipulating list of ttys
526 * tty_ldisc_lock from called functions
527 * termios_mutex resetting termios data
528 * tasklist_lock to walk task list for hangup event
529 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 */
David Howells65f27f32006-11-22 14:55:48 +0000531static void do_tty_hangup(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532{
David Howells65f27f32006-11-22 14:55:48 +0000533 struct tty_struct *tty =
534 container_of(work, struct tty_struct, hangup_work);
Alan Cox37bdfb02008-02-08 04:18:47 -0800535 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 struct file *filp, *f = NULL;
537 struct task_struct *p;
538 struct tty_ldisc *ld;
539 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700540 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100541 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
543 if (!tty)
544 return;
545
546 /* inuse_filps is protected by the single kernel lock */
547 lock_kernel();
548
549 spin_lock(&redirect_lock);
550 if (redirect && redirect->private_data == tty) {
551 f = redirect;
552 redirect = NULL;
553 }
554 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 check_tty_count(tty, "do_tty_hangup");
557 file_list_lock();
558 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Eric Dumazet2f512012005-10-30 15:02:16 -0800559 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if (filp->f_op->write == redirected_tty_write)
561 cons_filp = filp;
562 if (filp->f_op->write != tty_write)
563 continue;
564 closecount++;
565 tty_fasync(-1, filp, 0); /* can't block */
566 filp->f_op = &hung_up_tty_fops;
567 }
568 file_list_unlock();
Alan Cox37bdfb02008-02-08 04:18:47 -0800569 /*
570 * FIXME! What are the locking issues here? This may me overdoing
571 * things... This question is especially important now that we've
572 * removed the irqlock.
573 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800575 if (ld != NULL) {
576 /* We may have no line discipline at this point */
Alan Coxa352def2008-07-16 21:53:12 +0100577 if (ld->ops->flush_buffer)
578 ld->ops->flush_buffer(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -0700579 tty_driver_flush_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
Alan Coxa352def2008-07-16 21:53:12 +0100581 ld->ops->write_wakeup)
582 ld->ops->write_wakeup(tty);
583 if (ld->ops->hangup)
584 ld->ops->hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 }
Alan Cox37bdfb02008-02-08 04:18:47 -0800586 /*
587 * FIXME: Once we trust the LDISC code better we can wait here for
588 * ldisc completion and fix the driver call race
589 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 wake_up_interruptible(&tty->write_wait);
591 wake_up_interruptible(&tty->read_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 /*
593 * Shutdown the current line discipline, and reset it to
594 * N_TTY.
595 */
596 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
Alan Coxedc6afc2006-12-08 02:38:44 -0800597 tty_reset_termios(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 /* Defer ldisc switch */
599 /* tty_deferred_ldisc_switch(N_TTY);
Alan Cox37bdfb02008-02-08 04:18:47 -0800600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 This should get done automatically when the port closes and
602 tty_release is called */
Alan Cox37bdfb02008-02-08 04:18:47 -0800603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800605 if (tty->session) {
606 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800607 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100608 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100610 /* We defer the dereferences outside fo
611 the tasklist lock */
612 refs++;
613 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800614 if (!p->signal->leader) {
615 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800617 }
618 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
619 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800620 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700621 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800622 if (tty->pgrp)
623 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700624 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800625 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800626 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 }
628 read_unlock(&tasklist_lock);
629
Alan Cox47f86832008-04-30 00:53:30 -0700630 spin_lock_irqsave(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 tty->flags = 0;
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600632 put_pid(tty->session);
633 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800634 tty->session = NULL;
635 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 tty->ctrl_status = 0;
Alan Cox47f86832008-04-30 00:53:30 -0700637 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
638
Alan Cox9c9f4de2008-10-13 10:37:26 +0100639 /* Account for the p->signal references we killed */
640 while (refs--)
641 tty_kref_put(tty);
642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800644 * If one of the devices matches a console pointer, we
645 * cannot just call hangup() because that will cause
646 * tty->count and state->count to go out of sync.
647 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 */
649 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700650 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700652 tty->ops->close(tty, cons_filp);
653 } else if (tty->ops->hangup)
654 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800655 /*
656 * We don't want to have driver/ldisc interactions beyond
657 * the ones we did here. The driver layer expects no
658 * calls after ->hangup() from the ldisc side. However we
659 * can't yet guarantee all that.
660 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 set_bit(TTY_HUPPED, &tty->flags);
662 if (ld) {
663 tty_ldisc_enable(tty);
664 tty_ldisc_deref(ld);
665 }
666 unlock_kernel();
667 if (f)
668 fput(f);
669}
670
Alan Coxaf9b8972006-08-27 01:24:01 -0700671/**
672 * tty_hangup - trigger a hangup event
673 * @tty: tty to hangup
674 *
675 * A carrier loss (virtual or otherwise) has occurred on this like
676 * schedule a hangup sequence to run after this event.
677 */
678
Alan Cox37bdfb02008-02-08 04:18:47 -0800679void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680{
681#ifdef TTY_DEBUG_HANGUP
682 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
684#endif
685 schedule_work(&tty->hangup_work);
686}
687
688EXPORT_SYMBOL(tty_hangup);
689
Alan Coxaf9b8972006-08-27 01:24:01 -0700690/**
691 * tty_vhangup - process vhangup
692 * @tty: tty to hangup
693 *
694 * The user has asked via system call for the terminal to be hung up.
695 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200696 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700697 */
698
Alan Cox37bdfb02008-02-08 04:18:47 -0800699void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
701#ifdef TTY_DEBUG_HANGUP
702 char buf[64];
703
704 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
705#endif
David Howells65f27f32006-11-22 14:55:48 +0000706 do_tty_hangup(&tty->hangup_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
Alan Cox37bdfb02008-02-08 04:18:47 -0800708
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709EXPORT_SYMBOL(tty_vhangup);
710
Alan Coxaf9b8972006-08-27 01:24:01 -0700711/**
Alan Cox2cb59982008-10-13 10:40:30 +0100712 * tty_vhangup_self - process vhangup for own ctty
713 *
714 * Perform a vhangup on the current controlling tty
715 */
716
717void tty_vhangup_self(void)
718{
719 struct tty_struct *tty;
720
Alan Cox2cb59982008-10-13 10:40:30 +0100721 tty = get_current_tty();
722 if (tty) {
723 tty_vhangup(tty);
724 tty_kref_put(tty);
725 }
Alan Cox2cb59982008-10-13 10:40:30 +0100726}
727
728/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700729 * tty_hung_up_p - was tty hung up
730 * @filp: file pointer of tty
731 *
732 * Return true if the tty has been subject to a vhangup or a carrier
733 * loss
734 */
735
Alan Cox37bdfb02008-02-08 04:18:47 -0800736int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
738 return (filp->f_op == &hung_up_tty_fops);
739}
740
741EXPORT_SYMBOL(tty_hung_up_p);
742
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800743static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800744{
745 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800746 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800747 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800748 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800749}
750
Alan Coxaf9b8972006-08-27 01:24:01 -0700751/**
752 * disassociate_ctty - disconnect controlling tty
753 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700755 * This function is typically called only by the session leader, when
756 * it wants to disassociate itself from its controlling tty.
757 *
758 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
760 * (2) Clears the tty from being controlling the session
761 * (3) Clears the controlling tty for all processes in the
762 * session group.
763 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700764 * The argument on_exit is set to 1 if called when a process is
765 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
766 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800767 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -0700768 * BKL is taken for hysterical raisins
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800769 * tty_mutex is taken to protect tty
770 * ->siglock is taken to protect ->signal/->sighand
771 * tasklist_lock is taken to walk process list for sessions
772 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775void disassociate_ctty(int on_exit)
776{
777 struct tty_struct *tty;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800778 struct pid *tty_pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800781 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 if (tty) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800783 tty_pgrp = get_pid(tty->pgrp);
Alan Cox452a00d2008-10-13 10:39:13 +0100784 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
786 tty_vhangup(tty);
Alan Cox04f378b2008-04-30 00:53:29 -0700787 unlock_kernel();
Alan Cox452a00d2008-10-13 10:39:13 +0100788 tty_kref_put(tty);
Eric W. Biederman680a9672007-02-12 00:52:52 -0800789 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800790 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800791 spin_lock_irq(&current->sighand->siglock);
792 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800793 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800794 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800795 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800796 kill_pgrp(old_pgrp, SIGHUP, on_exit);
797 kill_pgrp(old_pgrp, SIGCONT, on_exit);
798 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 return;
801 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800802 if (tty_pgrp) {
803 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 if (!on_exit)
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800805 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
806 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 }
808
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800809 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700810 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800811 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800812 spin_unlock_irq(&current->sighand->siglock);
813
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800814 tty = get_current_tty();
815 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700816 unsigned long flags;
817 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800818 put_pid(tty->session);
819 put_pid(tty->pgrp);
820 tty->session = NULL;
821 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700822 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100823 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800824 } else {
825#ifdef TTY_DEBUG_HANGUP
826 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
827 " = NULL", tty);
828#endif
829 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 /* Now clear signal->tty under the lock */
832 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800833 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835}
836
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700837/**
838 *
839 * no_tty - Ensure the current process does not have a controlling tty
840 */
841void no_tty(void)
842{
843 struct task_struct *tsk = current;
Alan Cox04f378b2008-04-30 00:53:29 -0700844 lock_kernel();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700845 if (tsk->signal->leader)
846 disassociate_ctty(0);
Alan Cox04f378b2008-04-30 00:53:29 -0700847 unlock_kernel();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700848 proc_clear_tty(tsk);
849}
850
Alan Coxaf9b8972006-08-27 01:24:01 -0700851
852/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200853 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700854 * @tty: tty to stop
855 *
856 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200857 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700858 * on an already stopped device and will not re-call the driver
859 * method.
860 *
861 * This functionality is used by both the line disciplines for
862 * halting incoming flow and by the driver. It may therefore be
863 * called from any context, may be under the tty atomic_write_lock
864 * but not always.
865 *
866 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700867 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700868 */
869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870void stop_tty(struct tty_struct *tty)
871{
Alan Cox04f378b2008-04-30 00:53:29 -0700872 unsigned long flags;
873 spin_lock_irqsave(&tty->ctrl_lock, flags);
874 if (tty->stopped) {
875 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700877 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 tty->stopped = 1;
879 if (tty->link && tty->link->packet) {
880 tty->ctrl_status &= ~TIOCPKT_START;
881 tty->ctrl_status |= TIOCPKT_STOP;
882 wake_up_interruptible(&tty->link->read_wait);
883 }
Alan Cox04f378b2008-04-30 00:53:29 -0700884 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700885 if (tty->ops->stop)
886 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887}
888
889EXPORT_SYMBOL(stop_tty);
890
Alan Coxaf9b8972006-08-27 01:24:01 -0700891/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200892 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700893 * @tty: tty to start
894 *
895 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200896 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700897 * is the tty was previous stopped and is being started then the
898 * driver start method is invoked and the line discipline woken.
899 *
900 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700901 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700902 */
903
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904void start_tty(struct tty_struct *tty)
905{
Alan Cox04f378b2008-04-30 00:53:29 -0700906 unsigned long flags;
907 spin_lock_irqsave(&tty->ctrl_lock, flags);
908 if (!tty->stopped || tty->flow_stopped) {
909 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700911 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 tty->stopped = 0;
913 if (tty->link && tty->link->packet) {
914 tty->ctrl_status &= ~TIOCPKT_STOP;
915 tty->ctrl_status |= TIOCPKT_START;
916 wake_up_interruptible(&tty->link->read_wait);
917 }
Alan Cox04f378b2008-04-30 00:53:29 -0700918 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700919 if (tty->ops->start)
920 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 /* If we have a running line discipline it may need kicking */
922 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923}
924
925EXPORT_SYMBOL(start_tty);
926
Alan Coxaf9b8972006-08-27 01:24:01 -0700927/**
928 * tty_read - read method for tty device files
929 * @file: pointer to tty file
930 * @buf: user buffer
931 * @count: size of user buffer
932 * @ppos: unused
933 *
934 * Perform the read system call function on this terminal device. Checks
935 * for hung up devices before calling the line discipline method.
936 *
937 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700938 * Locks the line discipline internally while needed. Multiple
939 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700940 */
941
Alan Cox37bdfb02008-02-08 04:18:47 -0800942static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 loff_t *ppos)
944{
945 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -0800946 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 struct inode *inode;
948 struct tty_ldisc *ld;
949
950 tty = (struct tty_struct *)file->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -0800951 inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 if (tty_paranoia_check(tty, inode, "tty_read"))
953 return -EIO;
954 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
955 return -EIO;
956
957 /* We want to wait for the line discipline to sort out in this
958 situation */
959 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100960 if (ld->ops->read)
961 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 else
963 i = -EIO;
964 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 if (i > 0)
966 inode->i_atime = current_fs_time(inode->i_sb);
967 return i;
968}
969
Alan Cox9c1729d2007-07-15 23:39:43 -0700970void tty_write_unlock(struct tty_struct *tty)
971{
972 mutex_unlock(&tty->atomic_write_lock);
973 wake_up_interruptible(&tty->write_wait);
974}
975
976int tty_write_lock(struct tty_struct *tty, int ndelay)
977{
978 if (!mutex_trylock(&tty->atomic_write_lock)) {
979 if (ndelay)
980 return -EAGAIN;
981 if (mutex_lock_interruptible(&tty->atomic_write_lock))
982 return -ERESTARTSYS;
983 }
984 return 0;
985}
986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987/*
988 * Split writes up in sane blocksizes to avoid
989 * denial-of-service type attacks
990 */
991static inline ssize_t do_tty_write(
992 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
993 struct tty_struct *tty,
994 struct file *file,
995 const char __user *buf,
996 size_t count)
997{
Alan Cox9c1729d2007-07-15 23:39:43 -0700998 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -08001000
Alan Cox9c1729d2007-07-15 23:39:43 -07001001 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1002 if (ret < 0)
1003 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
1005 /*
1006 * We chunk up writes into a temporary buffer. This
1007 * simplifies low-level drivers immensely, since they
1008 * don't have locking issues and user mode accesses.
1009 *
1010 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1011 * big chunk-size..
1012 *
1013 * The default chunk-size is 2kB, because the NTTY
1014 * layer has problems with bigger chunks. It will
1015 * claim to be able to handle more characters than
1016 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001017 *
1018 * FIXME: This can probably go away now except that 64K chunks
1019 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 */
1021 chunk = 2048;
1022 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1023 chunk = 65536;
1024 if (count < chunk)
1025 chunk = count;
1026
Ingo Molnar70522e12006-03-23 03:00:31 -08001027 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001029 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030
1031 if (chunk < 1024)
1032 chunk = 1024;
1033
Jason Wessel402fda92008-10-13 10:45:36 +01001034 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1035 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001036 ret = -ENOMEM;
1037 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 }
1039 kfree(tty->write_buf);
1040 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001041 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 }
1043
1044 /* Do the write .. */
1045 for (;;) {
1046 size_t size = count;
1047 if (size > chunk)
1048 size = chunk;
1049 ret = -EFAULT;
1050 if (copy_from_user(tty->write_buf, buf, size))
1051 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (ret <= 0)
1054 break;
1055 written += ret;
1056 buf += ret;
1057 count -= ret;
1058 if (!count)
1059 break;
1060 ret = -ERESTARTSYS;
1061 if (signal_pending(current))
1062 break;
1063 cond_resched();
1064 }
1065 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001066 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 inode->i_mtime = current_fs_time(inode->i_sb);
1068 ret = written;
1069 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001070out:
1071 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 return ret;
1073}
1074
Alan Cox95f9bfc2008-10-13 10:39:23 +01001075/**
1076 * tty_write_message - write a message to a certain tty, not just the console.
1077 * @tty: the destination tty_struct
1078 * @msg: the message to write
1079 *
1080 * This is used for messages that need to be redirected to a specific tty.
1081 * We don't put it into the syslog queue right now maybe in the future if
1082 * really needed.
1083 *
1084 * We must still hold the BKL and test the CLOSING flag for the moment.
1085 */
1086
1087void tty_write_message(struct tty_struct *tty, char *msg)
1088{
1089 lock_kernel();
1090 if (tty) {
1091 mutex_lock(&tty->atomic_write_lock);
1092 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags))
1093 tty->ops->write(tty, msg, strlen(msg));
1094 tty_write_unlock(tty);
1095 }
1096 unlock_kernel();
1097 return;
1098}
1099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Alan Coxaf9b8972006-08-27 01:24:01 -07001101/**
1102 * tty_write - write method for tty device file
1103 * @file: tty file pointer
1104 * @buf: user data to write
1105 * @count: bytes to write
1106 * @ppos: unused
1107 *
1108 * Write data to a tty device via the line discipline.
1109 *
1110 * Locking:
1111 * Locks the line discipline as required
1112 * Writes to the tty driver are serialized by the atomic_write_lock
1113 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001114 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001115 */
1116
Alan Cox37bdfb02008-02-08 04:18:47 -08001117static ssize_t tty_write(struct file *file, const char __user *buf,
1118 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119{
Alan Cox37bdfb02008-02-08 04:18:47 -08001120 struct tty_struct *tty;
Josef Sipeka7113a92006-12-08 02:36:55 -08001121 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 ssize_t ret;
1123 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08001124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 tty = (struct tty_struct *)file->private_data;
1126 if (tty_paranoia_check(tty, inode, "tty_write"))
1127 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001128 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001129 (test_bit(TTY_IO_ERROR, &tty->flags)))
1130 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001131 /* Short term debug to catch buggy drivers */
1132 if (tty->ops->write_room == NULL)
1133 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1134 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001135 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001136 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 ret = -EIO;
1138 else
Alan Coxa352def2008-07-16 21:53:12 +01001139 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 tty_ldisc_deref(ld);
1141 return ret;
1142}
1143
Alan Cox37bdfb02008-02-08 04:18:47 -08001144ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1145 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146{
1147 struct file *p = NULL;
1148
1149 spin_lock(&redirect_lock);
1150 if (redirect) {
1151 get_file(redirect);
1152 p = redirect;
1153 }
1154 spin_unlock(&redirect_lock);
1155
1156 if (p) {
1157 ssize_t res;
1158 res = vfs_write(p, buf, count, &p->f_pos);
1159 fput(p);
1160 return res;
1161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 return tty_write(file, buf, count, ppos);
1163}
1164
1165static char ptychar[] = "pqrstuvwxyzabcde";
1166
Alan Coxaf9b8972006-08-27 01:24:01 -07001167/**
1168 * pty_line_name - generate name for a pty
1169 * @driver: the tty driver in use
1170 * @index: the minor number
1171 * @p: output buffer of at least 6 bytes
1172 *
1173 * Generate a name from a driver reference and write it to the output
1174 * buffer.
1175 *
1176 * Locking: None
1177 */
1178static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179{
1180 int i = index + driver->name_base;
1181 /* ->name is initialized to "ttyp", but "tty" is expected */
1182 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001183 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1184 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185}
1186
Alan Coxaf9b8972006-08-27 01:24:01 -07001187/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001188 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001189 * @driver: the tty driver in use
1190 * @index: the minor number
1191 * @p: output buffer of at least 7 bytes
1192 *
1193 * Generate a name from a driver reference and write it to the output
1194 * buffer.
1195 *
1196 * Locking: None
1197 */
1198static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199{
1200 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1201}
1202
Alan Cox99f1fe12008-10-13 10:42:00 +01001203/**
1204 * tty_driver_lookup_tty() - find an existing tty, if any
1205 * @driver: the driver for the tty
1206 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001207 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001208 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001209 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001210 * Locking: tty_mutex must be held. If tty is found, the mutex must
1211 * be held until the 'fast-open' is also done. Will change once we
1212 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001213 */
Jason Wessela47d5452009-01-02 13:43:04 +00001214static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001215 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001216{
1217 struct tty_struct *tty;
1218
Alan Cox99f1fe12008-10-13 10:42:00 +01001219 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001220 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001221
Alan Cox8b0a88d2008-10-13 10:42:19 +01001222 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001223 return tty;
1224}
1225
Alan Cox99f1fe12008-10-13 10:42:00 +01001226/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001227 * tty_init_termios - helper for termios setup
1228 * @tty: the tty to set up
1229 *
1230 * Initialise the termios structures for this tty. Thus runs under
1231 * the tty_mutex currently so we can be relaxed about ordering.
1232 */
1233
1234int tty_init_termios(struct tty_struct *tty)
1235{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001236 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001237 int idx = tty->index;
1238
1239 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001240 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001241 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1242 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001243 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001244 memcpy(tp, &tty->driver->init_termios,
1245 sizeof(struct ktermios));
1246 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001247 }
1248 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001249 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001250
1251 /* Compatibility until drivers always set this */
1252 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1253 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1254 return 0;
1255}
1256
1257/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001258 * tty_driver_install_tty() - install a tty entry in the driver
1259 * @driver: the driver for the tty
1260 * @tty: the tty
1261 *
1262 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001263 * will be set by the time this is called. This method is responsible
1264 * for ensuring any need additional structures are allocated and
1265 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001266 *
1267 * Locking: tty_mutex for now
1268 */
1269static int tty_driver_install_tty(struct tty_driver *driver,
1270 struct tty_struct *tty)
1271{
Alan Coxbf970ee2008-10-13 10:42:39 +01001272 int idx = tty->index;
1273
Alan Cox8b0a88d2008-10-13 10:42:19 +01001274 if (driver->ops->install)
1275 return driver->ops->install(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001276
1277 if (tty_init_termios(tty) == 0) {
1278 tty_driver_kref_get(driver);
1279 tty->count++;
1280 driver->ttys[idx] = tty;
1281 return 0;
1282 }
1283 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001284}
1285
1286/**
1287 * tty_driver_remove_tty() - remove a tty from the driver tables
1288 * @driver: the driver for the tty
1289 * @idx: the minor number
1290 *
1291 * Remvoe a tty object from the driver tables. The tty->index field
1292 * will be set by the time this is called.
1293 *
1294 * Locking: tty_mutex for now
1295 */
1296static void tty_driver_remove_tty(struct tty_driver *driver,
1297 struct tty_struct *tty)
1298{
1299 if (driver->ops->remove)
1300 driver->ops->remove(driver, tty);
1301 else
1302 driver->ttys[tty->index] = NULL;
1303}
1304
1305/*
1306 * tty_reopen() - fast re-open of an open tty
1307 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001308 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001309 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001310 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001311 * Locking: tty_mutex must be held from the time the tty was found
1312 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001313 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001314static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001315{
1316 struct tty_driver *driver = tty->driver;
1317
1318 if (test_bit(TTY_CLOSING, &tty->flags))
1319 return -EIO;
1320
1321 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1322 driver->subtype == PTY_TYPE_MASTER) {
1323 /*
1324 * special case for PTY masters: only one open permitted,
1325 * and the slave side open count is incremented as well.
1326 */
1327 if (tty->count)
1328 return -EIO;
1329
1330 tty->link->count++;
1331 }
1332 tty->count++;
1333 tty->driver = driver; /* N.B. why do this every time?? */
1334
Alan Cox99f1fe12008-10-13 10:42:00 +01001335 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001336
1337 return 0;
1338}
1339
Alan Coxaf9b8972006-08-27 01:24:01 -07001340/**
Alan Coxd81ed102008-10-13 10:41:42 +01001341 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001342 * @driver: tty driver we are opening a device on
1343 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001344 * @ret_tty: returned tty structure
1345 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001346 *
1347 * Prepare a tty device. This may not be a "new" clean device but
1348 * could also be an active device. The pty drivers require special
1349 * handling because of this.
1350 *
1351 * Locking:
1352 * The function is called under the tty_mutex, which
1353 * protects us from the tty struct or driver itself going away.
1354 *
1355 * On exit the tty device has the line discipline attached and
1356 * a reference count of 1. If a pair was created for pty/tty use
1357 * and the other was a pty master then it too has a reference count of 1.
1358 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001360 * failed open. The new code protects the open with a mutex, so it's
1361 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 * relaxed for the (most common) case of reopening a tty.
1363 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001364
Alan Cox73ec06f2008-10-13 10:42:29 +01001365struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1366 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367{
Alan Coxbf970ee2008-10-13 10:42:39 +01001368 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001369 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001371 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001372 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Cox73ec06f2008-10-13 10:42:29 +01001373 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok)
1374 return ERR_PTR(-EIO);
1375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 /*
1377 * First time open is complex, especially for PTY devices.
1378 * This code guarantees that either everything succeeds and the
1379 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001380 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 * and locked termios may be retained.)
1382 */
1383
Alan Cox73ec06f2008-10-13 10:42:29 +01001384 if (!try_module_get(driver->owner))
1385 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 tty = alloc_tty_struct();
Alan Cox37bdfb02008-02-08 04:18:47 -08001388 if (!tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 goto fail_no_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +01001390 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
Alan Cox73ec06f2008-10-13 10:42:29 +01001392 retval = tty_driver_install_tty(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001393 if (retval < 0) {
1394 free_tty_struct(tty);
1395 module_put(driver->owner);
1396 return ERR_PTR(retval);
1397 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001398
Alan Cox37bdfb02008-02-08 04:18:47 -08001399 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001401 * If we fail here just call release_tty to clean up. No need
1402 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 */
1404
Alan Coxbf970ee2008-10-13 10:42:39 +01001405 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001406 if (retval)
1407 goto release_mem_out;
Alan Cox73ec06f2008-10-13 10:42:29 +01001408 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410fail_no_mem:
1411 module_put(driver->owner);
Alan Cox73ec06f2008-10-13 10:42:29 +01001412 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001414 /* call the tty release_tty routine to clean out this slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415release_mem_out:
Akinobu Mita40509142006-09-29 02:01:27 -07001416 if (printk_ratelimit())
Alan Coxd81ed102008-10-13 10:41:42 +01001417 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001418 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001419 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001420 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421}
1422
Alan Coxfeebed62008-10-13 10:41:30 +01001423void tty_free_termios(struct tty_struct *tty)
1424{
1425 struct ktermios *tp;
1426 int idx = tty->index;
1427 /* Kill this flag and push into drivers for locking etc */
1428 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1429 /* FIXME: Locking on ->termios array */
1430 tp = tty->termios;
1431 tty->driver->termios[idx] = NULL;
1432 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001433 }
1434}
1435EXPORT_SYMBOL(tty_free_termios);
1436
1437void tty_shutdown(struct tty_struct *tty)
1438{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001439 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001440 tty_free_termios(tty);
1441}
1442EXPORT_SYMBOL(tty_shutdown);
1443
Alan Coxaf9b8972006-08-27 01:24:01 -07001444/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001445 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001446 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001447 *
1448 * Releases memory associated with a tty structure, and clears out the
1449 * driver table slots. This function is called when a device is no longer
1450 * in use. It also gets called when setup of a device fails.
1451 *
1452 * Locking:
1453 * tty_mutex - sometimes only
1454 * takes the file list lock internally when working on the list
1455 * of ttys that the driver keeps.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 */
Alan Cox9c9f4de2008-10-13 10:37:26 +01001457static void release_one_tty(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001459 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Alan Cox6f967f72008-10-13 10:37:36 +01001460 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
Alan Coxfeebed62008-10-13 10:41:30 +01001462 if (tty->ops->shutdown)
1463 tty->ops->shutdown(tty);
1464 else
1465 tty_shutdown(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001467 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001468 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001469
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 file_list_lock();
1471 list_del_init(&tty->tty_files);
1472 file_list_unlock();
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001473
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 free_tty_struct(tty);
1475}
1476
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001477/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001478 * tty_kref_put - release a tty kref
1479 * @tty: tty device
1480 *
1481 * Release a reference to a tty device and if need be let the kref
1482 * layer destruct the object for us
1483 */
1484
1485void tty_kref_put(struct tty_struct *tty)
1486{
1487 if (tty)
1488 kref_put(&tty->kref, release_one_tty);
1489}
1490EXPORT_SYMBOL(tty_kref_put);
1491
1492/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001493 * release_tty - release tty structure memory
1494 *
1495 * Release both @tty and a possible linked partner (think pty pair),
1496 * and decrement the refcount of the backing module.
1497 *
1498 * Locking:
1499 * tty_mutex - sometimes only
1500 * takes the file list lock internally when working on the list
1501 * of ttys that the driver keeps.
1502 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001503 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001504 */
1505static void release_tty(struct tty_struct *tty, int idx)
1506{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001507 /* This should always be true but check for the moment */
1508 WARN_ON(tty->index != idx);
1509
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001510 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001511 tty_kref_put(tty->link);
1512 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001513}
1514
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515/*
1516 * Even releasing the tty structures is a tricky business.. We have
1517 * to be very careful that the structures are all released at the
1518 * same time, as interrupts might otherwise get the wrong pointers.
1519 *
1520 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1521 * lead to double frees or releasing memory still in use.
1522 */
Alan Coxd81ed102008-10-13 10:41:42 +01001523void tty_release_dev(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
1525 struct tty_struct *tty, *o_tty;
1526 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001527 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 int idx;
1529 char buf[64];
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001530 struct inode *inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08001531
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001532 inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 tty = (struct tty_struct *)filp->private_data;
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001534 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 return;
1536
Alan Coxd81ed102008-10-13 10:41:42 +01001537 check_tty_count(tty, "tty_release_dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538
1539 tty_fasync(-1, filp, 0);
1540
1541 idx = tty->index;
1542 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1543 tty->driver->subtype == PTY_TYPE_MASTER);
1544 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 o_tty = tty->link;
1546
1547#ifdef TTY_PARANOIA_CHECK
1548 if (idx < 0 || idx >= tty->driver->num) {
Alan Coxd81ed102008-10-13 10:41:42 +01001549 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 "free (%s)\n", tty->name);
1551 return;
1552 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001553 if (!devpts) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 if (tty != tty->driver->ttys[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001555 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 "for (%s)\n", idx, tty->name);
1557 return;
1558 }
1559 if (tty->termios != tty->driver->termios[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001560 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 "for (%s)\n",
1562 idx, tty->name);
1563 return;
1564 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 }
1566#endif
1567
1568#ifdef TTY_DEBUG_HANGUP
Alan Coxd81ed102008-10-13 10:41:42 +01001569 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 tty_name(tty, buf), tty->count);
1571#endif
1572
1573#ifdef TTY_PARANOIA_CHECK
1574 if (tty->driver->other &&
1575 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1576 if (o_tty != tty->driver->other->ttys[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001577 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 "not o_tty for (%s)\n",
1579 idx, tty->name);
1580 return;
1581 }
1582 if (o_tty->termios != tty->driver->other->termios[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001583 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 "not o_termios for (%s)\n",
1585 idx, tty->name);
1586 return;
1587 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 if (o_tty->link != tty) {
Alan Coxd81ed102008-10-13 10:41:42 +01001589 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 return;
1591 }
1592 }
1593#endif
Alan Coxf34d7a52008-04-30 00:54:13 -07001594 if (tty->ops->close)
1595 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
1597 /*
1598 * Sanity check: if tty->count is going to zero, there shouldn't be
1599 * any waiters on tty->read_wait or tty->write_wait. We test the
1600 * wait queues and kick everyone out _before_ actually starting to
1601 * close. This ensures that we won't block while releasing the tty
1602 * structure.
1603 *
1604 * The test for the o_tty closing is necessary, since the master and
1605 * slave sides may close in any order. If the slave side closes out
1606 * first, its count will be one, since the master side holds an open.
1607 * Thus this test wouldn't be triggered at the time the slave closes,
1608 * so we do it now.
1609 *
1610 * Note that it's possible for the tty to be opened again while we're
1611 * flushing out waiters. By recalculating the closing flags before
1612 * each iteration we avoid any problems.
1613 */
1614 while (1) {
1615 /* Guard against races with tty->count changes elsewhere and
1616 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001617
Ingo Molnar70522e12006-03-23 03:00:31 -08001618 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 tty_closing = tty->count <= 1;
1620 o_tty_closing = o_tty &&
1621 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 do_sleep = 0;
1623
1624 if (tty_closing) {
1625 if (waitqueue_active(&tty->read_wait)) {
1626 wake_up(&tty->read_wait);
1627 do_sleep++;
1628 }
1629 if (waitqueue_active(&tty->write_wait)) {
1630 wake_up(&tty->write_wait);
1631 do_sleep++;
1632 }
1633 }
1634 if (o_tty_closing) {
1635 if (waitqueue_active(&o_tty->read_wait)) {
1636 wake_up(&o_tty->read_wait);
1637 do_sleep++;
1638 }
1639 if (waitqueue_active(&o_tty->write_wait)) {
1640 wake_up(&o_tty->write_wait);
1641 do_sleep++;
1642 }
1643 }
1644 if (!do_sleep)
1645 break;
1646
Alan Coxd81ed102008-10-13 10:41:42 +01001647 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 "active!\n", tty_name(tty, buf));
Ingo Molnar70522e12006-03-23 03:00:31 -08001649 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001651 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
1653 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001654 * The closing flags are now consistent with the open counts on
1655 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 * block, so it's safe to proceed with closing.
1657 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 if (pty_master) {
1659 if (--o_tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001660 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 "(%d) for %s\n",
1662 o_tty->count, tty_name(o_tty, buf));
1663 o_tty->count = 0;
1664 }
1665 }
1666 if (--tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001667 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 tty->count, tty_name(tty, buf));
1669 tty->count = 0;
1670 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001671
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 /*
1673 * We've decremented tty->count, so we need to remove this file
1674 * descriptor off the tty->tty_files list; this serves two
1675 * purposes:
1676 * - check_tty_count sees the correct number of file descriptors
1677 * associated with this tty.
1678 * - do_tty_hangup no longer sees this file descriptor as
1679 * something that needs to be handled for hangups.
1680 */
1681 file_kill(filp);
1682 filp->private_data = NULL;
1683
1684 /*
1685 * Perform some housekeeping before deciding whether to return.
1686 *
1687 * Set the TTY_CLOSING flag if this was the last open. In the
1688 * case of a pty we may have to wait around for the other side
1689 * to close, and TTY_CLOSING makes sure we can't be reopened.
1690 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001691 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001693 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 set_bit(TTY_CLOSING, &o_tty->flags);
1695
1696 /*
1697 * If _either_ side is closing, make sure there aren't any
1698 * processes that still think tty or o_tty is their controlling
1699 * tty.
1700 */
1701 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001703 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001705 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 read_unlock(&tasklist_lock);
1707 }
1708
Ingo Molnar70522e12006-03-23 03:00:31 -08001709 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001710
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 /* check whether both sides are closing ... */
1712 if (!tty_closing || (o_tty && !o_tty_closing))
1713 return;
Alan Cox37bdfb02008-02-08 04:18:47 -08001714
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715#ifdef TTY_DEBUG_HANGUP
1716 printk(KERN_DEBUG "freeing tty structure...");
1717#endif
1718 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001719 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001721 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001723 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 * the slots and preserving the termios structure.
1725 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001726 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001729 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001730 devpts_kill_index(inode, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731}
1732
Alan Coxaf9b8972006-08-27 01:24:01 -07001733/**
Alan Cox15582d32008-10-13 10:41:03 +01001734 * __tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001735 * @inode: inode of device file
1736 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001738 * tty_open and tty_release keep up the tty count that contains the
1739 * number of opens done on a tty. We cannot use the inode-count, as
1740 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001742 * Open-counting is needed for pty masters, as well as for keeping
1743 * track of serial lines: DTR is dropped when the last close happens.
1744 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1745 *
1746 * The termios state of a pty is reset on first open so that
1747 * settings don't persist across reuse.
1748 *
Alan Coxd81ed102008-10-13 10:41:42 +01001749 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001750 * tty->count should protect the rest.
1751 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001753
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001754static int __tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755{
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001756 struct tty_struct *tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 int noctty, retval;
1758 struct tty_driver *driver;
1759 int index;
1760 dev_t device = inode->i_rdev;
1761 unsigned short saved_flags = filp->f_flags;
1762
1763 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001764
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765retry_open:
1766 noctty = filp->f_flags & O_NOCTTY;
1767 index = -1;
1768 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001769
Ingo Molnar70522e12006-03-23 03:00:31 -08001770 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
Alan Cox37bdfb02008-02-08 04:18:47 -08001772 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001773 tty = get_current_tty();
1774 if (!tty) {
Ingo Molnar70522e12006-03-23 03:00:31 -08001775 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 return -ENXIO;
1777 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01001778 driver = tty_driver_kref_get(tty->driver);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001779 index = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1781 /* noctty = 1; */
Alan Cox452a00d2008-10-13 10:39:13 +01001782 /* FIXME: Should we take a driver reference ? */
1783 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 goto got_driver;
1785 }
1786#ifdef CONFIG_VT
Alan Cox37bdfb02008-02-08 04:18:47 -08001787 if (device == MKDEV(TTY_MAJOR, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 extern struct tty_driver *console_driver;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001789 driver = tty_driver_kref_get(console_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 index = fg_console;
1791 noctty = 1;
1792 goto got_driver;
1793 }
1794#endif
Alan Cox37bdfb02008-02-08 04:18:47 -08001795 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
Will Newton296fa7f2008-12-01 11:36:06 +00001796 struct tty_driver *console_driver = console_device(&index);
1797 if (console_driver) {
1798 driver = tty_driver_kref_get(console_driver);
1799 if (driver) {
1800 /* Don't let /dev/console block */
1801 filp->f_flags |= O_NONBLOCK;
1802 noctty = 1;
1803 goto got_driver;
1804 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 }
Ingo Molnar70522e12006-03-23 03:00:31 -08001806 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 return -ENODEV;
1808 }
1809
1810 driver = get_tty_driver(device, &index);
1811 if (!driver) {
Ingo Molnar70522e12006-03-23 03:00:31 -08001812 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 return -ENODEV;
1814 }
1815got_driver:
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001816 if (!tty) {
1817 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001818 tty = tty_driver_lookup_tty(driver, inode, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001819
Eric Paris808ffa32009-01-27 11:50:37 +00001820 if (IS_ERR(tty)) {
1821 mutex_unlock(&tty_mutex);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001822 return PTR_ERR(tty);
Eric Paris808ffa32009-01-27 11:50:37 +00001823 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001824 }
1825
1826 if (tty) {
1827 retval = tty_reopen(tty);
1828 if (retval)
1829 tty = ERR_PTR(retval);
1830 } else
1831 tty = tty_init_dev(driver, index, 0);
1832
Ingo Molnar70522e12006-03-23 03:00:31 -08001833 mutex_unlock(&tty_mutex);
Alan Cox7d7b93c2008-10-13 10:42:09 +01001834 tty_driver_kref_put(driver);
Alan Cox73ec06f2008-10-13 10:42:29 +01001835 if (IS_ERR(tty))
1836 return PTR_ERR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837
1838 filp->private_data = tty;
1839 file_move(filp, &tty->tty_files);
1840 check_tty_count(tty, "tty_open");
1841 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1842 tty->driver->subtype == PTY_TYPE_MASTER)
1843 noctty = 1;
1844#ifdef TTY_DEBUG_HANGUP
1845 printk(KERN_DEBUG "opening %s...", tty->name);
1846#endif
1847 if (!retval) {
Alan Coxf34d7a52008-04-30 00:54:13 -07001848 if (tty->ops->open)
1849 retval = tty->ops->open(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 else
1851 retval = -ENODEV;
1852 }
1853 filp->f_flags = saved_flags;
1854
Alan Cox37bdfb02008-02-08 04:18:47 -08001855 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1856 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 retval = -EBUSY;
1858
1859 if (retval) {
1860#ifdef TTY_DEBUG_HANGUP
1861 printk(KERN_DEBUG "error %d in opening %s...", retval,
1862 tty->name);
1863#endif
Alan Coxd81ed102008-10-13 10:41:42 +01001864 tty_release_dev(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 if (retval != -ERESTARTSYS)
1866 return retval;
1867 if (signal_pending(current))
1868 return retval;
1869 schedule();
1870 /*
1871 * Need to reset f_op in case a hangup happened.
1872 */
1873 if (filp->f_op == &hung_up_tty_fops)
1874 filp->f_op = &tty_fops;
1875 goto retry_open;
1876 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001877
1878 mutex_lock(&tty_mutex);
1879 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 if (!noctty &&
1881 current->signal->leader &&
1882 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001883 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07001884 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001885 spin_unlock_irq(&current->sighand->siglock);
1886 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 return 0;
1888}
1889
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001890/* BKL pushdown: scary code avoidance wrapper */
1891static int tty_open(struct inode *inode, struct file *filp)
1892{
1893 int ret;
1894
1895 lock_kernel();
1896 ret = __tty_open(inode, filp);
1897 unlock_kernel();
1898 return ret;
1899}
1900
1901
1902
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903
Alan Coxaf9b8972006-08-27 01:24:01 -07001904/**
1905 * tty_release - vfs callback for close
1906 * @inode: inode of tty
1907 * @filp: file pointer for handle to tty
1908 *
1909 * Called the last time each file handle is closed that references
1910 * this tty. There may however be several such references.
1911 *
1912 * Locking:
Alan Coxd81ed102008-10-13 10:41:42 +01001913 * Takes bkl. See tty_release_dev
Alan Coxaf9b8972006-08-27 01:24:01 -07001914 */
1915
Alan Cox37bdfb02008-02-08 04:18:47 -08001916static int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917{
1918 lock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001919 tty_release_dev(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 unlock_kernel();
1921 return 0;
1922}
1923
Alan Coxaf9b8972006-08-27 01:24:01 -07001924/**
1925 * tty_poll - check tty status
1926 * @filp: file being polled
1927 * @wait: poll wait structures to update
1928 *
1929 * Call the line discipline polling method to obtain the poll
1930 * status of the device.
1931 *
1932 * Locking: locks called line discipline but ldisc poll method
1933 * may be re-entered freely by other callers.
1934 */
1935
Alan Cox37bdfb02008-02-08 04:18:47 -08001936static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937{
Alan Cox37bdfb02008-02-08 04:18:47 -08001938 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 struct tty_ldisc *ld;
1940 int ret = 0;
1941
1942 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001943 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001945
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001947 if (ld->ops->poll)
1948 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 tty_ldisc_deref(ld);
1950 return ret;
1951}
1952
Alan Cox37bdfb02008-02-08 04:18:47 -08001953static int tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954{
Alan Cox37bdfb02008-02-08 04:18:47 -08001955 struct tty_struct *tty;
Alan Cox47f86832008-04-30 00:53:30 -07001956 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001957 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001959 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001961 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001962 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08001963
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 retval = fasync_helper(fd, filp, on, &tty->fasync);
1965 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001966 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967
1968 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001969 enum pid_type type;
1970 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 if (!waitqueue_active(&tty->read_wait))
1972 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07001973 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001974 if (tty->pgrp) {
1975 pid = tty->pgrp;
1976 type = PIDTYPE_PGID;
1977 } else {
1978 pid = task_pid(current);
1979 type = PIDTYPE_PID;
1980 }
Alan Cox47f86832008-04-30 00:53:30 -07001981 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001982 retval = __f_setown(filp, pid, type, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001984 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 } else {
1986 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1987 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1988 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001989 retval = 0;
1990out:
1991 unlock_kernel();
1992 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993}
1994
Alan Coxaf9b8972006-08-27 01:24:01 -07001995/**
1996 * tiocsti - fake input character
1997 * @tty: tty to fake input into
1998 * @p: pointer to character
1999 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002000 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002001 * input management.
2002 *
2003 * FIXME: does not honour flow control ??
2004 *
2005 * Locking:
2006 * Called functions take tty_ldisc_lock
2007 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002008 *
2009 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002010 */
2011
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012static int tiocsti(struct tty_struct *tty, char __user *p)
2013{
2014 char ch, mbz = 0;
2015 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002016
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2018 return -EPERM;
2019 if (get_user(ch, p))
2020 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002021 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002023 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 tty_ldisc_deref(ld);
2025 return 0;
2026}
2027
Alan Coxaf9b8972006-08-27 01:24:01 -07002028/**
2029 * tiocgwinsz - implement window query ioctl
2030 * @tty; tty
2031 * @arg: user buffer for result
2032 *
Alan Cox808a0d32006-09-29 02:00:40 -07002033 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002034 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002035 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002036 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002037 */
2038
Alan Cox37bdfb02008-02-08 04:18:47 -08002039static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040{
Alan Cox808a0d32006-09-29 02:00:40 -07002041 int err;
2042
Arjan van de Ven5785c952006-09-29 02:00:43 -07002043 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002044 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002045 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002046
2047 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048}
2049
Alan Coxaf9b8972006-08-27 01:24:01 -07002050/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002051 * tty_do_resize - resize event
2052 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002053 * @rows: rows (character)
2054 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002055 *
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002056 * Update the termios variables and send the neccessary signals to
2057 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002058 */
2059
Alan Coxfc6f6232009-01-02 13:43:17 +00002060int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061{
Alan Coxfc6f6232009-01-02 13:43:17 +00002062 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002063 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064
Alan Coxfc6f6232009-01-02 13:43:17 +00002065 /* Lock the tty */
2066 mutex_lock(&tty->termios_mutex);
2067 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002068 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002069 /* Get the PID values and reference them so we can
2070 avoid holding the tty ctrl lock while sending signals */
2071 spin_lock_irqsave(&tty->ctrl_lock, flags);
2072 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002073 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2074
2075 if (pgrp)
2076 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002077 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002078
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002079 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002080done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002081 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 return 0;
2083}
2084
Alan Coxaf9b8972006-08-27 01:24:01 -07002085/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002086 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002087 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002088 * @arg: user buffer for result
2089 *
2090 * Copies the user idea of the window size to the kernel. Traditionally
2091 * this is just advisory information but for the Linux console it
2092 * actually has driver level meaning and triggers a VC resize.
2093 *
2094 * Locking:
2095 * Driver dependant. The default do_resize method takes the
2096 * tty termios mutex and ctrl_lock. The console takes its own lock
2097 * then calls into the default method.
2098 */
2099
Alan Coxfc6f6232009-01-02 13:43:17 +00002100static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002101{
2102 struct winsize tmp_ws;
2103 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2104 return -EFAULT;
2105
2106 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002107 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002108 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002109 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002110}
2111
2112/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002113 * tioccons - allow admin to move logical console
2114 * @file: the file to become console
2115 *
2116 * Allow the adminstrator to move the redirected console device
2117 *
2118 * Locking: uses redirect_lock to guard the redirect information
2119 */
2120
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121static int tioccons(struct file *file)
2122{
2123 if (!capable(CAP_SYS_ADMIN))
2124 return -EPERM;
2125 if (file->f_op->write == redirected_tty_write) {
2126 struct file *f;
2127 spin_lock(&redirect_lock);
2128 f = redirect;
2129 redirect = NULL;
2130 spin_unlock(&redirect_lock);
2131 if (f)
2132 fput(f);
2133 return 0;
2134 }
2135 spin_lock(&redirect_lock);
2136 if (redirect) {
2137 spin_unlock(&redirect_lock);
2138 return -EBUSY;
2139 }
2140 get_file(file);
2141 redirect = file;
2142 spin_unlock(&redirect_lock);
2143 return 0;
2144}
2145
Alan Coxaf9b8972006-08-27 01:24:01 -07002146/**
2147 * fionbio - non blocking ioctl
2148 * @file: file to set blocking value
2149 * @p: user parameter
2150 *
2151 * Historical tty interfaces had a blocking control ioctl before
2152 * the generic functionality existed. This piece of history is preserved
2153 * in the expected tty API of posix OS's.
2154 *
2155 * Locking: none, the open fle handle ensures it won't go away.
2156 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157
2158static int fionbio(struct file *file, int __user *p)
2159{
2160 int nonblock;
2161
2162 if (get_user(nonblock, p))
2163 return -EFAULT;
2164
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002165 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 if (nonblock)
2167 file->f_flags |= O_NONBLOCK;
2168 else
2169 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002170 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 return 0;
2172}
2173
Alan Coxaf9b8972006-08-27 01:24:01 -07002174/**
2175 * tiocsctty - set controlling tty
2176 * @tty: tty structure
2177 * @arg: user argument
2178 *
2179 * This ioctl is used to manage job control. It permits a session
2180 * leader to set this tty as the controlling tty for the session.
2181 *
2182 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002183 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002184 * Takes tasklist_lock internally to walk sessions
2185 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002186 */
2187
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188static int tiocsctty(struct tty_struct *tty, int arg)
2189{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002190 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002191 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002192 return ret;
2193
2194 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 /*
2196 * The process must be a session leader and
2197 * not have a controlling tty already.
2198 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002199 if (!current->signal->leader || current->signal->tty) {
2200 ret = -EPERM;
2201 goto unlock;
2202 }
2203
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002204 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 /*
2206 * This tty is already the controlling
2207 * tty for another session group!
2208 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002209 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 /*
2211 * Steal it away
2212 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002214 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002216 } else {
2217 ret = -EPERM;
2218 goto unlock;
2219 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002221 proc_set_tty(current, tty);
2222unlock:
Alan Cox28298232006-09-29 02:00:58 -07002223 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002224 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225}
2226
Alan Coxaf9b8972006-08-27 01:24:01 -07002227/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002228 * tty_get_pgrp - return a ref counted pgrp pid
2229 * @tty: tty to read
2230 *
2231 * Returns a refcounted instance of the pid struct for the process
2232 * group controlling the tty.
2233 */
2234
2235struct pid *tty_get_pgrp(struct tty_struct *tty)
2236{
2237 unsigned long flags;
2238 struct pid *pgrp;
2239
2240 spin_lock_irqsave(&tty->ctrl_lock, flags);
2241 pgrp = get_pid(tty->pgrp);
2242 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2243
2244 return pgrp;
2245}
2246EXPORT_SYMBOL_GPL(tty_get_pgrp);
2247
2248/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002249 * tiocgpgrp - get process group
2250 * @tty: tty passed by user
2251 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2252 * @p: returned pid
2253 *
2254 * Obtain the process group of the tty. If there is no process group
2255 * return an error.
2256 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002257 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002258 */
2259
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2261{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002262 struct pid *pid;
2263 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 /*
2265 * (tty == real_tty) is a cheap way of
2266 * testing if the tty is NOT a master pty.
2267 */
2268 if (tty == real_tty && current->signal->tty != real_tty)
2269 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002270 pid = tty_get_pgrp(real_tty);
2271 ret = put_user(pid_vnr(pid), p);
2272 put_pid(pid);
2273 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274}
2275
Alan Coxaf9b8972006-08-27 01:24:01 -07002276/**
2277 * tiocspgrp - attempt to set process group
2278 * @tty: tty passed by user
2279 * @real_tty: tty side device matching tty passed by user
2280 * @p: pid pointer
2281 *
2282 * Set the process group of the tty to the session passed. Only
2283 * permitted where the tty session is our session.
2284 *
Alan Cox47f86832008-04-30 00:53:30 -07002285 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002286 */
2287
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2289{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002290 struct pid *pgrp;
2291 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002293 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294
2295 if (retval == -EIO)
2296 return -ENOTTY;
2297 if (retval)
2298 return retval;
2299 if (!current->signal->tty ||
2300 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002301 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002303 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002305 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002307 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002308 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002309 retval = -ESRCH;
2310 if (!pgrp)
2311 goto out_unlock;
2312 retval = -EPERM;
2313 if (session_of_pgrp(pgrp) != task_session(current))
2314 goto out_unlock;
2315 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002316 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002317 put_pid(real_tty->pgrp);
2318 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002319 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002320out_unlock:
2321 rcu_read_unlock();
2322 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323}
2324
Alan Coxaf9b8972006-08-27 01:24:01 -07002325/**
2326 * tiocgsid - get session id
2327 * @tty: tty passed by user
2328 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2329 * @p: pointer to returned session id
2330 *
2331 * Obtain the session id of the tty. If there is no session
2332 * return an error.
2333 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002334 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002335 */
2336
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2338{
2339 /*
2340 * (tty == real_tty) is a cheap way of
2341 * testing if the tty is NOT a master pty.
2342 */
2343 if (tty == real_tty && current->signal->tty != real_tty)
2344 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002345 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002347 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348}
2349
Alan Coxaf9b8972006-08-27 01:24:01 -07002350/**
2351 * tiocsetd - set line discipline
2352 * @tty: tty device
2353 * @p: pointer to user data
2354 *
2355 * Set the line discipline according to user request.
2356 *
2357 * Locking: see tty_set_ldisc, this function is just a helper
2358 */
2359
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360static int tiocsetd(struct tty_struct *tty, int __user *p)
2361{
2362 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002363 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364
2365 if (get_user(ldisc, p))
2366 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002367
2368 lock_kernel();
2369 ret = tty_set_ldisc(tty, ldisc);
2370 unlock_kernel();
2371
2372 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373}
2374
Alan Coxaf9b8972006-08-27 01:24:01 -07002375/**
2376 * send_break - performed time break
2377 * @tty: device to break on
2378 * @duration: timeout in mS
2379 *
2380 * Perform a timed break on hardware that lacks its own driver level
2381 * timed break functionality.
2382 *
2383 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002384 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002385 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002386 */
2387
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002388static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389{
Alan Cox9e989662008-07-22 11:18:03 +01002390 int retval;
2391
2392 if (tty->ops->break_ctl == NULL)
2393 return 0;
2394
2395 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2396 retval = tty->ops->break_ctl(tty, duration);
2397 else {
2398 /* Do the work ourselves */
2399 if (tty_write_lock(tty, 0) < 0)
2400 return -EINTR;
2401 retval = tty->ops->break_ctl(tty, -1);
2402 if (retval)
2403 goto out;
2404 if (!signal_pending(current))
2405 msleep_interruptible(duration);
2406 retval = tty->ops->break_ctl(tty, 0);
2407out:
2408 tty_write_unlock(tty);
2409 if (signal_pending(current))
2410 retval = -EINTR;
2411 }
2412 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413}
2414
Alan Coxaf9b8972006-08-27 01:24:01 -07002415/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002416 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002417 * @tty: tty device
2418 * @file: user file pointer
2419 * @p: pointer to result
2420 *
2421 * Obtain the modem status bits from the tty driver if the feature
2422 * is supported. Return -EINVAL if it is not available.
2423 *
2424 * Locking: none (up to the driver)
2425 */
2426
2427static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428{
2429 int retval = -EINVAL;
2430
Alan Coxf34d7a52008-04-30 00:54:13 -07002431 if (tty->ops->tiocmget) {
2432 retval = tty->ops->tiocmget(tty, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433
2434 if (retval >= 0)
2435 retval = put_user(retval, p);
2436 }
2437 return retval;
2438}
2439
Alan Coxaf9b8972006-08-27 01:24:01 -07002440/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002441 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002442 * @tty: tty device
2443 * @file: user file pointer
2444 * @cmd: command - clear bits, set bits or set all
2445 * @p: pointer to desired bits
2446 *
2447 * Set the modem status bits from the tty driver if the feature
2448 * is supported. Return -EINVAL if it is not available.
2449 *
2450 * Locking: none (up to the driver)
2451 */
2452
2453static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 unsigned __user *p)
2455{
Alan Coxae677512008-07-16 21:56:54 +01002456 int retval;
2457 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458
Alan Coxae677512008-07-16 21:56:54 +01002459 if (tty->ops->tiocmset == NULL)
2460 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461
Alan Coxae677512008-07-16 21:56:54 +01002462 retval = get_user(val, p);
2463 if (retval)
2464 return retval;
2465 set = clear = 0;
2466 switch (cmd) {
2467 case TIOCMBIS:
2468 set = val;
2469 break;
2470 case TIOCMBIC:
2471 clear = val;
2472 break;
2473 case TIOCMSET:
2474 set = val;
2475 clear = ~val;
2476 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 }
Alan Coxae677512008-07-16 21:56:54 +01002478 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2479 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2480 return tty->ops->tiocmset(tty, file, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481}
2482
2483/*
2484 * Split this up, as gcc can choke on it otherwise..
2485 */
Alan Cox04f378b2008-04-30 00:53:29 -07002486long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487{
2488 struct tty_struct *tty, *real_tty;
2489 void __user *p = (void __user *)arg;
2490 int retval;
2491 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002492 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002493
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494 tty = (struct tty_struct *)file->private_data;
2495 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2496 return -EINVAL;
2497
2498 real_tty = tty;
2499 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2500 tty->driver->subtype == PTY_TYPE_MASTER)
2501 real_tty = tty->link;
2502
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503
2504 /*
2505 * Factor out some common prep work
2506 */
2507 switch (cmd) {
2508 case TIOCSETD:
2509 case TIOCSBRK:
2510 case TIOCCBRK:
2511 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002512 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 retval = tty_check_change(tty);
2514 if (retval)
2515 return retval;
2516 if (cmd != TIOCCBRK) {
2517 tty_wait_until_sent(tty, 0);
2518 if (signal_pending(current))
2519 return -EINTR;
2520 }
2521 break;
2522 }
2523
Alan Cox9e989662008-07-22 11:18:03 +01002524 /*
2525 * Now do the stuff.
2526 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002528 case TIOCSTI:
2529 return tiocsti(tty, p);
2530 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002531 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002532 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002533 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002534 case TIOCCONS:
2535 return real_tty != tty ? -EINVAL : tioccons(file);
2536 case FIONBIO:
2537 return fionbio(file, p);
2538 case TIOCEXCL:
2539 set_bit(TTY_EXCLUSIVE, &tty->flags);
2540 return 0;
2541 case TIOCNXCL:
2542 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2543 return 0;
2544 case TIOCNOTTY:
2545 if (current->signal->tty != tty)
2546 return -ENOTTY;
2547 no_tty();
2548 return 0;
2549 case TIOCSCTTY:
2550 return tiocsctty(tty, arg);
2551 case TIOCGPGRP:
2552 return tiocgpgrp(tty, real_tty, p);
2553 case TIOCSPGRP:
2554 return tiocspgrp(tty, real_tty, p);
2555 case TIOCGSID:
2556 return tiocgsid(tty, real_tty, p);
2557 case TIOCGETD:
Alan Coxa352def2008-07-16 21:53:12 +01002558 return put_user(tty->ldisc.ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002559 case TIOCSETD:
2560 return tiocsetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002561 /*
2562 * Break handling
2563 */
2564 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002565 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002566 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002567 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002568 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002569 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002570 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002571 return 0;
2572 case TCSBRK: /* SVID version: non-zero arg --> no break */
2573 /* non-zero arg means wait for all output data
2574 * to be sent (performed above) but don't send break.
2575 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002577 if (!arg)
2578 return send_break(tty, 250);
2579 return 0;
2580 case TCSBRKP: /* support for POSIX tcsendbreak() */
2581 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582
Alan Cox37bdfb02008-02-08 04:18:47 -08002583 case TIOCMGET:
2584 return tty_tiocmget(tty, file, p);
2585 case TIOCMSET:
2586 case TIOCMBIC:
2587 case TIOCMBIS:
2588 return tty_tiocmset(tty, file, cmd, p);
2589 case TCFLSH:
2590 switch (arg) {
2591 case TCIFLUSH:
2592 case TCIOFLUSH:
2593 /* flush tty buffer and allow ldisc to process ioctl */
2594 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002595 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002596 }
2597 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002599 if (tty->ops->ioctl) {
2600 retval = (tty->ops->ioctl)(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 if (retval != -ENOIOCTLCMD)
2602 return retval;
2603 }
2604 ld = tty_ldisc_ref_wait(tty);
2605 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002606 if (ld->ops->ioctl) {
2607 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 if (retval == -ENOIOCTLCMD)
2609 retval = -EINVAL;
2610 }
2611 tty_ldisc_deref(ld);
2612 return retval;
2613}
2614
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002615#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002616static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002617 unsigned long arg)
2618{
2619 struct inode *inode = file->f_dentry->d_inode;
2620 struct tty_struct *tty = file->private_data;
2621 struct tty_ldisc *ld;
2622 int retval = -ENOIOCTLCMD;
2623
2624 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2625 return -EINVAL;
2626
Alan Coxf34d7a52008-04-30 00:54:13 -07002627 if (tty->ops->compat_ioctl) {
2628 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002629 if (retval != -ENOIOCTLCMD)
2630 return retval;
2631 }
2632
2633 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002634 if (ld->ops->compat_ioctl)
2635 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002636 tty_ldisc_deref(ld);
2637
2638 return retval;
2639}
2640#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641
2642/*
2643 * This implements the "Secure Attention Key" --- the idea is to
2644 * prevent trojan horses by killing all processes associated with this
2645 * tty when the user hits the "Secure Attention Key". Required for
2646 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002647 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 * This code could be nicer; ideally it should send a HUP, wait a few
2649 * seconds, then send a INT, and then a KILL signal. But you then
2650 * have to coordinate with the init process, since all processes associated
2651 * with the current tty must be dead before the new getty is allowed
2652 * to spawn.
2653 *
2654 * Now, if it would be correct ;-/ The current code has a nasty hole -
2655 * it doesn't catch files in flight. We may send the descriptor to ourselves
2656 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2657 *
2658 * Nasty bug: do_SAK is being called in interrupt context. This can
2659 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2660 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002661void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662{
2663#ifdef TTY_SOFT_SAK
2664 tty_hangup(tty);
2665#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002666 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002667 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 int i;
2669 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002670 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002671
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672 if (!tty)
2673 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002674 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002675
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002676 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677
Alan Coxf34d7a52008-04-30 00:54:13 -07002678 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002679
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002681 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002682 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002683 printk(KERN_NOTICE "SAK: killed process %d"
Pavel Emelianova47afb02007-10-18 23:39:46 -07002684 " (%s): task_session_nr(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002685 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002686 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002687 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002688 /* Now kill any processes that happen to have the
2689 * tty open.
2690 */
2691 do_each_thread(g, p) {
2692 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 printk(KERN_NOTICE "SAK: killed process %d"
Pavel Emelianova47afb02007-10-18 23:39:46 -07002694 " (%s): task_session_nr(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002695 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 send_sig(SIGKILL, p, 1);
2697 continue;
2698 }
2699 task_lock(p);
2700 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002701 /*
2702 * We don't take a ref to the file, so we must
2703 * hold ->file_lock instead.
2704 */
2705 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002706 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002707 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 filp = fcheck_files(p->files, i);
2709 if (!filp)
2710 continue;
2711 if (filp->f_op->read == tty_read &&
2712 filp->private_data == tty) {
2713 printk(KERN_NOTICE "SAK: killed process %d"
2714 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002715 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002716 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 break;
2718 }
2719 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002720 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 }
2722 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002723 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724 read_unlock(&tasklist_lock);
2725#endif
2726}
2727
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002728static void do_SAK_work(struct work_struct *work)
2729{
2730 struct tty_struct *tty =
2731 container_of(work, struct tty_struct, SAK_work);
2732 __do_SAK(tty);
2733}
2734
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735/*
2736 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2737 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2738 * the values which we write to it will be identical to the values which it
2739 * already has. --akpm
2740 */
2741void do_SAK(struct tty_struct *tty)
2742{
2743 if (!tty)
2744 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 schedule_work(&tty->SAK_work);
2746}
2747
2748EXPORT_SYMBOL(do_SAK);
2749
Alan Coxaf9b8972006-08-27 01:24:01 -07002750/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002751 * initialize_tty_struct
2752 * @tty: tty to initialize
2753 *
2754 * This subroutine initializes a tty structure that has been newly
2755 * allocated.
2756 *
2757 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002759
Alan Coxbf970ee2008-10-13 10:42:39 +01002760void initialize_tty_struct(struct tty_struct *tty,
2761 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762{
2763 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002764 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002766 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002767 tty->session = NULL;
2768 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002770 tty->buf.head = tty->buf.tail = NULL;
2771 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002772 mutex_init(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773 init_waitqueue_head(&tty->write_wait);
2774 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002775 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002776 mutex_init(&tty->atomic_read_lock);
2777 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002778 mutex_init(&tty->output_lock);
2779 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002781 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002783 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002784
2785 tty->driver = driver;
2786 tty->ops = driver->ops;
2787 tty->index = idx;
2788 tty_line_name(driver, idx, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789}
2790
Alan Coxf34d7a52008-04-30 00:54:13 -07002791/**
2792 * tty_put_char - write one character to a tty
2793 * @tty: tty
2794 * @ch: character
2795 *
2796 * Write one byte to the tty using the provided put_char method
2797 * if present. Returns the number of characters successfully output.
2798 *
2799 * Note: the specific put_char operation in the driver layer may go
2800 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002802
Alan Coxf34d7a52008-04-30 00:54:13 -07002803int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804{
Alan Coxf34d7a52008-04-30 00:54:13 -07002805 if (tty->ops->put_char)
2806 return tty->ops->put_char(tty, ch);
2807 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808}
Alan Coxf34d7a52008-04-30 00:54:13 -07002809EXPORT_SYMBOL_GPL(tty_put_char);
2810
Alan Coxd81ed102008-10-13 10:41:42 +01002811struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812
2813/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002814 * tty_register_device - register a tty device
2815 * @driver: the tty driver that describes the tty device
2816 * @index: the index in the tty driver for this tty device
2817 * @device: a struct device that is associated with this tty device.
2818 * This field is optional, if there is no known struct device
2819 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002821 * Returns a pointer to the struct device for this tty device
2822 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002823 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002824 * This call is required to be made to register an individual tty device
2825 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2826 * that bit is not set, this function should not be called by a tty
2827 * driver.
2828 *
2829 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002831
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002832struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2833 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834{
2835 char name[64];
2836 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2837
2838 if (index >= driver->num) {
2839 printk(KERN_ERR "Attempt to register invalid tty line number "
2840 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002841 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 }
2843
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 if (driver->type == TTY_DRIVER_TYPE_PTY)
2845 pty_line_name(driver, index, name);
2846 else
2847 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002848
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07002849 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002851EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852
2853/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002854 * tty_unregister_device - unregister a tty device
2855 * @driver: the tty driver that describes the tty device
2856 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002858 * If a tty device is registered with a call to tty_register_device() then
2859 * this function must be called when the tty device is gone.
2860 *
2861 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002863
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864void tty_unregister_device(struct tty_driver *driver, unsigned index)
2865{
Alan Cox37bdfb02008-02-08 04:18:47 -08002866 device_destroy(tty_class,
2867 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869EXPORT_SYMBOL(tty_unregister_device);
2870
2871struct tty_driver *alloc_tty_driver(int lines)
2872{
2873 struct tty_driver *driver;
2874
Jean Delvare506eb992007-07-15 23:40:14 -07002875 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01002877 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 driver->magic = TTY_DRIVER_MAGIC;
2879 driver->num = lines;
2880 /* later we'll move allocation of tables here */
2881 }
2882 return driver;
2883}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002884EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885
Alan Cox7d7b93c2008-10-13 10:42:09 +01002886static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002888 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2889 int i;
2890 struct ktermios *tp;
2891 void *p;
2892
2893 if (driver->flags & TTY_DRIVER_INSTALLED) {
2894 /*
2895 * Free the termios and termios_locked structures because
2896 * we don't want to get memory leaks when modular tty
2897 * drivers are removed from the kernel.
2898 */
2899 for (i = 0; i < driver->num; i++) {
2900 tp = driver->termios[i];
2901 if (tp) {
2902 driver->termios[i] = NULL;
2903 kfree(tp);
2904 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01002905 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
2906 tty_unregister_device(driver, i);
2907 }
2908 p = driver->ttys;
2909 proc_tty_unregister_driver(driver);
2910 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002911 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01002912 kfree(p);
2913 cdev_del(&driver->cdev);
2914 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 kfree(driver);
2916}
2917
Alan Cox7d7b93c2008-10-13 10:42:09 +01002918void tty_driver_kref_put(struct tty_driver *driver)
2919{
2920 kref_put(&driver->kref, destruct_tty_driver);
2921}
2922EXPORT_SYMBOL(tty_driver_kref_put);
2923
Jeff Dikeb68e31d2006-10-02 02:17:18 -07002924void tty_set_operations(struct tty_driver *driver,
2925 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926{
Alan Coxf34d7a52008-04-30 00:54:13 -07002927 driver->ops = op;
2928};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929EXPORT_SYMBOL(tty_set_operations);
2930
Alan Cox7d7b93c2008-10-13 10:42:09 +01002931void put_tty_driver(struct tty_driver *d)
2932{
2933 tty_driver_kref_put(d);
2934}
2935EXPORT_SYMBOL(put_tty_driver);
2936
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937/*
2938 * Called by a tty driver to register itself.
2939 */
2940int tty_register_driver(struct tty_driver *driver)
2941{
2942 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08002943 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 dev_t dev;
2945 void **p = NULL;
2946
Andy Whitcroft543691a62007-05-06 14:49:33 -07002947 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01002948 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 if (!p)
2950 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 }
2952
2953 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002954 error = alloc_chrdev_region(&dev, driver->minor_start,
2955 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 if (!error) {
2957 driver->major = MAJOR(dev);
2958 driver->minor_start = MINOR(dev);
2959 }
2960 } else {
2961 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01002962 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963 }
2964 if (error < 0) {
2965 kfree(p);
2966 return error;
2967 }
2968
2969 if (p) {
2970 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08002971 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 } else {
2973 driver->ttys = NULL;
2974 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 }
2976
2977 cdev_init(&driver->cdev, &tty_fops);
2978 driver->cdev.owner = driver->owner;
2979 error = cdev_add(&driver->cdev, dev, driver->num);
2980 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981 unregister_chrdev_region(dev, driver->num);
2982 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002983 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 kfree(p);
2985 return error;
2986 }
2987
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002988 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002990 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08002991
2992 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
2993 for (i = 0; i < driver->num; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994 tty_register_device(driver, i, NULL);
2995 }
2996 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01002997 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998 return 0;
2999}
3000
3001EXPORT_SYMBOL(tty_register_driver);
3002
3003/*
3004 * Called by a tty driver to unregister itself.
3005 */
3006int tty_unregister_driver(struct tty_driver *driver)
3007{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003008#if 0
3009 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010 if (driver->refcount)
3011 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003012#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3014 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003015 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003017 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018 return 0;
3019}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003020
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021EXPORT_SYMBOL(tty_unregister_driver);
3022
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003023dev_t tty_devnum(struct tty_struct *tty)
3024{
3025 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3026}
3027EXPORT_SYMBOL(tty_devnum);
3028
3029void proc_clear_tty(struct task_struct *p)
3030{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003031 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003032 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003033 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003034 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003035 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003036 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003037 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003038}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003039
Alan Cox47f86832008-04-30 00:53:30 -07003040/* Called under the sighand lock */
3041
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003042static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003043{
3044 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003045 unsigned long flags;
3046 /* We should not have a session or pgrp to put here but.... */
3047 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003048 put_pid(tty->session);
3049 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003050 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003051 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3052 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003053 if (tsk->signal->tty) {
3054 printk(KERN_DEBUG "tty not NULL!!\n");
3055 tty_kref_put(tsk->signal->tty);
3056 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003057 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003058 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003059 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003060 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003061}
3062
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003063static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003064{
3065 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003066 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003067 spin_unlock_irq(&tsk->sighand->siglock);
3068}
3069
3070struct tty_struct *get_current_tty(void)
3071{
3072 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003073 unsigned long flags;
3074
3075 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003076 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003077 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003078 return tty;
3079}
Heiko Carstensa311f742006-12-13 00:33:41 -08003080EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081
Alan Coxd81ed102008-10-13 10:41:42 +01003082void tty_default_fops(struct file_operations *fops)
3083{
3084 *fops = tty_fops;
3085}
3086
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087/*
3088 * Initialize the console device. This is called *early*, so
3089 * we can't necessarily depend on lots of kernel help here.
3090 * Just do some early initializations, and do the complex setup
3091 * later.
3092 */
3093void __init console_init(void)
3094{
3095 initcall_t *call;
3096
3097 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003098 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099
3100 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003101 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102 * inform about problems etc..
3103 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104 call = __con_initcall_start;
3105 while (call < __con_initcall_end) {
3106 (*call)();
3107 call++;
3108 }
3109}
3110
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111static int __init tty_class_init(void)
3112{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003113 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 if (IS_ERR(tty_class))
3115 return PTR_ERR(tty_class);
3116 return 0;
3117}
3118
3119postcore_initcall(tty_class_init);
3120
3121/* 3/2004 jmc: why do these devices exist? */
3122
3123static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124
3125/*
3126 * Ok, now we can initialize the rest of the tty devices and can count
3127 * on memory allocations, interrupts etc..
3128 */
3129static int __init tty_init(void)
3130{
3131 cdev_init(&tty_cdev, &tty_fops);
3132 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3133 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3134 panic("Couldn't register /dev/tty driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003135 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003136 "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137
3138 cdev_init(&console_cdev, &console_fops);
3139 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3140 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3141 panic("Couldn't register /dev/console driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003142 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003143 "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003146 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147#endif
3148 return 0;
3149}
3150module_init(tty_init);