blob: d71f0fc34b467c6e7a7c25c0762321f90b7e3fa0 [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 *);
Alan Cox04f378b2008-04-30 00:53:29 -0700145long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700146#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800147static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700148 unsigned long arg);
149#else
150#define tty_compat_ioctl NULL
151#endif
Alan Cox37bdfb02008-02-08 04:18:47 -0800152static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800153static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700154static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700155static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Alan Coxaf9b8972006-08-27 01:24:01 -0700157/**
158 * alloc_tty_struct - allocate a tty object
159 *
160 * Return a new empty tty structure. The data fields have not
161 * been initialized in any way but has been zeroed
162 *
163 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700164 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Alan Coxbf970ee2008-10-13 10:42:39 +0100166struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Alan Cox1266b1e2006-09-29 02:00:40 -0700168 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
170
Alan Coxaf9b8972006-08-27 01:24:01 -0700171/**
172 * free_tty_struct - free a disused tty
173 * @tty: tty struct to free
174 *
175 * Free the write buffers, tty queue and tty memory itself.
176 *
177 * Locking: none. Must be called after tty is definitely unused
178 */
179
Alan Coxbf970ee2008-10-13 10:42:39 +0100180void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
182 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800183 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 kfree(tty);
185}
186
187#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
188
Alan Coxaf9b8972006-08-27 01:24:01 -0700189/**
190 * tty_name - return tty naming
191 * @tty: tty structure
192 * @buf: buffer for output
193 *
194 * Convert a tty structure into a name. The name reflects the kernel
195 * naming policy and if udev is in use may not reflect user space
196 *
197 * Locking: none
198 */
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200char *tty_name(struct tty_struct *tty, char *buf)
201{
202 if (!tty) /* Hmm. NULL pointer. That's fun. */
203 strcpy(buf, "NULL tty");
204 else
205 strcpy(buf, tty->name);
206 return buf;
207}
208
209EXPORT_SYMBOL(tty_name);
210
Andrew Mortond769a662005-05-05 16:15:50 -0700211int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 const char *routine)
213{
214#ifdef TTY_PARANOIA_CHECK
215 if (!tty) {
216 printk(KERN_WARNING
217 "null TTY for (%d:%d) in %s\n",
218 imajor(inode), iminor(inode), routine);
219 return 1;
220 }
221 if (tty->magic != TTY_MAGIC) {
222 printk(KERN_WARNING
223 "bad magic number for tty struct (%d:%d) in %s\n",
224 imajor(inode), iminor(inode), routine);
225 return 1;
226 }
227#endif
228 return 0;
229}
230
231static int check_tty_count(struct tty_struct *tty, const char *routine)
232{
233#ifdef CHECK_TTY_COUNT
234 struct list_head *p;
235 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 file_list_lock();
238 list_for_each(p, &tty->tty_files) {
239 count++;
240 }
241 file_list_unlock();
242 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
243 tty->driver->subtype == PTY_TYPE_SLAVE &&
244 tty->link && tty->link->count)
245 count++;
246 if (tty->count != count) {
247 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
248 "!= #fd's(%d) in %s\n",
249 tty->name, tty->count, count, routine);
250 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800251 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252#endif
253 return 0;
254}
255
Alan Coxaf9b8972006-08-27 01:24:01 -0700256/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700257 * get_tty_driver - find device of a tty
258 * @dev_t: device identifier
259 * @index: returns the index of the tty
260 *
261 * This routine returns a tty driver structure, given a device number
262 * and also passes back the index number.
263 *
264 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267static struct tty_driver *get_tty_driver(dev_t device, int *index)
268{
269 struct tty_driver *p;
270
271 list_for_each_entry(p, &tty_drivers, tty_drivers) {
272 dev_t base = MKDEV(p->major, p->minor_start);
273 if (device < base || device >= base + p->num)
274 continue;
275 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100276 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 }
278 return NULL;
279}
280
Jason Wesself2d937f2008-04-17 20:05:37 +0200281#ifdef CONFIG_CONSOLE_POLL
282
283/**
284 * tty_find_polling_driver - find device of a polled tty
285 * @name: name string to match
286 * @line: pointer to resulting tty line nr
287 *
288 * This routine returns a tty driver structure, given a name
289 * and the condition that the tty driver is capable of polled
290 * operation.
291 */
292struct tty_driver *tty_find_polling_driver(char *name, int *line)
293{
294 struct tty_driver *p, *res = NULL;
295 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500296 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100297 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200298
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500299 for (str = name; *str; str++)
300 if ((*str >= '0' && *str <= '9') || *str == ',')
301 break;
302 if (!*str)
303 return NULL;
304
305 len = str - name;
306 tty_line = simple_strtoul(str, &str, 10);
307
Jason Wesself2d937f2008-04-17 20:05:37 +0200308 mutex_lock(&tty_mutex);
309 /* Search through the tty devices to look for a match */
310 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500311 if (strncmp(name, p->name, len) != 0)
312 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100313 stp = str;
314 if (*stp == ',')
315 stp++;
316 if (*stp == '\0')
317 stp = 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 &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100320 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
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 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700467 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468}
469
470EXPORT_SYMBOL_GPL(tty_wakeup);
471
472/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700473 * do_tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000474 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700475 *
Alan Cox1bad8792008-07-22 23:38:04 +0100476 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700477 * synchronous but doesn't hold any locks, so we need to make sure we
478 * have the appropriate locks for what we're doing.
479 *
480 * The hangup event clears any pending redirections onto the hung up
481 * device. It ensures future writes will error and it does the needed
482 * line discipline hangup and signal delivery. The tty object itself
483 * remains intact.
484 *
485 * Locking:
486 * BKL
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800487 * redirect lock for undoing redirection
488 * file list lock for manipulating list of ttys
489 * tty_ldisc_lock from called functions
490 * termios_mutex resetting termios data
491 * tasklist_lock to walk task list for hangup event
492 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 */
David Howells65f27f32006-11-22 14:55:48 +0000494static void do_tty_hangup(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495{
David Howells65f27f32006-11-22 14:55:48 +0000496 struct tty_struct *tty =
497 container_of(work, struct tty_struct, hangup_work);
Alan Cox37bdfb02008-02-08 04:18:47 -0800498 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 struct file *filp, *f = NULL;
500 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700502 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100503 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 if (!tty)
506 return;
507
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
509 spin_lock(&redirect_lock);
510 if (redirect && redirect->private_data == tty) {
511 f = redirect;
512 redirect = NULL;
513 }
514 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800515
Alan Cox38c70b22009-11-30 13:18:40 +0000516 /* inuse_filps is protected by the single kernel lock */
517 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 check_tty_count(tty, "do_tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 file_list_lock();
521 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Eric Dumazet2f512012005-10-30 15:02:16 -0800522 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (filp->f_op->write == redirected_tty_write)
524 cons_filp = filp;
525 if (filp->f_op->write != tty_write)
526 continue;
527 closecount++;
528 tty_fasync(-1, filp, 0); /* can't block */
529 filp->f_op = &hung_up_tty_fops;
530 }
531 file_list_unlock();
Alan Cox37bdfb02008-02-08 04:18:47 -0800532
Alan Coxc65c9bc2009-06-11 12:50:12 +0100533 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800536 if (tty->session) {
537 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800538 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100539 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100541 /* We defer the dereferences outside fo
542 the tasklist lock */
543 refs++;
544 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800545 if (!p->signal->leader) {
546 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800548 }
549 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
550 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800551 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700552 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800553 if (tty->pgrp)
554 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700555 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800556 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800557 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 }
559 read_unlock(&tasklist_lock);
560
Alan Cox47f86832008-04-30 00:53:30 -0700561 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100562 clear_bit(TTY_THROTTLED, &tty->flags);
563 clear_bit(TTY_PUSH, &tty->flags);
564 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600565 put_pid(tty->session);
566 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800567 tty->session = NULL;
568 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 tty->ctrl_status = 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100570 set_bit(TTY_HUPPED, &tty->flags);
Alan Cox47f86832008-04-30 00:53:30 -0700571 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
572
Alan Cox9c9f4de2008-10-13 10:37:26 +0100573 /* Account for the p->signal references we killed */
574 while (refs--)
575 tty_kref_put(tty);
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800578 * If one of the devices matches a console pointer, we
579 * cannot just call hangup() because that will cause
580 * tty->count and state->count to go out of sync.
581 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 */
583 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700584 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700586 tty->ops->close(tty, cons_filp);
587 } else if (tty->ops->hangup)
588 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800589 /*
590 * We don't want to have driver/ldisc interactions beyond
591 * the ones we did here. The driver layer expects no
592 * calls after ->hangup() from the ldisc side. However we
593 * can't yet guarantee all that.
594 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 set_bit(TTY_HUPPED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100596 tty_ldisc_enable(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 unlock_kernel();
598 if (f)
599 fput(f);
600}
601
Alan Coxaf9b8972006-08-27 01:24:01 -0700602/**
603 * tty_hangup - trigger a hangup event
604 * @tty: tty to hangup
605 *
606 * A carrier loss (virtual or otherwise) has occurred on this like
607 * schedule a hangup sequence to run after this event.
608 */
609
Alan Cox37bdfb02008-02-08 04:18:47 -0800610void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
612#ifdef TTY_DEBUG_HANGUP
613 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
615#endif
616 schedule_work(&tty->hangup_work);
617}
618
619EXPORT_SYMBOL(tty_hangup);
620
Alan Coxaf9b8972006-08-27 01:24:01 -0700621/**
622 * tty_vhangup - process vhangup
623 * @tty: tty to hangup
624 *
625 * The user has asked via system call for the terminal to be hung up.
626 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200627 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700628 */
629
Alan Cox37bdfb02008-02-08 04:18:47 -0800630void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
632#ifdef TTY_DEBUG_HANGUP
633 char buf[64];
634
635 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
636#endif
David Howells65f27f32006-11-22 14:55:48 +0000637 do_tty_hangup(&tty->hangup_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638}
Alan Cox37bdfb02008-02-08 04:18:47 -0800639
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640EXPORT_SYMBOL(tty_vhangup);
641
Alan Coxaf9b8972006-08-27 01:24:01 -0700642/**
Alan Cox2cb59982008-10-13 10:40:30 +0100643 * tty_vhangup_self - process vhangup for own ctty
644 *
645 * Perform a vhangup on the current controlling tty
646 */
647
648void tty_vhangup_self(void)
649{
650 struct tty_struct *tty;
651
Alan Cox2cb59982008-10-13 10:40:30 +0100652 tty = get_current_tty();
653 if (tty) {
654 tty_vhangup(tty);
655 tty_kref_put(tty);
656 }
Alan Cox2cb59982008-10-13 10:40:30 +0100657}
658
659/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700660 * tty_hung_up_p - was tty hung up
661 * @filp: file pointer of tty
662 *
663 * Return true if the tty has been subject to a vhangup or a carrier
664 * loss
665 */
666
Alan Cox37bdfb02008-02-08 04:18:47 -0800667int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668{
669 return (filp->f_op == &hung_up_tty_fops);
670}
671
672EXPORT_SYMBOL(tty_hung_up_p);
673
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800674static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800675{
676 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800677 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800678 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800679 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800680}
681
Alan Coxaf9b8972006-08-27 01:24:01 -0700682/**
683 * disassociate_ctty - disconnect controlling tty
684 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700686 * This function is typically called only by the session leader, when
687 * it wants to disassociate itself from its controlling tty.
688 *
689 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
691 * (2) Clears the tty from being controlling the session
692 * (3) Clears the controlling tty for all processes in the
693 * session group.
694 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700695 * The argument on_exit is set to 1 if called when a process is
696 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
697 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800698 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -0700699 * BKL is taken for hysterical raisins
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800700 * tty_mutex is taken to protect tty
701 * ->siglock is taken to protect ->signal/->sighand
702 * tasklist_lock is taken to walk process list for sessions
703 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700705
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706void disassociate_ctty(int on_exit)
707{
708 struct tty_struct *tty;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800709 struct pid *tty_pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Alan Cox5ec93d12009-11-30 13:18:45 +0000711 if (!current->signal->leader)
712 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800714 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 if (tty) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800716 tty_pgrp = get_pid(tty->pgrp);
Alan Cox452a00d2008-10-13 10:39:13 +0100717 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
719 tty_vhangup(tty);
Alan Cox04f378b2008-04-30 00:53:29 -0700720 unlock_kernel();
Alan Cox452a00d2008-10-13 10:39:13 +0100721 tty_kref_put(tty);
Eric W. Biederman680a9672007-02-12 00:52:52 -0800722 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800723 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800724 spin_lock_irq(&current->sighand->siglock);
725 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800726 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800727 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800728 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800729 kill_pgrp(old_pgrp, SIGHUP, on_exit);
730 kill_pgrp(old_pgrp, SIGCONT, on_exit);
731 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 return;
734 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800735 if (tty_pgrp) {
736 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 if (!on_exit)
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800738 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
739 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 }
741
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800742 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700743 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800744 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800745 spin_unlock_irq(&current->sighand->siglock);
746
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800747 tty = get_current_tty();
748 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700749 unsigned long flags;
750 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800751 put_pid(tty->session);
752 put_pid(tty->pgrp);
753 tty->session = NULL;
754 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700755 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100756 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800757 } else {
758#ifdef TTY_DEBUG_HANGUP
759 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
760 " = NULL", tty);
761#endif
762 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
764 /* Now clear signal->tty under the lock */
765 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800766 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700770/**
771 *
772 * no_tty - Ensure the current process does not have a controlling tty
773 */
774void no_tty(void)
775{
776 struct task_struct *tsk = current;
Alan Cox04f378b2008-04-30 00:53:29 -0700777 lock_kernel();
Alan Cox5ec93d12009-11-30 13:18:45 +0000778 disassociate_ctty(0);
Alan Cox04f378b2008-04-30 00:53:29 -0700779 unlock_kernel();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700780 proc_clear_tty(tsk);
781}
782
Alan Coxaf9b8972006-08-27 01:24:01 -0700783
784/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200785 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700786 * @tty: tty to stop
787 *
788 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200789 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700790 * on an already stopped device and will not re-call the driver
791 * method.
792 *
793 * This functionality is used by both the line disciplines for
794 * halting incoming flow and by the driver. It may therefore be
795 * called from any context, may be under the tty atomic_write_lock
796 * but not always.
797 *
798 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700799 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700800 */
801
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802void stop_tty(struct tty_struct *tty)
803{
Alan Cox04f378b2008-04-30 00:53:29 -0700804 unsigned long flags;
805 spin_lock_irqsave(&tty->ctrl_lock, flags);
806 if (tty->stopped) {
807 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700809 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 tty->stopped = 1;
811 if (tty->link && tty->link->packet) {
812 tty->ctrl_status &= ~TIOCPKT_START;
813 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700814 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 }
Alan Cox04f378b2008-04-30 00:53:29 -0700816 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700817 if (tty->ops->stop)
818 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819}
820
821EXPORT_SYMBOL(stop_tty);
822
Alan Coxaf9b8972006-08-27 01:24:01 -0700823/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200824 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700825 * @tty: tty to start
826 *
827 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200828 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700829 * is the tty was previous stopped and is being started then the
830 * driver start method is invoked and the line discipline woken.
831 *
832 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700833 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700834 */
835
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836void start_tty(struct tty_struct *tty)
837{
Alan Cox04f378b2008-04-30 00:53:29 -0700838 unsigned long flags;
839 spin_lock_irqsave(&tty->ctrl_lock, flags);
840 if (!tty->stopped || tty->flow_stopped) {
841 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700843 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 tty->stopped = 0;
845 if (tty->link && tty->link->packet) {
846 tty->ctrl_status &= ~TIOCPKT_STOP;
847 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700848 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 }
Alan Cox04f378b2008-04-30 00:53:29 -0700850 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700851 if (tty->ops->start)
852 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 /* If we have a running line discipline it may need kicking */
854 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855}
856
857EXPORT_SYMBOL(start_tty);
858
Alan Coxaf9b8972006-08-27 01:24:01 -0700859/**
860 * tty_read - read method for tty device files
861 * @file: pointer to tty file
862 * @buf: user buffer
863 * @count: size of user buffer
864 * @ppos: unused
865 *
866 * Perform the read system call function on this terminal device. Checks
867 * for hung up devices before calling the line discipline method.
868 *
869 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700870 * Locks the line discipline internally while needed. Multiple
871 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700872 */
873
Alan Cox37bdfb02008-02-08 04:18:47 -0800874static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 loff_t *ppos)
876{
877 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -0800878 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 struct inode *inode;
880 struct tty_ldisc *ld;
881
882 tty = (struct tty_struct *)file->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -0800883 inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 if (tty_paranoia_check(tty, inode, "tty_read"))
885 return -EIO;
886 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
887 return -EIO;
888
889 /* We want to wait for the line discipline to sort out in this
890 situation */
891 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100892 if (ld->ops->read)
893 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 else
895 i = -EIO;
896 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 if (i > 0)
898 inode->i_atime = current_fs_time(inode->i_sb);
899 return i;
900}
901
Alan Cox9c1729d2007-07-15 23:39:43 -0700902void tty_write_unlock(struct tty_struct *tty)
903{
904 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700905 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700906}
907
908int tty_write_lock(struct tty_struct *tty, int ndelay)
909{
910 if (!mutex_trylock(&tty->atomic_write_lock)) {
911 if (ndelay)
912 return -EAGAIN;
913 if (mutex_lock_interruptible(&tty->atomic_write_lock))
914 return -ERESTARTSYS;
915 }
916 return 0;
917}
918
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919/*
920 * Split writes up in sane blocksizes to avoid
921 * denial-of-service type attacks
922 */
923static inline ssize_t do_tty_write(
924 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
925 struct tty_struct *tty,
926 struct file *file,
927 const char __user *buf,
928 size_t count)
929{
Alan Cox9c1729d2007-07-15 23:39:43 -0700930 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -0800932
Alan Cox9c1729d2007-07-15 23:39:43 -0700933 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
934 if (ret < 0)
935 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 /*
938 * We chunk up writes into a temporary buffer. This
939 * simplifies low-level drivers immensely, since they
940 * don't have locking issues and user mode accesses.
941 *
942 * But if TTY_NO_WRITE_SPLIT is set, we should use a
943 * big chunk-size..
944 *
945 * The default chunk-size is 2kB, because the NTTY
946 * layer has problems with bigger chunks. It will
947 * claim to be able to handle more characters than
948 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -0700949 *
950 * FIXME: This can probably go away now except that 64K chunks
951 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 */
953 chunk = 2048;
954 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
955 chunk = 65536;
956 if (count < chunk)
957 chunk = count;
958
Ingo Molnar70522e12006-03-23 03:00:31 -0800959 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +0100961 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
963 if (chunk < 1024)
964 chunk = 1024;
965
Jason Wessel402fda92008-10-13 10:45:36 +0100966 buf_chunk = kmalloc(chunk, GFP_KERNEL);
967 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -0700968 ret = -ENOMEM;
969 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 }
971 kfree(tty->write_buf);
972 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +0100973 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975
976 /* Do the write .. */
977 for (;;) {
978 size_t size = count;
979 if (size > chunk)
980 size = chunk;
981 ret = -EFAULT;
982 if (copy_from_user(tty->write_buf, buf, size))
983 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 if (ret <= 0)
986 break;
987 written += ret;
988 buf += ret;
989 count -= ret;
990 if (!count)
991 break;
992 ret = -ERESTARTSYS;
993 if (signal_pending(current))
994 break;
995 cond_resched();
996 }
997 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -0800998 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 inode->i_mtime = current_fs_time(inode->i_sb);
1000 ret = written;
1001 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001002out:
1003 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 return ret;
1005}
1006
Alan Cox95f9bfc2008-10-13 10:39:23 +01001007/**
1008 * tty_write_message - write a message to a certain tty, not just the console.
1009 * @tty: the destination tty_struct
1010 * @msg: the message to write
1011 *
1012 * This is used for messages that need to be redirected to a specific tty.
1013 * We don't put it into the syslog queue right now maybe in the future if
1014 * really needed.
1015 *
1016 * We must still hold the BKL and test the CLOSING flag for the moment.
1017 */
1018
1019void tty_write_message(struct tty_struct *tty, char *msg)
1020{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001021 if (tty) {
1022 mutex_lock(&tty->atomic_write_lock);
Alan Coxeeb89d92009-11-30 13:18:29 +00001023 lock_kernel();
1024 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
1025 unlock_kernel();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001026 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001027 } else
1028 unlock_kernel();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001029 tty_write_unlock(tty);
1030 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001031 return;
1032}
1033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034
Alan Coxaf9b8972006-08-27 01:24:01 -07001035/**
1036 * tty_write - write method for tty device file
1037 * @file: tty file pointer
1038 * @buf: user data to write
1039 * @count: bytes to write
1040 * @ppos: unused
1041 *
1042 * Write data to a tty device via the line discipline.
1043 *
1044 * Locking:
1045 * Locks the line discipline as required
1046 * Writes to the tty driver are serialized by the atomic_write_lock
1047 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001048 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001049 */
1050
Alan Cox37bdfb02008-02-08 04:18:47 -08001051static ssize_t tty_write(struct file *file, const char __user *buf,
1052 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053{
Alan Cox37bdfb02008-02-08 04:18:47 -08001054 struct tty_struct *tty;
Josef Sipeka7113a92006-12-08 02:36:55 -08001055 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 ssize_t ret;
1057 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08001058
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 tty = (struct tty_struct *)file->private_data;
1060 if (tty_paranoia_check(tty, inode, "tty_write"))
1061 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001062 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001063 (test_bit(TTY_IO_ERROR, &tty->flags)))
1064 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001065 /* Short term debug to catch buggy drivers */
1066 if (tty->ops->write_room == NULL)
1067 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1068 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001069 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001070 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 ret = -EIO;
1072 else
Alan Coxa352def2008-07-16 21:53:12 +01001073 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 tty_ldisc_deref(ld);
1075 return ret;
1076}
1077
Alan Cox37bdfb02008-02-08 04:18:47 -08001078ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1079 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080{
1081 struct file *p = NULL;
1082
1083 spin_lock(&redirect_lock);
1084 if (redirect) {
1085 get_file(redirect);
1086 p = redirect;
1087 }
1088 spin_unlock(&redirect_lock);
1089
1090 if (p) {
1091 ssize_t res;
1092 res = vfs_write(p, buf, count, &p->f_pos);
1093 fput(p);
1094 return res;
1095 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 return tty_write(file, buf, count, ppos);
1097}
1098
1099static char ptychar[] = "pqrstuvwxyzabcde";
1100
Alan Coxaf9b8972006-08-27 01:24:01 -07001101/**
1102 * pty_line_name - generate name for a pty
1103 * @driver: the tty driver in use
1104 * @index: the minor number
1105 * @p: output buffer of at least 6 bytes
1106 *
1107 * Generate a name from a driver reference and write it to the output
1108 * buffer.
1109 *
1110 * Locking: None
1111 */
1112static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113{
1114 int i = index + driver->name_base;
1115 /* ->name is initialized to "ttyp", but "tty" is expected */
1116 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001117 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1118 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119}
1120
Alan Coxaf9b8972006-08-27 01:24:01 -07001121/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001122 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001123 * @driver: the tty driver in use
1124 * @index: the minor number
1125 * @p: output buffer of at least 7 bytes
1126 *
1127 * Generate a name from a driver reference and write it to the output
1128 * buffer.
1129 *
1130 * Locking: None
1131 */
1132static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133{
1134 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1135}
1136
Alan Cox99f1fe12008-10-13 10:42:00 +01001137/**
1138 * tty_driver_lookup_tty() - find an existing tty, if any
1139 * @driver: the driver for the tty
1140 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001141 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001142 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001143 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001144 * Locking: tty_mutex must be held. If tty is found, the mutex must
1145 * be held until the 'fast-open' is also done. Will change once we
1146 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001147 */
Jason Wessela47d5452009-01-02 13:43:04 +00001148static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001149 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001150{
1151 struct tty_struct *tty;
1152
Alan Cox99f1fe12008-10-13 10:42:00 +01001153 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001154 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001155
Alan Cox8b0a88d2008-10-13 10:42:19 +01001156 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001157 return tty;
1158}
1159
Alan Cox99f1fe12008-10-13 10:42:00 +01001160/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001161 * tty_init_termios - helper for termios setup
1162 * @tty: the tty to set up
1163 *
1164 * Initialise the termios structures for this tty. Thus runs under
1165 * the tty_mutex currently so we can be relaxed about ordering.
1166 */
1167
1168int tty_init_termios(struct tty_struct *tty)
1169{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001170 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001171 int idx = tty->index;
1172
1173 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001174 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001175 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1176 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001177 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001178 memcpy(tp, &tty->driver->init_termios,
1179 sizeof(struct ktermios));
1180 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001181 }
1182 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001183 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001184
1185 /* Compatibility until drivers always set this */
1186 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1187 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1188 return 0;
1189}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001190EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001191
1192/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001193 * tty_driver_install_tty() - install a tty entry in the driver
1194 * @driver: the driver for the tty
1195 * @tty: the tty
1196 *
1197 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001198 * will be set by the time this is called. This method is responsible
1199 * for ensuring any need additional structures are allocated and
1200 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001201 *
1202 * Locking: tty_mutex for now
1203 */
1204static int tty_driver_install_tty(struct tty_driver *driver,
1205 struct tty_struct *tty)
1206{
Alan Coxbf970ee2008-10-13 10:42:39 +01001207 int idx = tty->index;
Alan Coxeeb89d92009-11-30 13:18:29 +00001208 int ret;
Alan Coxbf970ee2008-10-13 10:42:39 +01001209
Alan Coxeeb89d92009-11-30 13:18:29 +00001210 if (driver->ops->install) {
1211 lock_kernel();
1212 ret = driver->ops->install(driver, tty);
1213 unlock_kernel();
1214 return ret;
1215 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001216
1217 if (tty_init_termios(tty) == 0) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001218 lock_kernel();
Alan Coxbf970ee2008-10-13 10:42:39 +01001219 tty_driver_kref_get(driver);
1220 tty->count++;
1221 driver->ttys[idx] = tty;
Alan Coxeeb89d92009-11-30 13:18:29 +00001222 unlock_kernel();
Alan Coxbf970ee2008-10-13 10:42:39 +01001223 return 0;
1224 }
1225 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001226}
1227
1228/**
1229 * tty_driver_remove_tty() - remove a tty from the driver tables
1230 * @driver: the driver for the tty
1231 * @idx: the minor number
1232 *
1233 * Remvoe a tty object from the driver tables. The tty->index field
1234 * will be set by the time this is called.
1235 *
1236 * Locking: tty_mutex for now
1237 */
1238static void tty_driver_remove_tty(struct tty_driver *driver,
1239 struct tty_struct *tty)
1240{
1241 if (driver->ops->remove)
1242 driver->ops->remove(driver, tty);
1243 else
1244 driver->ttys[tty->index] = NULL;
1245}
1246
1247/*
1248 * tty_reopen() - fast re-open of an open tty
1249 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001250 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001251 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001252 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001253 * Locking: tty_mutex must be held from the time the tty was found
1254 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001255 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001256static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001257{
1258 struct tty_driver *driver = tty->driver;
1259
1260 if (test_bit(TTY_CLOSING, &tty->flags))
1261 return -EIO;
1262
1263 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1264 driver->subtype == PTY_TYPE_MASTER) {
1265 /*
1266 * special case for PTY masters: only one open permitted,
1267 * and the slave side open count is incremented as well.
1268 */
1269 if (tty->count)
1270 return -EIO;
1271
1272 tty->link->count++;
1273 }
1274 tty->count++;
1275 tty->driver = driver; /* N.B. why do this every time?? */
1276
Alan Cox1aa4bed2009-06-16 17:01:33 +01001277 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001278 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001279 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001280
1281 return 0;
1282}
1283
Alan Coxaf9b8972006-08-27 01:24:01 -07001284/**
Alan Coxd81ed102008-10-13 10:41:42 +01001285 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001286 * @driver: tty driver we are opening a device on
1287 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001288 * @ret_tty: returned tty structure
1289 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001290 *
1291 * Prepare a tty device. This may not be a "new" clean device but
1292 * could also be an active device. The pty drivers require special
1293 * handling because of this.
1294 *
1295 * Locking:
1296 * The function is called under the tty_mutex, which
1297 * protects us from the tty struct or driver itself going away.
1298 *
1299 * On exit the tty device has the line discipline attached and
1300 * a reference count of 1. If a pair was created for pty/tty use
1301 * and the other was a pty master then it too has a reference count of 1.
1302 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001304 * failed open. The new code protects the open with a mutex, so it's
1305 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 * relaxed for the (most common) case of reopening a tty.
1307 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001308
Alan Cox73ec06f2008-10-13 10:42:29 +01001309struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1310 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311{
Alan Coxbf970ee2008-10-13 10:42:39 +01001312 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001313 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314
Alan Coxeeb89d92009-11-30 13:18:29 +00001315 lock_kernel();
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001316 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001317 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Coxeeb89d92009-11-30 13:18:29 +00001318 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {
1319 unlock_kernel();
Alan Cox73ec06f2008-10-13 10:42:29 +01001320 return ERR_PTR(-EIO);
Alan Coxeeb89d92009-11-30 13:18:29 +00001321 }
1322 unlock_kernel();
Alan Cox73ec06f2008-10-13 10:42:29 +01001323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 /*
1325 * First time open is complex, especially for PTY devices.
1326 * This code guarantees that either everything succeeds and the
1327 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001328 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 * and locked termios may be retained.)
1330 */
1331
Alan Cox73ec06f2008-10-13 10:42:29 +01001332 if (!try_module_get(driver->owner))
1333 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 tty = alloc_tty_struct();
Alan Cox37bdfb02008-02-08 04:18:47 -08001336 if (!tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 goto fail_no_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +01001338 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Alan Cox73ec06f2008-10-13 10:42:29 +01001340 retval = tty_driver_install_tty(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001341 if (retval < 0) {
1342 free_tty_struct(tty);
1343 module_put(driver->owner);
1344 return ERR_PTR(retval);
1345 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001346
Alan Cox37bdfb02008-02-08 04:18:47 -08001347 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001349 * If we fail here just call release_tty to clean up. No need
1350 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001352 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001353 if (retval)
1354 goto release_mem_out;
Alan Cox73ec06f2008-10-13 10:42:29 +01001355 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357fail_no_mem:
1358 module_put(driver->owner);
Alan Cox73ec06f2008-10-13 10:42:29 +01001359 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001361 /* call the tty release_tty routine to clean out this slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362release_mem_out:
Akinobu Mita40509142006-09-29 02:01:27 -07001363 if (printk_ratelimit())
Alan Coxd81ed102008-10-13 10:41:42 +01001364 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001365 "clearing slot %d\n", idx);
Alan Coxeeb89d92009-11-30 13:18:29 +00001366 lock_kernel();
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001367 release_tty(tty, idx);
Alan Coxeeb89d92009-11-30 13:18:29 +00001368 unlock_kernel();
Alan Cox73ec06f2008-10-13 10:42:29 +01001369 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370}
1371
Alan Coxfeebed62008-10-13 10:41:30 +01001372void tty_free_termios(struct tty_struct *tty)
1373{
1374 struct ktermios *tp;
1375 int idx = tty->index;
1376 /* Kill this flag and push into drivers for locking etc */
1377 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1378 /* FIXME: Locking on ->termios array */
1379 tp = tty->termios;
1380 tty->driver->termios[idx] = NULL;
1381 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001382 }
1383}
1384EXPORT_SYMBOL(tty_free_termios);
1385
1386void tty_shutdown(struct tty_struct *tty)
1387{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001388 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001389 tty_free_termios(tty);
1390}
1391EXPORT_SYMBOL(tty_shutdown);
1392
Alan Coxaf9b8972006-08-27 01:24:01 -07001393/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001394 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001395 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001396 *
1397 * Releases memory associated with a tty structure, and clears out the
1398 * driver table slots. This function is called when a device is no longer
1399 * in use. It also gets called when setup of a device fails.
1400 *
1401 * Locking:
1402 * tty_mutex - sometimes only
1403 * takes the file list lock internally when working on the list
1404 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001405 *
1406 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001407 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 */
Alan Coxb50989d2009-09-19 13:13:22 -07001409static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410{
Alan Coxb50989d2009-09-19 13:13:22 -07001411 struct tty_struct *tty =
1412 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001413 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Dave Youngf278a2f2009-09-27 16:00:42 +00001415 if (tty->ops->cleanup)
1416 tty->ops->cleanup(tty);
1417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001419 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001420 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001421
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 file_list_lock();
1423 list_del_init(&tty->tty_files);
1424 file_list_unlock();
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001425
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001426 put_pid(tty->pgrp);
1427 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 free_tty_struct(tty);
1429}
1430
Alan Coxb50989d2009-09-19 13:13:22 -07001431static void queue_release_one_tty(struct kref *kref)
1432{
1433 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001434
1435 if (tty->ops->shutdown)
1436 tty->ops->shutdown(tty);
1437 else
1438 tty_shutdown(tty);
1439
Alan Coxb50989d2009-09-19 13:13:22 -07001440 /* The hangup queue is now free so we can reuse it rather than
1441 waste a chunk of memory for each port */
1442 INIT_WORK(&tty->hangup_work, release_one_tty);
1443 schedule_work(&tty->hangup_work);
1444}
1445
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001446/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001447 * tty_kref_put - release a tty kref
1448 * @tty: tty device
1449 *
1450 * Release a reference to a tty device and if need be let the kref
1451 * layer destruct the object for us
1452 */
1453
1454void tty_kref_put(struct tty_struct *tty)
1455{
1456 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001457 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001458}
1459EXPORT_SYMBOL(tty_kref_put);
1460
1461/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001462 * release_tty - release tty structure memory
1463 *
1464 * Release both @tty and a possible linked partner (think pty pair),
1465 * and decrement the refcount of the backing module.
1466 *
1467 * Locking:
1468 * tty_mutex - sometimes only
1469 * takes the file list lock internally when working on the list
1470 * of ttys that the driver keeps.
1471 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001472 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001473 */
1474static void release_tty(struct tty_struct *tty, int idx)
1475{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001476 /* This should always be true but check for the moment */
1477 WARN_ON(tty->index != idx);
1478
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001479 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001480 tty_kref_put(tty->link);
1481 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001482}
1483
Alan Coxeeb89d92009-11-30 13:18:29 +00001484/**
1485 * tty_release - vfs callback for close
1486 * @inode: inode of tty
1487 * @filp: file pointer for handle to tty
1488 *
1489 * Called the last time each file handle is closed that references
1490 * this tty. There may however be several such references.
1491 *
1492 * Locking:
1493 * Takes bkl. See tty_release_dev
1494 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 * Even releasing the tty structures is a tricky business.. We have
1496 * to be very careful that the structures are all released at the
1497 * same time, as interrupts might otherwise get the wrong pointers.
1498 *
1499 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1500 * lead to double frees or releasing memory still in use.
1501 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001502
1503int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
1505 struct tty_struct *tty, *o_tty;
1506 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001507 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 int idx;
1509 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001510
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 tty = (struct tty_struct *)filp->private_data;
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001512 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
Alan Coxeeb89d92009-11-30 13:18:29 +00001513 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
Alan Coxeeb89d92009-11-30 13:18:29 +00001515 lock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001516 check_tty_count(tty, "tty_release_dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
1518 tty_fasync(-1, filp, 0);
1519
1520 idx = tty->index;
1521 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1522 tty->driver->subtype == PTY_TYPE_MASTER);
1523 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 o_tty = tty->link;
1525
1526#ifdef TTY_PARANOIA_CHECK
1527 if (idx < 0 || idx >= tty->driver->num) {
Alan Coxd81ed102008-10-13 10:41:42 +01001528 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 "free (%s)\n", tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001530 unlock_kernel();
1531 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001533 if (!devpts) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 if (tty != tty->driver->ttys[idx]) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001535 unlock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001536 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 "for (%s)\n", idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001538 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 }
1540 if (tty->termios != tty->driver->termios[idx]) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001541 unlock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001542 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 "for (%s)\n",
1544 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001545 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 }
1548#endif
1549
1550#ifdef TTY_DEBUG_HANGUP
Alan Coxd81ed102008-10-13 10:41:42 +01001551 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 tty_name(tty, buf), tty->count);
1553#endif
1554
1555#ifdef TTY_PARANOIA_CHECK
1556 if (tty->driver->other &&
1557 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1558 if (o_tty != tty->driver->other->ttys[idx]) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001559 unlock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001560 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 "not o_tty for (%s)\n",
1562 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001563 return 0 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 }
1565 if (o_tty->termios != tty->driver->other->termios[idx]) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001566 unlock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001567 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 "not o_termios for (%s)\n",
1569 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001570 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 if (o_tty->link != tty) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001573 unlock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001574 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
Alan Coxeeb89d92009-11-30 13:18:29 +00001575 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 }
1577 }
1578#endif
Alan Coxf34d7a52008-04-30 00:54:13 -07001579 if (tty->ops->close)
1580 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581
Alan Coxeeb89d92009-11-30 13:18:29 +00001582 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 /*
1584 * Sanity check: if tty->count is going to zero, there shouldn't be
1585 * any waiters on tty->read_wait or tty->write_wait. We test the
1586 * wait queues and kick everyone out _before_ actually starting to
1587 * close. This ensures that we won't block while releasing the tty
1588 * structure.
1589 *
1590 * The test for the o_tty closing is necessary, since the master and
1591 * slave sides may close in any order. If the slave side closes out
1592 * first, its count will be one, since the master side holds an open.
1593 * Thus this test wouldn't be triggered at the time the slave closes,
1594 * so we do it now.
1595 *
1596 * Note that it's possible for the tty to be opened again while we're
1597 * flushing out waiters. By recalculating the closing flags before
1598 * each iteration we avoid any problems.
1599 */
1600 while (1) {
1601 /* Guard against races with tty->count changes elsewhere and
1602 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001603
Ingo Molnar70522e12006-03-23 03:00:31 -08001604 mutex_lock(&tty_mutex);
Alan Coxeeb89d92009-11-30 13:18:29 +00001605 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 tty_closing = tty->count <= 1;
1607 o_tty_closing = o_tty &&
1608 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 do_sleep = 0;
1610
1611 if (tty_closing) {
1612 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001613 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 do_sleep++;
1615 }
1616 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001617 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 do_sleep++;
1619 }
1620 }
1621 if (o_tty_closing) {
1622 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001623 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 do_sleep++;
1625 }
1626 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001627 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 do_sleep++;
1629 }
1630 }
1631 if (!do_sleep)
1632 break;
1633
Alan Coxd81ed102008-10-13 10:41:42 +01001634 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 "active!\n", tty_name(tty, buf));
Alan Coxeeb89d92009-11-30 13:18:29 +00001636 unlock_kernel();
Ingo Molnar70522e12006-03-23 03:00:31 -08001637 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001639 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
1641 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001642 * The closing flags are now consistent with the open counts on
1643 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 * block, so it's safe to proceed with closing.
1645 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 if (pty_master) {
1647 if (--o_tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001648 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 "(%d) for %s\n",
1650 o_tty->count, tty_name(o_tty, buf));
1651 o_tty->count = 0;
1652 }
1653 }
1654 if (--tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001655 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 tty->count, tty_name(tty, buf));
1657 tty->count = 0;
1658 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001659
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 /*
1661 * We've decremented tty->count, so we need to remove this file
1662 * descriptor off the tty->tty_files list; this serves two
1663 * purposes:
1664 * - check_tty_count sees the correct number of file descriptors
1665 * associated with this tty.
1666 * - do_tty_hangup no longer sees this file descriptor as
1667 * something that needs to be handled for hangups.
1668 */
1669 file_kill(filp);
1670 filp->private_data = NULL;
1671
1672 /*
1673 * Perform some housekeeping before deciding whether to return.
1674 *
1675 * Set the TTY_CLOSING flag if this was the last open. In the
1676 * case of a pty we may have to wait around for the other side
1677 * to close, and TTY_CLOSING makes sure we can't be reopened.
1678 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001679 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001681 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 set_bit(TTY_CLOSING, &o_tty->flags);
1683
1684 /*
1685 * If _either_ side is closing, make sure there aren't any
1686 * processes that still think tty or o_tty is their controlling
1687 * tty.
1688 */
1689 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001691 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001693 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 read_unlock(&tasklist_lock);
1695 }
1696
Ingo Molnar70522e12006-03-23 03:00:31 -08001697 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001698
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 /* check whether both sides are closing ... */
Alan Coxeeb89d92009-11-30 13:18:29 +00001700 if (!tty_closing || (o_tty && !o_tty_closing)) {
1701 unlock_kernel();
1702 return 0;
1703 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001704
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705#ifdef TTY_DEBUG_HANGUP
1706 printk(KERN_DEBUG "freeing tty structure...");
1707#endif
1708 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001709 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001711 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001713 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 * the slots and preserving the termios structure.
1715 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001716 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001719 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001720 devpts_kill_index(inode, idx);
Alan Coxeeb89d92009-11-30 13:18:29 +00001721 unlock_kernel();
1722 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723}
1724
Alan Coxaf9b8972006-08-27 01:24:01 -07001725/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001726 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001727 * @inode: inode of device file
1728 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001730 * tty_open and tty_release keep up the tty count that contains the
1731 * number of opens done on a tty. We cannot use the inode-count, as
1732 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001734 * Open-counting is needed for pty masters, as well as for keeping
1735 * track of serial lines: DTR is dropped when the last close happens.
1736 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1737 *
1738 * The termios state of a pty is reset on first open so that
1739 * settings don't persist across reuse.
1740 *
Alan Coxd81ed102008-10-13 10:41:42 +01001741 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001742 * tty->count should protect the rest.
1743 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001745
Alan Coxeeb89d92009-11-30 13:18:29 +00001746static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747{
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001748 struct tty_struct *tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 int noctty, retval;
1750 struct tty_driver *driver;
1751 int index;
1752 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001753 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
1755 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001756
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757retry_open:
1758 noctty = filp->f_flags & O_NOCTTY;
1759 index = -1;
1760 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001761
Ingo Molnar70522e12006-03-23 03:00:31 -08001762 mutex_lock(&tty_mutex);
Alan Coxeeb89d92009-11-30 13:18:29 +00001763 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
Alan Cox37bdfb02008-02-08 04:18:47 -08001765 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001766 tty = get_current_tty();
1767 if (!tty) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001768 unlock_kernel();
Ingo Molnar70522e12006-03-23 03:00:31 -08001769 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 return -ENXIO;
1771 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01001772 driver = tty_driver_kref_get(tty->driver);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001773 index = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1775 /* noctty = 1; */
Alan Cox452a00d2008-10-13 10:39:13 +01001776 /* FIXME: Should we take a driver reference ? */
1777 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 goto got_driver;
1779 }
1780#ifdef CONFIG_VT
Alan Cox37bdfb02008-02-08 04:18:47 -08001781 if (device == MKDEV(TTY_MAJOR, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 extern struct tty_driver *console_driver;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001783 driver = tty_driver_kref_get(console_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 index = fg_console;
1785 noctty = 1;
1786 goto got_driver;
1787 }
1788#endif
Alan Cox37bdfb02008-02-08 04:18:47 -08001789 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
Will Newton296fa7f2008-12-01 11:36:06 +00001790 struct tty_driver *console_driver = console_device(&index);
1791 if (console_driver) {
1792 driver = tty_driver_kref_get(console_driver);
1793 if (driver) {
1794 /* Don't let /dev/console block */
1795 filp->f_flags |= O_NONBLOCK;
1796 noctty = 1;
1797 goto got_driver;
1798 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 }
Alan Coxeeb89d92009-11-30 13:18:29 +00001800 unlock_kernel();
Ingo Molnar70522e12006-03-23 03:00:31 -08001801 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 return -ENODEV;
1803 }
1804
1805 driver = get_tty_driver(device, &index);
1806 if (!driver) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001807 unlock_kernel();
Ingo Molnar70522e12006-03-23 03:00:31 -08001808 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 return -ENODEV;
1810 }
1811got_driver:
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001812 if (!tty) {
1813 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001814 tty = tty_driver_lookup_tty(driver, inode, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001815
Eric Paris808ffa32009-01-27 11:50:37 +00001816 if (IS_ERR(tty)) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001817 unlock_kernel();
Eric Paris808ffa32009-01-27 11:50:37 +00001818 mutex_unlock(&tty_mutex);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001819 return PTR_ERR(tty);
Eric Paris808ffa32009-01-27 11:50:37 +00001820 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001821 }
1822
1823 if (tty) {
1824 retval = tty_reopen(tty);
1825 if (retval)
1826 tty = ERR_PTR(retval);
1827 } else
1828 tty = tty_init_dev(driver, index, 0);
1829
Ingo Molnar70522e12006-03-23 03:00:31 -08001830 mutex_unlock(&tty_mutex);
Alan Cox7d7b93c2008-10-13 10:42:09 +01001831 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001832 if (IS_ERR(tty)) {
1833 unlock_kernel();
Alan Cox73ec06f2008-10-13 10:42:29 +01001834 return PTR_ERR(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001835 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836
1837 filp->private_data = tty;
1838 file_move(filp, &tty->tty_files);
1839 check_tty_count(tty, "tty_open");
1840 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1841 tty->driver->subtype == PTY_TYPE_MASTER)
1842 noctty = 1;
1843#ifdef TTY_DEBUG_HANGUP
1844 printk(KERN_DEBUG "opening %s...", tty->name);
1845#endif
1846 if (!retval) {
Alan Coxf34d7a52008-04-30 00:54:13 -07001847 if (tty->ops->open)
1848 retval = tty->ops->open(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 else
1850 retval = -ENODEV;
1851 }
1852 filp->f_flags = saved_flags;
1853
Alan Cox37bdfb02008-02-08 04:18:47 -08001854 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1855 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 retval = -EBUSY;
1857
1858 if (retval) {
1859#ifdef TTY_DEBUG_HANGUP
1860 printk(KERN_DEBUG "error %d in opening %s...", retval,
1861 tty->name);
1862#endif
Alan Coxeeb89d92009-11-30 13:18:29 +00001863 tty_release(inode, filp);
1864 if (retval != -ERESTARTSYS) {
1865 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 return retval;
Alan Coxeeb89d92009-11-30 13:18:29 +00001867 }
1868 if (signal_pending(current)) {
1869 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 return retval;
Alan Coxeeb89d92009-11-30 13:18:29 +00001871 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 schedule();
1873 /*
1874 * Need to reset f_op in case a hangup happened.
1875 */
1876 if (filp->f_op == &hung_up_tty_fops)
1877 filp->f_op = &tty_fops;
Alan Cox77945fe2010-05-04 20:42:36 +01001878 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 goto retry_open;
1880 }
Alan Coxeeb89d92009-11-30 13:18:29 +00001881 unlock_kernel();
1882
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001883
1884 mutex_lock(&tty_mutex);
Alan Coxeeb89d92009-11-30 13:18:29 +00001885 lock_kernel();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001886 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 if (!noctty &&
1888 current->signal->leader &&
1889 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001890 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07001891 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001892 spin_unlock_irq(&current->sighand->siglock);
Alan Coxeeb89d92009-11-30 13:18:29 +00001893 unlock_kernel();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001894 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 return 0;
1896}
1897
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001898
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
Alan Coxaf9b8972006-08-27 01:24:01 -07001900/**
1901 * tty_poll - check tty status
1902 * @filp: file being polled
1903 * @wait: poll wait structures to update
1904 *
1905 * Call the line discipline polling method to obtain the poll
1906 * status of the device.
1907 *
1908 * Locking: locks called line discipline but ldisc poll method
1909 * may be re-entered freely by other callers.
1910 */
1911
Alan Cox37bdfb02008-02-08 04:18:47 -08001912static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913{
Alan Cox37bdfb02008-02-08 04:18:47 -08001914 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 struct tty_ldisc *ld;
1916 int ret = 0;
1917
1918 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001919 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001921
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001923 if (ld->ops->poll)
1924 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 tty_ldisc_deref(ld);
1926 return ret;
1927}
1928
Alan Cox37bdfb02008-02-08 04:18:47 -08001929static int tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930{
Alan Cox37bdfb02008-02-08 04:18:47 -08001931 struct tty_struct *tty;
Alan Cox47f86832008-04-30 00:53:30 -07001932 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001933 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001935 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001937 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001938 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08001939
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 retval = fasync_helper(fd, filp, on, &tty->fasync);
1941 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001942 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943
1944 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001945 enum pid_type type;
1946 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 if (!waitqueue_active(&tty->read_wait))
1948 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07001949 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001950 if (tty->pgrp) {
1951 pid = tty->pgrp;
1952 type = PIDTYPE_PGID;
1953 } else {
1954 pid = task_pid(current);
1955 type = PIDTYPE_PID;
1956 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08001957 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08001958 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08001959 retval = __f_setown(filp, pid, type, 0);
1960 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001962 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 } else {
1964 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1965 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1966 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001967 retval = 0;
1968out:
1969 unlock_kernel();
1970 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971}
1972
Alan Coxaf9b8972006-08-27 01:24:01 -07001973/**
1974 * tiocsti - fake input character
1975 * @tty: tty to fake input into
1976 * @p: pointer to character
1977 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02001978 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07001979 * input management.
1980 *
1981 * FIXME: does not honour flow control ??
1982 *
1983 * Locking:
1984 * Called functions take tty_ldisc_lock
1985 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07001986 *
1987 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07001988 */
1989
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990static int tiocsti(struct tty_struct *tty, char __user *p)
1991{
1992 char ch, mbz = 0;
1993 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08001994
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1996 return -EPERM;
1997 if (get_user(ch, p))
1998 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00001999 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002001 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 tty_ldisc_deref(ld);
2003 return 0;
2004}
2005
Alan Coxaf9b8972006-08-27 01:24:01 -07002006/**
2007 * tiocgwinsz - implement window query ioctl
2008 * @tty; tty
2009 * @arg: user buffer for result
2010 *
Alan Cox808a0d32006-09-29 02:00:40 -07002011 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002012 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002013 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002014 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002015 */
2016
Alan Cox37bdfb02008-02-08 04:18:47 -08002017static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018{
Alan Cox808a0d32006-09-29 02:00:40 -07002019 int err;
2020
Arjan van de Ven5785c952006-09-29 02:00:43 -07002021 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002022 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002023 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002024
2025 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026}
2027
Alan Coxaf9b8972006-08-27 01:24:01 -07002028/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002029 * tty_do_resize - resize event
2030 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002031 * @rows: rows (character)
2032 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002033 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002034 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002035 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002036 */
2037
Alan Coxfc6f6232009-01-02 13:43:17 +00002038int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039{
Alan Coxfc6f6232009-01-02 13:43:17 +00002040 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002041 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042
Alan Coxfc6f6232009-01-02 13:43:17 +00002043 /* Lock the tty */
2044 mutex_lock(&tty->termios_mutex);
2045 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002046 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002047 /* Get the PID values and reference them so we can
2048 avoid holding the tty ctrl lock while sending signals */
2049 spin_lock_irqsave(&tty->ctrl_lock, flags);
2050 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002051 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2052
2053 if (pgrp)
2054 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002055 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002056
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002057 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002058done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002059 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 return 0;
2061}
2062
Alan Coxaf9b8972006-08-27 01:24:01 -07002063/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002064 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002065 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002066 * @arg: user buffer for result
2067 *
2068 * Copies the user idea of the window size to the kernel. Traditionally
2069 * this is just advisory information but for the Linux console it
2070 * actually has driver level meaning and triggers a VC resize.
2071 *
2072 * Locking:
2073 * Driver dependant. The default do_resize method takes the
2074 * tty termios mutex and ctrl_lock. The console takes its own lock
2075 * then calls into the default method.
2076 */
2077
Alan Coxfc6f6232009-01-02 13:43:17 +00002078static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002079{
2080 struct winsize tmp_ws;
2081 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2082 return -EFAULT;
2083
2084 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002085 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002086 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002087 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002088}
2089
2090/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002091 * tioccons - allow admin to move logical console
2092 * @file: the file to become console
2093 *
2094 * Allow the adminstrator to move the redirected console device
2095 *
2096 * Locking: uses redirect_lock to guard the redirect information
2097 */
2098
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099static int tioccons(struct file *file)
2100{
2101 if (!capable(CAP_SYS_ADMIN))
2102 return -EPERM;
2103 if (file->f_op->write == redirected_tty_write) {
2104 struct file *f;
2105 spin_lock(&redirect_lock);
2106 f = redirect;
2107 redirect = NULL;
2108 spin_unlock(&redirect_lock);
2109 if (f)
2110 fput(f);
2111 return 0;
2112 }
2113 spin_lock(&redirect_lock);
2114 if (redirect) {
2115 spin_unlock(&redirect_lock);
2116 return -EBUSY;
2117 }
2118 get_file(file);
2119 redirect = file;
2120 spin_unlock(&redirect_lock);
2121 return 0;
2122}
2123
Alan Coxaf9b8972006-08-27 01:24:01 -07002124/**
2125 * fionbio - non blocking ioctl
2126 * @file: file to set blocking value
2127 * @p: user parameter
2128 *
2129 * Historical tty interfaces had a blocking control ioctl before
2130 * the generic functionality existed. This piece of history is preserved
2131 * in the expected tty API of posix OS's.
2132 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002133 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002134 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135
2136static int fionbio(struct file *file, int __user *p)
2137{
2138 int nonblock;
2139
2140 if (get_user(nonblock, p))
2141 return -EFAULT;
2142
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002143 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 if (nonblock)
2145 file->f_flags |= O_NONBLOCK;
2146 else
2147 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002148 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 return 0;
2150}
2151
Alan Coxaf9b8972006-08-27 01:24:01 -07002152/**
2153 * tiocsctty - set controlling tty
2154 * @tty: tty structure
2155 * @arg: user argument
2156 *
2157 * This ioctl is used to manage job control. It permits a session
2158 * leader to set this tty as the controlling tty for the session.
2159 *
2160 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002161 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002162 * Takes tasklist_lock internally to walk sessions
2163 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002164 */
2165
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166static int tiocsctty(struct tty_struct *tty, int arg)
2167{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002168 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002169 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002170 return ret;
2171
2172 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 /*
2174 * The process must be a session leader and
2175 * not have a controlling tty already.
2176 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002177 if (!current->signal->leader || current->signal->tty) {
2178 ret = -EPERM;
2179 goto unlock;
2180 }
2181
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002182 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 /*
2184 * This tty is already the controlling
2185 * tty for another session group!
2186 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002187 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 /*
2189 * Steal it away
2190 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002192 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002194 } else {
2195 ret = -EPERM;
2196 goto unlock;
2197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002199 proc_set_tty(current, tty);
2200unlock:
Alan Cox28298232006-09-29 02:00:58 -07002201 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002202 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203}
2204
Alan Coxaf9b8972006-08-27 01:24:01 -07002205/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002206 * tty_get_pgrp - return a ref counted pgrp pid
2207 * @tty: tty to read
2208 *
2209 * Returns a refcounted instance of the pid struct for the process
2210 * group controlling the tty.
2211 */
2212
2213struct pid *tty_get_pgrp(struct tty_struct *tty)
2214{
2215 unsigned long flags;
2216 struct pid *pgrp;
2217
2218 spin_lock_irqsave(&tty->ctrl_lock, flags);
2219 pgrp = get_pid(tty->pgrp);
2220 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2221
2222 return pgrp;
2223}
2224EXPORT_SYMBOL_GPL(tty_get_pgrp);
2225
2226/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002227 * tiocgpgrp - get process group
2228 * @tty: tty passed by user
2229 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2230 * @p: returned pid
2231 *
2232 * Obtain the process group of the tty. If there is no process group
2233 * return an error.
2234 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002235 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002236 */
2237
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2239{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002240 struct pid *pid;
2241 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 /*
2243 * (tty == real_tty) is a cheap way of
2244 * testing if the tty is NOT a master pty.
2245 */
2246 if (tty == real_tty && current->signal->tty != real_tty)
2247 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002248 pid = tty_get_pgrp(real_tty);
2249 ret = put_user(pid_vnr(pid), p);
2250 put_pid(pid);
2251 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252}
2253
Alan Coxaf9b8972006-08-27 01:24:01 -07002254/**
2255 * tiocspgrp - attempt to set process group
2256 * @tty: tty passed by user
2257 * @real_tty: tty side device matching tty passed by user
2258 * @p: pid pointer
2259 *
2260 * Set the process group of the tty to the session passed. Only
2261 * permitted where the tty session is our session.
2262 *
Alan Cox47f86832008-04-30 00:53:30 -07002263 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002264 */
2265
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2267{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002268 struct pid *pgrp;
2269 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002271 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272
2273 if (retval == -EIO)
2274 return -ENOTTY;
2275 if (retval)
2276 return retval;
2277 if (!current->signal->tty ||
2278 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002279 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002281 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002283 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002285 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002286 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002287 retval = -ESRCH;
2288 if (!pgrp)
2289 goto out_unlock;
2290 retval = -EPERM;
2291 if (session_of_pgrp(pgrp) != task_session(current))
2292 goto out_unlock;
2293 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002294 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002295 put_pid(real_tty->pgrp);
2296 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002297 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002298out_unlock:
2299 rcu_read_unlock();
2300 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301}
2302
Alan Coxaf9b8972006-08-27 01:24:01 -07002303/**
2304 * tiocgsid - get session id
2305 * @tty: tty passed by user
2306 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2307 * @p: pointer to returned session id
2308 *
2309 * Obtain the session id of the tty. If there is no session
2310 * return an error.
2311 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002312 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002313 */
2314
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2316{
2317 /*
2318 * (tty == real_tty) is a cheap way of
2319 * testing if the tty is NOT a master pty.
2320 */
2321 if (tty == real_tty && current->signal->tty != real_tty)
2322 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002323 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002325 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326}
2327
Alan Coxaf9b8972006-08-27 01:24:01 -07002328/**
2329 * tiocsetd - set line discipline
2330 * @tty: tty device
2331 * @p: pointer to user data
2332 *
2333 * Set the line discipline according to user request.
2334 *
2335 * Locking: see tty_set_ldisc, this function is just a helper
2336 */
2337
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338static int tiocsetd(struct tty_struct *tty, int __user *p)
2339{
2340 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002341 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342
2343 if (get_user(ldisc, p))
2344 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002345
Alan Cox04f378b2008-04-30 00:53:29 -07002346 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002347
2348 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349}
2350
Alan Coxaf9b8972006-08-27 01:24:01 -07002351/**
2352 * send_break - performed time break
2353 * @tty: device to break on
2354 * @duration: timeout in mS
2355 *
2356 * Perform a timed break on hardware that lacks its own driver level
2357 * timed break functionality.
2358 *
2359 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002360 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002361 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002362 */
2363
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002364static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365{
Alan Cox9e989662008-07-22 11:18:03 +01002366 int retval;
2367
2368 if (tty->ops->break_ctl == NULL)
2369 return 0;
2370
2371 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2372 retval = tty->ops->break_ctl(tty, duration);
2373 else {
2374 /* Do the work ourselves */
2375 if (tty_write_lock(tty, 0) < 0)
2376 return -EINTR;
2377 retval = tty->ops->break_ctl(tty, -1);
2378 if (retval)
2379 goto out;
2380 if (!signal_pending(current))
2381 msleep_interruptible(duration);
2382 retval = tty->ops->break_ctl(tty, 0);
2383out:
2384 tty_write_unlock(tty);
2385 if (signal_pending(current))
2386 retval = -EINTR;
2387 }
2388 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389}
2390
Alan Coxaf9b8972006-08-27 01:24:01 -07002391/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002392 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002393 * @tty: tty device
2394 * @file: user file pointer
2395 * @p: pointer to result
2396 *
2397 * Obtain the modem status bits from the tty driver if the feature
2398 * is supported. Return -EINVAL if it is not available.
2399 *
2400 * Locking: none (up to the driver)
2401 */
2402
2403static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404{
2405 int retval = -EINVAL;
2406
Alan Coxf34d7a52008-04-30 00:54:13 -07002407 if (tty->ops->tiocmget) {
2408 retval = tty->ops->tiocmget(tty, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409
2410 if (retval >= 0)
2411 retval = put_user(retval, p);
2412 }
2413 return retval;
2414}
2415
Alan Coxaf9b8972006-08-27 01:24:01 -07002416/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002417 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002418 * @tty: tty device
2419 * @file: user file pointer
2420 * @cmd: command - clear bits, set bits or set all
2421 * @p: pointer to desired bits
2422 *
2423 * Set the modem status bits from the tty driver if the feature
2424 * is supported. Return -EINVAL if it is not available.
2425 *
2426 * Locking: none (up to the driver)
2427 */
2428
2429static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430 unsigned __user *p)
2431{
Alan Coxae677512008-07-16 21:56:54 +01002432 int retval;
2433 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434
Alan Coxae677512008-07-16 21:56:54 +01002435 if (tty->ops->tiocmset == NULL)
2436 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437
Alan Coxae677512008-07-16 21:56:54 +01002438 retval = get_user(val, p);
2439 if (retval)
2440 return retval;
2441 set = clear = 0;
2442 switch (cmd) {
2443 case TIOCMBIS:
2444 set = val;
2445 break;
2446 case TIOCMBIC:
2447 clear = val;
2448 break;
2449 case TIOCMSET:
2450 set = val;
2451 clear = ~val;
2452 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 }
Alan Coxae677512008-07-16 21:56:54 +01002454 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2455 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2456 return tty->ops->tiocmset(tty, file, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457}
2458
Alan Coxe8b70e72009-06-11 12:48:02 +01002459struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2460{
2461 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2462 tty->driver->subtype == PTY_TYPE_MASTER)
2463 tty = tty->link;
2464 return tty;
2465}
2466EXPORT_SYMBOL(tty_pair_get_tty);
2467
2468struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2469{
2470 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2471 tty->driver->subtype == PTY_TYPE_MASTER)
2472 return tty;
2473 return tty->link;
2474}
2475EXPORT_SYMBOL(tty_pair_get_pty);
2476
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477/*
2478 * Split this up, as gcc can choke on it otherwise..
2479 */
Alan Cox04f378b2008-04-30 00:53:29 -07002480long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481{
2482 struct tty_struct *tty, *real_tty;
2483 void __user *p = (void __user *)arg;
2484 int retval;
2485 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002486 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002487
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488 tty = (struct tty_struct *)file->private_data;
2489 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2490 return -EINVAL;
2491
Alan Coxe8b70e72009-06-11 12:48:02 +01002492 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493
2494 /*
2495 * Factor out some common prep work
2496 */
2497 switch (cmd) {
2498 case TIOCSETD:
2499 case TIOCSBRK:
2500 case TIOCCBRK:
2501 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002502 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 retval = tty_check_change(tty);
2504 if (retval)
2505 return retval;
2506 if (cmd != TIOCCBRK) {
2507 tty_wait_until_sent(tty, 0);
2508 if (signal_pending(current))
2509 return -EINTR;
2510 }
2511 break;
2512 }
2513
Alan Cox9e989662008-07-22 11:18:03 +01002514 /*
2515 * Now do the stuff.
2516 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002518 case TIOCSTI:
2519 return tiocsti(tty, p);
2520 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002521 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002522 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002523 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002524 case TIOCCONS:
2525 return real_tty != tty ? -EINVAL : tioccons(file);
2526 case FIONBIO:
2527 return fionbio(file, p);
2528 case TIOCEXCL:
2529 set_bit(TTY_EXCLUSIVE, &tty->flags);
2530 return 0;
2531 case TIOCNXCL:
2532 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2533 return 0;
2534 case TIOCNOTTY:
2535 if (current->signal->tty != tty)
2536 return -ENOTTY;
2537 no_tty();
2538 return 0;
2539 case TIOCSCTTY:
2540 return tiocsctty(tty, arg);
2541 case TIOCGPGRP:
2542 return tiocgpgrp(tty, real_tty, p);
2543 case TIOCSPGRP:
2544 return tiocspgrp(tty, real_tty, p);
2545 case TIOCGSID:
2546 return tiocgsid(tty, real_tty, p);
2547 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002548 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002549 case TIOCSETD:
2550 return tiocsetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002551 /*
2552 * Break handling
2553 */
2554 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002555 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002556 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002557 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002558 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002559 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002560 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002561 return 0;
2562 case TCSBRK: /* SVID version: non-zero arg --> no break */
2563 /* non-zero arg means wait for all output data
2564 * to be sent (performed above) but don't send break.
2565 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002567 if (!arg)
2568 return send_break(tty, 250);
2569 return 0;
2570 case TCSBRKP: /* support for POSIX tcsendbreak() */
2571 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572
Alan Cox37bdfb02008-02-08 04:18:47 -08002573 case TIOCMGET:
2574 return tty_tiocmget(tty, file, p);
2575 case TIOCMSET:
2576 case TIOCMBIC:
2577 case TIOCMBIS:
2578 return tty_tiocmset(tty, file, cmd, p);
2579 case TCFLSH:
2580 switch (arg) {
2581 case TCIFLUSH:
2582 case TCIOFLUSH:
2583 /* flush tty buffer and allow ldisc to process ioctl */
2584 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002585 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002586 }
2587 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002589 if (tty->ops->ioctl) {
2590 retval = (tty->ops->ioctl)(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 if (retval != -ENOIOCTLCMD)
2592 return retval;
2593 }
2594 ld = tty_ldisc_ref_wait(tty);
2595 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002596 if (ld->ops->ioctl) {
2597 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 if (retval == -ENOIOCTLCMD)
2599 retval = -EINVAL;
2600 }
2601 tty_ldisc_deref(ld);
2602 return retval;
2603}
2604
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002605#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002606static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002607 unsigned long arg)
2608{
2609 struct inode *inode = file->f_dentry->d_inode;
2610 struct tty_struct *tty = file->private_data;
2611 struct tty_ldisc *ld;
2612 int retval = -ENOIOCTLCMD;
2613
2614 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2615 return -EINVAL;
2616
Alan Coxf34d7a52008-04-30 00:54:13 -07002617 if (tty->ops->compat_ioctl) {
2618 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002619 if (retval != -ENOIOCTLCMD)
2620 return retval;
2621 }
2622
2623 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002624 if (ld->ops->compat_ioctl)
2625 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002626 tty_ldisc_deref(ld);
2627
2628 return retval;
2629}
2630#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631
2632/*
2633 * This implements the "Secure Attention Key" --- the idea is to
2634 * prevent trojan horses by killing all processes associated with this
2635 * tty when the user hits the "Secure Attention Key". Required for
2636 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002637 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 * This code could be nicer; ideally it should send a HUP, wait a few
2639 * seconds, then send a INT, and then a KILL signal. But you then
2640 * have to coordinate with the init process, since all processes associated
2641 * with the current tty must be dead before the new getty is allowed
2642 * to spawn.
2643 *
2644 * Now, if it would be correct ;-/ The current code has a nasty hole -
2645 * it doesn't catch files in flight. We may send the descriptor to ourselves
2646 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2647 *
2648 * Nasty bug: do_SAK is being called in interrupt context. This can
2649 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2650 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002651void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652{
2653#ifdef TTY_SOFT_SAK
2654 tty_hangup(tty);
2655#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002656 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002657 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 int i;
2659 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002660 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002661
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662 if (!tty)
2663 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002664 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002665
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002666 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667
Alan Coxf34d7a52008-04-30 00:54:13 -07002668 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002669
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002671 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002672 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002673 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002674 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002675 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002676 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002677 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002678 /* Now kill any processes that happen to have the
2679 * tty open.
2680 */
2681 do_each_thread(g, p) {
2682 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002684 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002685 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 send_sig(SIGKILL, p, 1);
2687 continue;
2688 }
2689 task_lock(p);
2690 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002691 /*
2692 * We don't take a ref to the file, so we must
2693 * hold ->file_lock instead.
2694 */
2695 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002696 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002697 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 filp = fcheck_files(p->files, i);
2699 if (!filp)
2700 continue;
2701 if (filp->f_op->read == tty_read &&
2702 filp->private_data == tty) {
2703 printk(KERN_NOTICE "SAK: killed process %d"
2704 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002705 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002706 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 break;
2708 }
2709 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002710 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 }
2712 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002713 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 read_unlock(&tasklist_lock);
2715#endif
2716}
2717
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002718static void do_SAK_work(struct work_struct *work)
2719{
2720 struct tty_struct *tty =
2721 container_of(work, struct tty_struct, SAK_work);
2722 __do_SAK(tty);
2723}
2724
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725/*
2726 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2727 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2728 * the values which we write to it will be identical to the values which it
2729 * already has. --akpm
2730 */
2731void do_SAK(struct tty_struct *tty)
2732{
2733 if (!tty)
2734 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735 schedule_work(&tty->SAK_work);
2736}
2737
2738EXPORT_SYMBOL(do_SAK);
2739
Alan Coxaf9b8972006-08-27 01:24:01 -07002740/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002741 * initialize_tty_struct
2742 * @tty: tty to initialize
2743 *
2744 * This subroutine initializes a tty structure that has been newly
2745 * allocated.
2746 *
2747 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002749
Alan Coxbf970ee2008-10-13 10:42:39 +01002750void initialize_tty_struct(struct tty_struct *tty,
2751 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752{
2753 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002754 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002756 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002757 tty->session = NULL;
2758 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002760 tty->buf.head = tty->buf.tail = NULL;
2761 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002762 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002763 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764 init_waitqueue_head(&tty->write_wait);
2765 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002766 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002767 mutex_init(&tty->atomic_read_lock);
2768 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002769 mutex_init(&tty->output_lock);
2770 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002772 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002774 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002775
2776 tty->driver = driver;
2777 tty->ops = driver->ops;
2778 tty->index = idx;
2779 tty_line_name(driver, idx, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780}
2781
Alan Coxf34d7a52008-04-30 00:54:13 -07002782/**
2783 * tty_put_char - write one character to a tty
2784 * @tty: tty
2785 * @ch: character
2786 *
2787 * Write one byte to the tty using the provided put_char method
2788 * if present. Returns the number of characters successfully output.
2789 *
2790 * Note: the specific put_char operation in the driver layer may go
2791 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002793
Alan Coxf34d7a52008-04-30 00:54:13 -07002794int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795{
Alan Coxf34d7a52008-04-30 00:54:13 -07002796 if (tty->ops->put_char)
2797 return tty->ops->put_char(tty, ch);
2798 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799}
Alan Coxf34d7a52008-04-30 00:54:13 -07002800EXPORT_SYMBOL_GPL(tty_put_char);
2801
Alan Coxd81ed102008-10-13 10:41:42 +01002802struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803
2804/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002805 * tty_register_device - register a tty device
2806 * @driver: the tty driver that describes the tty device
2807 * @index: the index in the tty driver for this tty device
2808 * @device: a struct device that is associated with this tty device.
2809 * This field is optional, if there is no known struct device
2810 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002812 * Returns a pointer to the struct device for this tty device
2813 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002814 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002815 * This call is required to be made to register an individual tty device
2816 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2817 * that bit is not set, this function should not be called by a tty
2818 * driver.
2819 *
2820 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002822
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002823struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2824 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825{
2826 char name[64];
2827 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2828
2829 if (index >= driver->num) {
2830 printk(KERN_ERR "Attempt to register invalid tty line number "
2831 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002832 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 }
2834
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 if (driver->type == TTY_DRIVER_TYPE_PTY)
2836 pty_line_name(driver, index, name);
2837 else
2838 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002839
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07002840 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002842EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843
2844/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002845 * tty_unregister_device - unregister a tty device
2846 * @driver: the tty driver that describes the tty device
2847 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002849 * If a tty device is registered with a call to tty_register_device() then
2850 * this function must be called when the tty device is gone.
2851 *
2852 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002854
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855void tty_unregister_device(struct tty_driver *driver, unsigned index)
2856{
Alan Cox37bdfb02008-02-08 04:18:47 -08002857 device_destroy(tty_class,
2858 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860EXPORT_SYMBOL(tty_unregister_device);
2861
2862struct tty_driver *alloc_tty_driver(int lines)
2863{
2864 struct tty_driver *driver;
2865
Jean Delvare506eb992007-07-15 23:40:14 -07002866 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01002868 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869 driver->magic = TTY_DRIVER_MAGIC;
2870 driver->num = lines;
2871 /* later we'll move allocation of tables here */
2872 }
2873 return driver;
2874}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002875EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876
Alan Cox7d7b93c2008-10-13 10:42:09 +01002877static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002879 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2880 int i;
2881 struct ktermios *tp;
2882 void *p;
2883
2884 if (driver->flags & TTY_DRIVER_INSTALLED) {
2885 /*
2886 * Free the termios and termios_locked structures because
2887 * we don't want to get memory leaks when modular tty
2888 * drivers are removed from the kernel.
2889 */
2890 for (i = 0; i < driver->num; i++) {
2891 tp = driver->termios[i];
2892 if (tp) {
2893 driver->termios[i] = NULL;
2894 kfree(tp);
2895 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01002896 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
2897 tty_unregister_device(driver, i);
2898 }
2899 p = driver->ttys;
2900 proc_tty_unregister_driver(driver);
2901 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002902 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01002903 kfree(p);
2904 cdev_del(&driver->cdev);
2905 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 kfree(driver);
2907}
2908
Alan Cox7d7b93c2008-10-13 10:42:09 +01002909void tty_driver_kref_put(struct tty_driver *driver)
2910{
2911 kref_put(&driver->kref, destruct_tty_driver);
2912}
2913EXPORT_SYMBOL(tty_driver_kref_put);
2914
Jeff Dikeb68e31d2006-10-02 02:17:18 -07002915void tty_set_operations(struct tty_driver *driver,
2916 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917{
Alan Coxf34d7a52008-04-30 00:54:13 -07002918 driver->ops = op;
2919};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920EXPORT_SYMBOL(tty_set_operations);
2921
Alan Cox7d7b93c2008-10-13 10:42:09 +01002922void put_tty_driver(struct tty_driver *d)
2923{
2924 tty_driver_kref_put(d);
2925}
2926EXPORT_SYMBOL(put_tty_driver);
2927
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928/*
2929 * Called by a tty driver to register itself.
2930 */
2931int tty_register_driver(struct tty_driver *driver)
2932{
2933 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08002934 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935 dev_t dev;
2936 void **p = NULL;
2937
Andy Whitcroft543691a2007-05-06 14:49:33 -07002938 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01002939 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 if (!p)
2941 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 }
2943
2944 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002945 error = alloc_chrdev_region(&dev, driver->minor_start,
2946 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 if (!error) {
2948 driver->major = MAJOR(dev);
2949 driver->minor_start = MINOR(dev);
2950 }
2951 } else {
2952 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01002953 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954 }
2955 if (error < 0) {
2956 kfree(p);
2957 return error;
2958 }
2959
2960 if (p) {
2961 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08002962 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963 } else {
2964 driver->ttys = NULL;
2965 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 }
2967
2968 cdev_init(&driver->cdev, &tty_fops);
2969 driver->cdev.owner = driver->owner;
2970 error = cdev_add(&driver->cdev, dev, driver->num);
2971 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 unregister_chrdev_region(dev, driver->num);
2973 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002974 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 kfree(p);
2976 return error;
2977 }
2978
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002979 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002981 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08002982
2983 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
2984 for (i = 0; i < driver->num; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 tty_register_device(driver, i, NULL);
2986 }
2987 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01002988 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 return 0;
2990}
2991
2992EXPORT_SYMBOL(tty_register_driver);
2993
2994/*
2995 * Called by a tty driver to unregister itself.
2996 */
2997int tty_unregister_driver(struct tty_driver *driver)
2998{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002999#if 0
3000 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 if (driver->refcount)
3002 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003003#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3005 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003006 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003008 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009 return 0;
3010}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003011
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012EXPORT_SYMBOL(tty_unregister_driver);
3013
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003014dev_t tty_devnum(struct tty_struct *tty)
3015{
3016 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3017}
3018EXPORT_SYMBOL(tty_devnum);
3019
3020void proc_clear_tty(struct task_struct *p)
3021{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003022 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003023 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003024 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003025 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003026 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003027 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003028 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003029}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003030
Alan Cox47f86832008-04-30 00:53:30 -07003031/* Called under the sighand lock */
3032
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003033static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003034{
3035 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003036 unsigned long flags;
3037 /* We should not have a session or pgrp to put here but.... */
3038 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003039 put_pid(tty->session);
3040 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003041 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003042 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3043 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003044 if (tsk->signal->tty) {
3045 printk(KERN_DEBUG "tty not NULL!!\n");
3046 tty_kref_put(tsk->signal->tty);
3047 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003048 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003049 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003050 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003051 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003052}
3053
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003054static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003055{
3056 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003057 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003058 spin_unlock_irq(&tsk->sighand->siglock);
3059}
3060
3061struct tty_struct *get_current_tty(void)
3062{
3063 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003064 unsigned long flags;
3065
3066 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003067 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003068 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003069 return tty;
3070}
Heiko Carstensa311f742006-12-13 00:33:41 -08003071EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072
Alan Coxd81ed102008-10-13 10:41:42 +01003073void tty_default_fops(struct file_operations *fops)
3074{
3075 *fops = tty_fops;
3076}
3077
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078/*
3079 * Initialize the console device. This is called *early*, so
3080 * we can't necessarily depend on lots of kernel help here.
3081 * Just do some early initializations, and do the complex setup
3082 * later.
3083 */
3084void __init console_init(void)
3085{
3086 initcall_t *call;
3087
3088 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003089 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090
3091 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003092 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093 * inform about problems etc..
3094 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 call = __con_initcall_start;
3096 while (call < __con_initcall_end) {
3097 (*call)();
3098 call++;
3099 }
3100}
3101
Kay Sieverse454cea2009-09-18 23:01:12 +02003102static char *tty_devnode(struct device *dev, mode_t *mode)
3103{
3104 if (!mode)
3105 return NULL;
3106 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3107 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3108 *mode = 0666;
3109 return NULL;
3110}
3111
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112static int __init tty_class_init(void)
3113{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003114 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 if (IS_ERR(tty_class))
3116 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003117 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 return 0;
3119}
3120
3121postcore_initcall(tty_class_init);
3122
3123/* 3/2004 jmc: why do these devices exist? */
3124
3125static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126
3127/*
3128 * Ok, now we can initialize the rest of the tty devices and can count
3129 * on memory allocations, interrupts etc..
3130 */
3131static int __init tty_init(void)
3132{
3133 cdev_init(&tty_cdev, &tty_fops);
3134 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3135 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3136 panic("Couldn't register /dev/tty driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003137 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003138 "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139
3140 cdev_init(&console_cdev, &console_fops);
3141 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3142 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3143 panic("Couldn't register /dev/console driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003144 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003145 "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003148 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149#endif
3150 return 0;
3151}
3152module_init(tty_init);