blob: d7d50b48287e8a7374e4d2e814527b4faa9dfaa9 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070093#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include <linux/wait.h>
95#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070096#include <linux/delay.h>
Alan Coxa352def2008-07-16 21:53:12 +010097#include <linux/seq_file.h>
Alan Coxd281da72010-09-16 18:21:24 +010098#include <linux/serial.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
Nick Pigginee2ffa02010-08-18 04:37:35 +1000139/* Spinlock to protect the tty->tty_files list */
140DEFINE_SPINLOCK(tty_files_lock);
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
143static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800144ssize_t redirected_tty_write(struct file *, const char __user *,
145 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146static unsigned int tty_poll(struct file *, poll_table *);
147static int tty_open(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700148long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700149#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800150static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700151 unsigned long arg);
152#else
153#define tty_compat_ioctl NULL
154#endif
Arnd Bergmannec79d602010-06-01 22:53:01 +0200155static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800156static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800157static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700158static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700159static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Alan Coxaf9b8972006-08-27 01:24:01 -0700161/**
162 * alloc_tty_struct - allocate a tty object
163 *
164 * Return a new empty tty structure. The data fields have not
165 * been initialized in any way but has been zeroed
166 *
167 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700168 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
Alan Coxbf970ee2008-10-13 10:42:39 +0100170struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
Alan Cox1266b1e2006-09-29 02:00:40 -0700172 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173}
174
Alan Coxaf9b8972006-08-27 01:24:01 -0700175/**
176 * free_tty_struct - free a disused tty
177 * @tty: tty struct to free
178 *
179 * Free the write buffers, tty queue and tty memory itself.
180 *
181 * Locking: none. Must be called after tty is definitely unused
182 */
183
Alan Coxbf970ee2008-10-13 10:42:39 +0100184void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185{
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +0400186 if (tty->dev)
187 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800189 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 kfree(tty);
191}
192
Nick Piggind996b622010-08-18 04:37:36 +1000193static inline struct tty_struct *file_tty(struct file *file)
194{
195 return ((struct tty_file_private *)file->private_data)->tty;
196}
197
198/* Associate a new file with the tty structure */
Pekka Enbergf573bd12010-08-24 07:48:34 +0300199int tty_add_file(struct tty_struct *tty, struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000200{
201 struct tty_file_private *priv;
202
Pekka Enbergf573bd12010-08-24 07:48:34 +0300203 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
204 if (!priv)
205 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000206
207 priv->tty = tty;
208 priv->file = file;
209 file->private_data = priv;
210
211 spin_lock(&tty_files_lock);
212 list_add(&priv->list, &tty->tty_files);
213 spin_unlock(&tty_files_lock);
Pekka Enbergf573bd12010-08-24 07:48:34 +0300214
215 return 0;
Nick Piggind996b622010-08-18 04:37:36 +1000216}
217
218/* Delete file from its tty */
219void tty_del_file(struct file *file)
220{
221 struct tty_file_private *priv = file->private_data;
222
223 spin_lock(&tty_files_lock);
224 list_del(&priv->list);
225 spin_unlock(&tty_files_lock);
226 file->private_data = NULL;
227 kfree(priv);
228}
229
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
232
Alan Coxaf9b8972006-08-27 01:24:01 -0700233/**
234 * tty_name - return tty naming
235 * @tty: tty structure
236 * @buf: buffer for output
237 *
238 * Convert a tty structure into a name. The name reflects the kernel
239 * naming policy and if udev is in use may not reflect user space
240 *
241 * Locking: none
242 */
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244char *tty_name(struct tty_struct *tty, char *buf)
245{
246 if (!tty) /* Hmm. NULL pointer. That's fun. */
247 strcpy(buf, "NULL tty");
248 else
249 strcpy(buf, tty->name);
250 return buf;
251}
252
253EXPORT_SYMBOL(tty_name);
254
Andrew Mortond769a662005-05-05 16:15:50 -0700255int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 const char *routine)
257{
258#ifdef TTY_PARANOIA_CHECK
259 if (!tty) {
260 printk(KERN_WARNING
261 "null TTY for (%d:%d) in %s\n",
262 imajor(inode), iminor(inode), routine);
263 return 1;
264 }
265 if (tty->magic != TTY_MAGIC) {
266 printk(KERN_WARNING
267 "bad magic number for tty struct (%d:%d) in %s\n",
268 imajor(inode), iminor(inode), routine);
269 return 1;
270 }
271#endif
272 return 0;
273}
274
275static int check_tty_count(struct tty_struct *tty, const char *routine)
276{
277#ifdef CHECK_TTY_COUNT
278 struct list_head *p;
279 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800280
Nick Pigginee2ffa02010-08-18 04:37:35 +1000281 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 list_for_each(p, &tty->tty_files) {
283 count++;
284 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000285 spin_unlock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
287 tty->driver->subtype == PTY_TYPE_SLAVE &&
288 tty->link && tty->link->count)
289 count++;
290 if (tty->count != count) {
291 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
292 "!= #fd's(%d) in %s\n",
293 tty->name, tty->count, count, routine);
294 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800295 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296#endif
297 return 0;
298}
299
Alan Coxaf9b8972006-08-27 01:24:01 -0700300/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700301 * get_tty_driver - find device of a tty
302 * @dev_t: device identifier
303 * @index: returns the index of the tty
304 *
305 * This routine returns a tty driver structure, given a device number
306 * and also passes back the index number.
307 *
308 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311static struct tty_driver *get_tty_driver(dev_t device, int *index)
312{
313 struct tty_driver *p;
314
315 list_for_each_entry(p, &tty_drivers, tty_drivers) {
316 dev_t base = MKDEV(p->major, p->minor_start);
317 if (device < base || device >= base + p->num)
318 continue;
319 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100320 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 }
322 return NULL;
323}
324
Jason Wesself2d937f2008-04-17 20:05:37 +0200325#ifdef CONFIG_CONSOLE_POLL
326
327/**
328 * tty_find_polling_driver - find device of a polled tty
329 * @name: name string to match
330 * @line: pointer to resulting tty line nr
331 *
332 * This routine returns a tty driver structure, given a name
333 * and the condition that the tty driver is capable of polled
334 * operation.
335 */
336struct tty_driver *tty_find_polling_driver(char *name, int *line)
337{
338 struct tty_driver *p, *res = NULL;
339 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500340 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100341 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200342
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500343 for (str = name; *str; str++)
344 if ((*str >= '0' && *str <= '9') || *str == ',')
345 break;
346 if (!*str)
347 return NULL;
348
349 len = str - name;
350 tty_line = simple_strtoul(str, &str, 10);
351
Jason Wesself2d937f2008-04-17 20:05:37 +0200352 mutex_lock(&tty_mutex);
353 /* Search through the tty devices to look for a match */
354 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500355 if (strncmp(name, p->name, len) != 0)
356 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100357 stp = str;
358 if (*stp == ',')
359 stp++;
360 if (*stp == '\0')
361 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200362
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200363 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100364 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100365 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200366 *line = tty_line;
367 break;
368 }
369 }
370 mutex_unlock(&tty_mutex);
371
372 return res;
373}
374EXPORT_SYMBOL_GPL(tty_find_polling_driver);
375#endif
376
Alan Coxaf9b8972006-08-27 01:24:01 -0700377/**
378 * tty_check_change - check for POSIX terminal changes
379 * @tty: tty to check
380 *
381 * If we try to write to, or set the state of, a terminal and we're
382 * not in the foreground, send a SIGTTOU. If the signal is blocked or
383 * ignored, go ahead and perform the operation. (POSIX 7.2)
384 *
Alan Cox978e5952008-04-30 00:53:59 -0700385 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700387
Alan Cox37bdfb02008-02-08 04:18:47 -0800388int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
Alan Cox47f86832008-04-30 00:53:30 -0700390 unsigned long flags;
391 int ret = 0;
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if (current->signal->tty != tty)
394 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700395
396 spin_lock_irqsave(&tty->ctrl_lock, flags);
397
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800398 if (!tty->pgrp) {
399 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700400 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800402 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700403 goto out_unlock;
404 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700406 goto out;
407 if (is_current_pgrp_orphaned()) {
408 ret = -EIO;
409 goto out;
410 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700411 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
412 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700413 ret = -ERESTARTSYS;
414out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700415 return ret;
416out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700417 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
418 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420
421EXPORT_SYMBOL(tty_check_change);
422
Alan Cox37bdfb02008-02-08 04:18:47 -0800423static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 size_t count, loff_t *ppos)
425{
426 return 0;
427}
428
Alan Cox37bdfb02008-02-08 04:18:47 -0800429static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 size_t count, loff_t *ppos)
431{
432 return -EIO;
433}
434
435/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800436static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437{
438 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
439}
440
Alan Cox04f378b2008-04-30 00:53:29 -0700441static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
442 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700443{
444 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
445}
446
Alan Cox37bdfb02008-02-08 04:18:47 -0800447static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700448 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
450 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
451}
452
Arjan van de Ven62322d22006-07-03 00:24:21 -0700453static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 .llseek = no_llseek,
455 .read = tty_read,
456 .write = tty_write,
457 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700458 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700459 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 .open = tty_open,
461 .release = tty_release,
462 .fasync = tty_fasync,
463};
464
Arjan van de Ven62322d22006-07-03 00:24:21 -0700465static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 .llseek = no_llseek,
467 .read = tty_read,
468 .write = redirected_tty_write,
469 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700470 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700471 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 .open = tty_open,
473 .release = tty_release,
474 .fasync = tty_fasync,
475};
476
Arjan van de Ven62322d22006-07-03 00:24:21 -0700477static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 .llseek = no_llseek,
479 .read = hung_up_tty_read,
480 .write = hung_up_tty_write,
481 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700482 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700483 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 .release = tty_release,
485};
486
487static DEFINE_SPINLOCK(redirect_lock);
488static struct file *redirect;
489
490/**
491 * tty_wakeup - request more data
492 * @tty: terminal
493 *
494 * Internal and external helper for wakeups of tty. This function
495 * informs the line discipline if present that the driver is ready
496 * to receive more output data.
497 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499void tty_wakeup(struct tty_struct *tty)
500{
501 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
504 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800505 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100506 if (ld->ops->write_wakeup)
507 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 tty_ldisc_deref(ld);
509 }
510 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700511 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512}
513
514EXPORT_SYMBOL_GPL(tty_wakeup);
515
516/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200517 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000518 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700519 *
Alan Cox1bad8792008-07-22 23:38:04 +0100520 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700521 * synchronous but doesn't hold any locks, so we need to make sure we
522 * have the appropriate locks for what we're doing.
523 *
524 * The hangup event clears any pending redirections onto the hung up
525 * device. It ensures future writes will error and it does the needed
526 * line discipline hangup and signal delivery. The tty object itself
527 * remains intact.
528 *
529 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200530 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800531 * redirect lock for undoing redirection
532 * file list lock for manipulating list of ttys
533 * tty_ldisc_lock from called functions
534 * termios_mutex resetting termios data
535 * tasklist_lock to walk task list for hangup event
536 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200538void __tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539{
Alan Cox37bdfb02008-02-08 04:18:47 -0800540 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 struct file *filp, *f = NULL;
542 struct task_struct *p;
Nick Piggind996b622010-08-18 04:37:36 +1000543 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700545 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100546 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
548 if (!tty)
549 return;
550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000553 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 f = redirect;
555 redirect = NULL;
556 }
557 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800558
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200559 tty_lock();
560
Jiri Slabyacfa7472010-11-29 10:16:54 +0100561 /* some functions below drop BTM, so we need this bit */
562 set_bit(TTY_HUPPING, &tty->flags);
563
Arnd Bergmannec79d602010-06-01 22:53:01 +0200564 /* inuse_filps is protected by the single tty lock,
565 this really needs to change if we want to flush the
566 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200567 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000568
Nick Pigginee2ffa02010-08-18 04:37:35 +1000569 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000571 list_for_each_entry(priv, &tty->tty_files, list) {
572 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 if (filp->f_op->write == redirected_tty_write)
574 cons_filp = filp;
575 if (filp->f_op->write != tty_write)
576 continue;
577 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200578 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 filp->f_op = &hung_up_tty_fops;
580 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000581 spin_unlock(&tty_files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800582
Jiri Slabyacfa7472010-11-29 10:16:54 +0100583 /*
584 * it drops BTM and thus races with reopen
585 * we protect the race by TTY_HUPPING
586 */
Alan Coxc65c9bc2009-06-11 12:50:12 +0100587 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800588
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800590 if (tty->session) {
591 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800592 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100593 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100595 /* We defer the dereferences outside fo
596 the tasklist lock */
597 refs++;
598 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800599 if (!p->signal->leader) {
600 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800602 }
603 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
604 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800605 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700606 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800607 if (tty->pgrp)
608 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700609 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800610 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800611 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 }
613 read_unlock(&tasklist_lock);
614
Alan Cox47f86832008-04-30 00:53:30 -0700615 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100616 clear_bit(TTY_THROTTLED, &tty->flags);
617 clear_bit(TTY_PUSH, &tty->flags);
618 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600619 put_pid(tty->session);
620 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800621 tty->session = NULL;
622 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 tty->ctrl_status = 0;
Alan Cox47f86832008-04-30 00:53:30 -0700624 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
625
Alan Cox9c9f4de2008-10-13 10:37:26 +0100626 /* Account for the p->signal references we killed */
627 while (refs--)
628 tty_kref_put(tty);
629
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800631 * If one of the devices matches a console pointer, we
632 * cannot just call hangup() because that will cause
633 * tty->count and state->count to go out of sync.
634 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 */
636 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700637 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700639 tty->ops->close(tty, cons_filp);
640 } else if (tty->ops->hangup)
641 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800642 /*
643 * We don't want to have driver/ldisc interactions beyond
644 * the ones we did here. The driver layer expects no
645 * calls after ->hangup() from the ldisc side. However we
646 * can't yet guarantee all that.
647 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 set_bit(TTY_HUPPED, &tty->flags);
Jiri Slabyacfa7472010-11-29 10:16:54 +0100649 clear_bit(TTY_HUPPING, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100650 tty_ldisc_enable(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200651
652 tty_unlock();
653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 if (f)
655 fput(f);
656}
657
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200658static void do_tty_hangup(struct work_struct *work)
659{
660 struct tty_struct *tty =
661 container_of(work, struct tty_struct, hangup_work);
662
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200663 __tty_hangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200664}
665
Alan Coxaf9b8972006-08-27 01:24:01 -0700666/**
667 * tty_hangup - trigger a hangup event
668 * @tty: tty to hangup
669 *
670 * A carrier loss (virtual or otherwise) has occurred on this like
671 * schedule a hangup sequence to run after this event.
672 */
673
Alan Cox37bdfb02008-02-08 04:18:47 -0800674void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675{
676#ifdef TTY_DEBUG_HANGUP
677 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
679#endif
680 schedule_work(&tty->hangup_work);
681}
682
683EXPORT_SYMBOL(tty_hangup);
684
Alan Coxaf9b8972006-08-27 01:24:01 -0700685/**
686 * tty_vhangup - process vhangup
687 * @tty: tty to hangup
688 *
689 * The user has asked via system call for the terminal to be hung up.
690 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200691 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700692 */
693
Alan Cox37bdfb02008-02-08 04:18:47 -0800694void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695{
696#ifdef TTY_DEBUG_HANGUP
697 char buf[64];
698
699 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
700#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200701 __tty_hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
Alan Cox37bdfb02008-02-08 04:18:47 -0800703
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704EXPORT_SYMBOL(tty_vhangup);
705
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200706
Alan Coxaf9b8972006-08-27 01:24:01 -0700707/**
Alan Cox2cb59982008-10-13 10:40:30 +0100708 * tty_vhangup_self - process vhangup for own ctty
709 *
710 * Perform a vhangup on the current controlling tty
711 */
712
713void tty_vhangup_self(void)
714{
715 struct tty_struct *tty;
716
Alan Cox2cb59982008-10-13 10:40:30 +0100717 tty = get_current_tty();
718 if (tty) {
719 tty_vhangup(tty);
720 tty_kref_put(tty);
721 }
Alan Cox2cb59982008-10-13 10:40:30 +0100722}
723
724/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700725 * tty_hung_up_p - was tty hung up
726 * @filp: file pointer of tty
727 *
728 * Return true if the tty has been subject to a vhangup or a carrier
729 * loss
730 */
731
Alan Cox37bdfb02008-02-08 04:18:47 -0800732int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733{
734 return (filp->f_op == &hung_up_tty_fops);
735}
736
737EXPORT_SYMBOL(tty_hung_up_p);
738
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800739static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800740{
741 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800742 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800743 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800744 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800745}
746
Alan Coxaf9b8972006-08-27 01:24:01 -0700747/**
748 * disassociate_ctty - disconnect controlling tty
749 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700751 * This function is typically called only by the session leader, when
752 * it wants to disassociate itself from its controlling tty.
753 *
754 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
756 * (2) Clears the tty from being controlling the session
757 * (3) Clears the controlling tty for all processes in the
758 * session group.
759 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700760 * The argument on_exit is set to 1 if called when a process is
761 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
762 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800763 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200764 * BTM is taken for hysterical raisins, and held when
765 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800766 * tty_mutex is taken to protect tty
767 * ->siglock is taken to protect ->signal/->sighand
768 * tasklist_lock is taken to walk process list for sessions
769 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772void disassociate_ctty(int on_exit)
773{
774 struct tty_struct *tty;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800775 struct pid *tty_pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Alan Cox5ec93d12009-11-30 13:18:45 +0000777 if (!current->signal->leader)
778 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800780 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (tty) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800782 tty_pgrp = get_pid(tty->pgrp);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200783 if (on_exit) {
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200784 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200785 tty_vhangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200786 }
Alan Cox452a00d2008-10-13 10:39:13 +0100787 tty_kref_put(tty);
Eric W. Biederman680a9672007-02-12 00:52:52 -0800788 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800789 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800790 spin_lock_irq(&current->sighand->siglock);
791 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800792 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800793 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800794 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800795 kill_pgrp(old_pgrp, SIGHUP, on_exit);
796 kill_pgrp(old_pgrp, SIGCONT, on_exit);
797 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 return;
800 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800801 if (tty_pgrp) {
802 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 if (!on_exit)
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800804 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
805 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 }
807
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800808 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700809 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800810 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800811 spin_unlock_irq(&current->sighand->siglock);
812
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800813 tty = get_current_tty();
814 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700815 unsigned long flags;
816 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800817 put_pid(tty->session);
818 put_pid(tty->pgrp);
819 tty->session = NULL;
820 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700821 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100822 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800823 } else {
824#ifdef TTY_DEBUG_HANGUP
825 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
826 " = NULL", tty);
827#endif
828 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 /* Now clear signal->tty under the lock */
831 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800832 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834}
835
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700836/**
837 *
838 * no_tty - Ensure the current process does not have a controlling tty
839 */
840void no_tty(void)
841{
842 struct task_struct *tsk = current;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200843 tty_lock();
Alan Cox5ec93d12009-11-30 13:18:45 +0000844 disassociate_ctty(0);
Arnd Bergmannec79d602010-06-01 22:53:01 +0200845 tty_unlock();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700846 proc_clear_tty(tsk);
847}
848
Alan Coxaf9b8972006-08-27 01:24:01 -0700849
850/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200851 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700852 * @tty: tty to stop
853 *
854 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200855 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700856 * on an already stopped device and will not re-call the driver
857 * method.
858 *
859 * This functionality is used by both the line disciplines for
860 * halting incoming flow and by the driver. It may therefore be
861 * called from any context, may be under the tty atomic_write_lock
862 * but not always.
863 *
864 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700865 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700866 */
867
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868void stop_tty(struct tty_struct *tty)
869{
Alan Cox04f378b2008-04-30 00:53:29 -0700870 unsigned long flags;
871 spin_lock_irqsave(&tty->ctrl_lock, flags);
872 if (tty->stopped) {
873 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700875 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 tty->stopped = 1;
877 if (tty->link && tty->link->packet) {
878 tty->ctrl_status &= ~TIOCPKT_START;
879 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700880 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 }
Alan Cox04f378b2008-04-30 00:53:29 -0700882 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700883 if (tty->ops->stop)
884 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885}
886
887EXPORT_SYMBOL(stop_tty);
888
Alan Coxaf9b8972006-08-27 01:24:01 -0700889/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200890 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700891 * @tty: tty to start
892 *
893 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200894 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700895 * is the tty was previous stopped and is being started then the
896 * driver start method is invoked and the line discipline woken.
897 *
898 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700899 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700900 */
901
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902void start_tty(struct tty_struct *tty)
903{
Alan Cox04f378b2008-04-30 00:53:29 -0700904 unsigned long flags;
905 spin_lock_irqsave(&tty->ctrl_lock, flags);
906 if (!tty->stopped || tty->flow_stopped) {
907 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700909 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 tty->stopped = 0;
911 if (tty->link && tty->link->packet) {
912 tty->ctrl_status &= ~TIOCPKT_STOP;
913 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700914 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 }
Alan Cox04f378b2008-04-30 00:53:29 -0700916 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700917 if (tty->ops->start)
918 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 /* If we have a running line discipline it may need kicking */
920 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921}
922
923EXPORT_SYMBOL(start_tty);
924
Alan Coxaf9b8972006-08-27 01:24:01 -0700925/**
926 * tty_read - read method for tty device files
927 * @file: pointer to tty file
928 * @buf: user buffer
929 * @count: size of user buffer
930 * @ppos: unused
931 *
932 * Perform the read system call function on this terminal device. Checks
933 * for hung up devices before calling the line discipline method.
934 *
935 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700936 * Locks the line discipline internally while needed. Multiple
937 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700938 */
939
Alan Cox37bdfb02008-02-08 04:18:47 -0800940static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 loff_t *ppos)
942{
943 int i;
Nick Piggind996b622010-08-18 04:37:36 +1000944 struct inode *inode = file->f_path.dentry->d_inode;
945 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 struct tty_ldisc *ld;
947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 if (tty_paranoia_check(tty, inode, "tty_read"))
949 return -EIO;
950 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
951 return -EIO;
952
953 /* We want to wait for the line discipline to sort out in this
954 situation */
955 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100956 if (ld->ops->read)
957 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 else
959 i = -EIO;
960 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 if (i > 0)
962 inode->i_atime = current_fs_time(inode->i_sb);
963 return i;
964}
965
Alan Cox9c1729d2007-07-15 23:39:43 -0700966void tty_write_unlock(struct tty_struct *tty)
967{
968 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700969 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700970}
971
972int tty_write_lock(struct tty_struct *tty, int ndelay)
973{
974 if (!mutex_trylock(&tty->atomic_write_lock)) {
975 if (ndelay)
976 return -EAGAIN;
977 if (mutex_lock_interruptible(&tty->atomic_write_lock))
978 return -ERESTARTSYS;
979 }
980 return 0;
981}
982
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983/*
984 * Split writes up in sane blocksizes to avoid
985 * denial-of-service type attacks
986 */
987static inline ssize_t do_tty_write(
988 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
989 struct tty_struct *tty,
990 struct file *file,
991 const char __user *buf,
992 size_t count)
993{
Alan Cox9c1729d2007-07-15 23:39:43 -0700994 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -0800996
Alan Cox9c1729d2007-07-15 23:39:43 -0700997 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
998 if (ret < 0)
999 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 /*
1002 * We chunk up writes into a temporary buffer. This
1003 * simplifies low-level drivers immensely, since they
1004 * don't have locking issues and user mode accesses.
1005 *
1006 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1007 * big chunk-size..
1008 *
1009 * The default chunk-size is 2kB, because the NTTY
1010 * layer has problems with bigger chunks. It will
1011 * claim to be able to handle more characters than
1012 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001013 *
1014 * FIXME: This can probably go away now except that 64K chunks
1015 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 */
1017 chunk = 2048;
1018 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1019 chunk = 65536;
1020 if (count < chunk)
1021 chunk = count;
1022
Ingo Molnar70522e12006-03-23 03:00:31 -08001023 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001025 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
1027 if (chunk < 1024)
1028 chunk = 1024;
1029
Jason Wessel402fda92008-10-13 10:45:36 +01001030 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1031 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001032 ret = -ENOMEM;
1033 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 }
1035 kfree(tty->write_buf);
1036 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001037 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 }
1039
1040 /* Do the write .. */
1041 for (;;) {
1042 size_t size = count;
1043 if (size > chunk)
1044 size = chunk;
1045 ret = -EFAULT;
1046 if (copy_from_user(tty->write_buf, buf, size))
1047 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 if (ret <= 0)
1050 break;
1051 written += ret;
1052 buf += ret;
1053 count -= ret;
1054 if (!count)
1055 break;
1056 ret = -ERESTARTSYS;
1057 if (signal_pending(current))
1058 break;
1059 cond_resched();
1060 }
1061 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001062 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 inode->i_mtime = current_fs_time(inode->i_sb);
1064 ret = written;
1065 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001066out:
1067 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return ret;
1069}
1070
Alan Cox95f9bfc2008-10-13 10:39:23 +01001071/**
1072 * tty_write_message - write a message to a certain tty, not just the console.
1073 * @tty: the destination tty_struct
1074 * @msg: the message to write
1075 *
1076 * This is used for messages that need to be redirected to a specific tty.
1077 * We don't put it into the syslog queue right now maybe in the future if
1078 * really needed.
1079 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001080 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001081 */
1082
1083void tty_write_message(struct tty_struct *tty, char *msg)
1084{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001085 if (tty) {
1086 mutex_lock(&tty->atomic_write_lock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001087 tty_lock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001088 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001089 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001090 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001091 } else
Arnd Bergmannec79d602010-06-01 22:53:01 +02001092 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001093 tty_write_unlock(tty);
1094 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001095 return;
1096}
1097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
Alan Coxaf9b8972006-08-27 01:24:01 -07001099/**
1100 * tty_write - write method for tty device file
1101 * @file: tty file pointer
1102 * @buf: user data to write
1103 * @count: bytes to write
1104 * @ppos: unused
1105 *
1106 * Write data to a tty device via the line discipline.
1107 *
1108 * Locking:
1109 * Locks the line discipline as required
1110 * Writes to the tty driver are serialized by the atomic_write_lock
1111 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001112 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001113 */
1114
Alan Cox37bdfb02008-02-08 04:18:47 -08001115static ssize_t tty_write(struct file *file, const char __user *buf,
1116 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117{
Josef Sipeka7113a92006-12-08 02:36:55 -08001118 struct inode *inode = file->f_path.dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10001119 struct tty_struct *tty = file_tty(file);
1120 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001122
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 if (tty_paranoia_check(tty, inode, "tty_write"))
1124 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001125 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001126 (test_bit(TTY_IO_ERROR, &tty->flags)))
1127 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001128 /* Short term debug to catch buggy drivers */
1129 if (tty->ops->write_room == NULL)
1130 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1131 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001132 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001133 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 ret = -EIO;
1135 else
Alan Coxa352def2008-07-16 21:53:12 +01001136 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 tty_ldisc_deref(ld);
1138 return ret;
1139}
1140
Alan Cox37bdfb02008-02-08 04:18:47 -08001141ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1142 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143{
1144 struct file *p = NULL;
1145
1146 spin_lock(&redirect_lock);
1147 if (redirect) {
1148 get_file(redirect);
1149 p = redirect;
1150 }
1151 spin_unlock(&redirect_lock);
1152
1153 if (p) {
1154 ssize_t res;
1155 res = vfs_write(p, buf, count, &p->f_pos);
1156 fput(p);
1157 return res;
1158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 return tty_write(file, buf, count, ppos);
1160}
1161
1162static char ptychar[] = "pqrstuvwxyzabcde";
1163
Alan Coxaf9b8972006-08-27 01:24:01 -07001164/**
1165 * pty_line_name - generate name for a pty
1166 * @driver: the tty driver in use
1167 * @index: the minor number
1168 * @p: output buffer of at least 6 bytes
1169 *
1170 * Generate a name from a driver reference and write it to the output
1171 * buffer.
1172 *
1173 * Locking: None
1174 */
1175static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176{
1177 int i = index + driver->name_base;
1178 /* ->name is initialized to "ttyp", but "tty" is expected */
1179 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001180 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1181 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182}
1183
Alan Coxaf9b8972006-08-27 01:24:01 -07001184/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001185 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001186 * @driver: the tty driver in use
1187 * @index: the minor number
1188 * @p: output buffer of at least 7 bytes
1189 *
1190 * Generate a name from a driver reference and write it to the output
1191 * buffer.
1192 *
1193 * Locking: None
1194 */
1195static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196{
1197 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1198}
1199
Alan Cox99f1fe12008-10-13 10:42:00 +01001200/**
1201 * tty_driver_lookup_tty() - find an existing tty, if any
1202 * @driver: the driver for the tty
1203 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001204 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001205 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001206 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001207 * Locking: tty_mutex must be held. If tty is found, the mutex must
1208 * be held until the 'fast-open' is also done. Will change once we
1209 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001210 */
Jason Wessela47d5452009-01-02 13:43:04 +00001211static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001212 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001213{
1214 struct tty_struct *tty;
1215
Alan Cox99f1fe12008-10-13 10:42:00 +01001216 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001217 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001218
Alan Cox8b0a88d2008-10-13 10:42:19 +01001219 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001220 return tty;
1221}
1222
Alan Cox99f1fe12008-10-13 10:42:00 +01001223/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001224 * tty_init_termios - helper for termios setup
1225 * @tty: the tty to set up
1226 *
1227 * Initialise the termios structures for this tty. Thus runs under
1228 * the tty_mutex currently so we can be relaxed about ordering.
1229 */
1230
1231int tty_init_termios(struct tty_struct *tty)
1232{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001233 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001234 int idx = tty->index;
1235
1236 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001237 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001238 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1239 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001240 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001241 memcpy(tp, &tty->driver->init_termios,
1242 sizeof(struct ktermios));
1243 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001244 }
1245 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001246 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001247
1248 /* Compatibility until drivers always set this */
1249 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1250 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1251 return 0;
1252}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001253EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001254
1255/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001256 * tty_driver_install_tty() - install a tty entry in the driver
1257 * @driver: the driver for the tty
1258 * @tty: the tty
1259 *
1260 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001261 * will be set by the time this is called. This method is responsible
1262 * for ensuring any need additional structures are allocated and
1263 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001264 *
1265 * Locking: tty_mutex for now
1266 */
1267static int tty_driver_install_tty(struct tty_driver *driver,
1268 struct tty_struct *tty)
1269{
Alan Coxbf970ee2008-10-13 10:42:39 +01001270 int idx = tty->index;
Alan Coxeeb89d92009-11-30 13:18:29 +00001271 int ret;
Alan Coxbf970ee2008-10-13 10:42:39 +01001272
Alan Coxeeb89d92009-11-30 13:18:29 +00001273 if (driver->ops->install) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001274 ret = driver->ops->install(driver, tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001275 return ret;
1276 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001277
1278 if (tty_init_termios(tty) == 0) {
1279 tty_driver_kref_get(driver);
1280 tty->count++;
1281 driver->ttys[idx] = tty;
1282 return 0;
1283 }
1284 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001285}
1286
1287/**
1288 * tty_driver_remove_tty() - remove a tty from the driver tables
1289 * @driver: the driver for the tty
1290 * @idx: the minor number
1291 *
1292 * Remvoe a tty object from the driver tables. The tty->index field
1293 * will be set by the time this is called.
1294 *
1295 * Locking: tty_mutex for now
1296 */
1297static void tty_driver_remove_tty(struct tty_driver *driver,
1298 struct tty_struct *tty)
1299{
1300 if (driver->ops->remove)
1301 driver->ops->remove(driver, tty);
1302 else
1303 driver->ttys[tty->index] = NULL;
1304}
1305
1306/*
1307 * tty_reopen() - fast re-open of an open tty
1308 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001309 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001310 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001311 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001312 * Locking: tty_mutex must be held from the time the tty was found
1313 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001314 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001315static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001316{
1317 struct tty_driver *driver = tty->driver;
1318
Jiri Slabye2efafb2010-11-29 10:16:53 +01001319 if (test_bit(TTY_CLOSING, &tty->flags) ||
Jiri Slabyacfa7472010-11-29 10:16:54 +01001320 test_bit(TTY_HUPPING, &tty->flags) ||
Jiri Slabye2efafb2010-11-29 10:16:53 +01001321 test_bit(TTY_LDISC_CHANGING, &tty->flags))
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001322 return -EIO;
1323
1324 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1325 driver->subtype == PTY_TYPE_MASTER) {
1326 /*
1327 * special case for PTY masters: only one open permitted,
1328 * and the slave side open count is incremented as well.
1329 */
1330 if (tty->count)
1331 return -EIO;
1332
1333 tty->link->count++;
1334 }
1335 tty->count++;
1336 tty->driver = driver; /* N.B. why do this every time?? */
1337
Alan Cox1aa4bed2009-06-16 17:01:33 +01001338 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001339 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001340 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001341
1342 return 0;
1343}
1344
Alan Coxaf9b8972006-08-27 01:24:01 -07001345/**
Alan Coxd81ed102008-10-13 10:41:42 +01001346 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001347 * @driver: tty driver we are opening a device on
1348 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001349 * @ret_tty: returned tty structure
1350 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001351 *
1352 * Prepare a tty device. This may not be a "new" clean device but
1353 * could also be an active device. The pty drivers require special
1354 * handling because of this.
1355 *
1356 * Locking:
1357 * The function is called under the tty_mutex, which
1358 * protects us from the tty struct or driver itself going away.
1359 *
1360 * On exit the tty device has the line discipline attached and
1361 * a reference count of 1. If a pair was created for pty/tty use
1362 * and the other was a pty master then it too has a reference count of 1.
1363 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001365 * failed open. The new code protects the open with a mutex, so it's
1366 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 * relaxed for the (most common) case of reopening a tty.
1368 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001369
Alan Cox73ec06f2008-10-13 10:42:29 +01001370struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1371 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372{
Alan Coxbf970ee2008-10-13 10:42:39 +01001373 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001374 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001376 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001377 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Coxeeb89d92009-11-30 13:18:29 +00001378 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {
Alan Cox73ec06f2008-10-13 10:42:29 +01001379 return ERR_PTR(-EIO);
Alan Coxeeb89d92009-11-30 13:18:29 +00001380 }
Alan Cox73ec06f2008-10-13 10:42:29 +01001381
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 /*
1383 * First time open is complex, especially for PTY devices.
1384 * This code guarantees that either everything succeeds and the
1385 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001386 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 * and locked termios may be retained.)
1388 */
1389
Alan Cox73ec06f2008-10-13 10:42:29 +01001390 if (!try_module_get(driver->owner))
1391 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 tty = alloc_tty_struct();
Alan Cox37bdfb02008-02-08 04:18:47 -08001394 if (!tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 goto fail_no_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +01001396 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
Alan Cox73ec06f2008-10-13 10:42:29 +01001398 retval = tty_driver_install_tty(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001399 if (retval < 0) {
1400 free_tty_struct(tty);
1401 module_put(driver->owner);
1402 return ERR_PTR(retval);
1403 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001404
Alan Cox37bdfb02008-02-08 04:18:47 -08001405 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001407 * If we fail here just call release_tty to clean up. No need
1408 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001410 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001411 if (retval)
1412 goto release_mem_out;
Alan Cox73ec06f2008-10-13 10:42:29 +01001413 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415fail_no_mem:
1416 module_put(driver->owner);
Alan Cox73ec06f2008-10-13 10:42:29 +01001417 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001419 /* call the tty release_tty routine to clean out this slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420release_mem_out:
Akinobu Mita40509142006-09-29 02:01:27 -07001421 if (printk_ratelimit())
Alan Coxd81ed102008-10-13 10:41:42 +01001422 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001423 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001424 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001425 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426}
1427
Alan Coxfeebed62008-10-13 10:41:30 +01001428void tty_free_termios(struct tty_struct *tty)
1429{
1430 struct ktermios *tp;
1431 int idx = tty->index;
1432 /* Kill this flag and push into drivers for locking etc */
1433 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1434 /* FIXME: Locking on ->termios array */
1435 tp = tty->termios;
1436 tty->driver->termios[idx] = NULL;
1437 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001438 }
1439}
1440EXPORT_SYMBOL(tty_free_termios);
1441
1442void tty_shutdown(struct tty_struct *tty)
1443{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001444 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001445 tty_free_termios(tty);
1446}
1447EXPORT_SYMBOL(tty_shutdown);
1448
Alan Coxaf9b8972006-08-27 01:24:01 -07001449/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001450 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001451 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001452 *
1453 * Releases memory associated with a tty structure, and clears out the
1454 * driver table slots. This function is called when a device is no longer
1455 * in use. It also gets called when setup of a device fails.
1456 *
1457 * Locking:
1458 * tty_mutex - sometimes only
1459 * takes the file list lock internally when working on the list
1460 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001461 *
1462 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001463 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 */
Alan Coxb50989d2009-09-19 13:13:22 -07001465static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466{
Alan Coxb50989d2009-09-19 13:13:22 -07001467 struct tty_struct *tty =
1468 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001469 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
Dave Youngf278a2f2009-09-27 16:00:42 +00001471 if (tty->ops->cleanup)
1472 tty->ops->cleanup(tty);
1473
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001475 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001476 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001477
Nick Pigginee2ffa02010-08-18 04:37:35 +10001478 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 list_del_init(&tty->tty_files);
Nick Pigginee2ffa02010-08-18 04:37:35 +10001480 spin_unlock(&tty_files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001481
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001482 put_pid(tty->pgrp);
1483 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 free_tty_struct(tty);
1485}
1486
Alan Coxb50989d2009-09-19 13:13:22 -07001487static void queue_release_one_tty(struct kref *kref)
1488{
1489 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001490
1491 if (tty->ops->shutdown)
1492 tty->ops->shutdown(tty);
1493 else
1494 tty_shutdown(tty);
1495
Alan Coxb50989d2009-09-19 13:13:22 -07001496 /* The hangup queue is now free so we can reuse it rather than
1497 waste a chunk of memory for each port */
1498 INIT_WORK(&tty->hangup_work, release_one_tty);
1499 schedule_work(&tty->hangup_work);
1500}
1501
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001502/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001503 * tty_kref_put - release a tty kref
1504 * @tty: tty device
1505 *
1506 * Release a reference to a tty device and if need be let the kref
1507 * layer destruct the object for us
1508 */
1509
1510void tty_kref_put(struct tty_struct *tty)
1511{
1512 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001513 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001514}
1515EXPORT_SYMBOL(tty_kref_put);
1516
1517/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001518 * release_tty - release tty structure memory
1519 *
1520 * Release both @tty and a possible linked partner (think pty pair),
1521 * and decrement the refcount of the backing module.
1522 *
1523 * Locking:
1524 * tty_mutex - sometimes only
1525 * takes the file list lock internally when working on the list
1526 * of ttys that the driver keeps.
1527 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001528 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001529 */
1530static void release_tty(struct tty_struct *tty, int idx)
1531{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001532 /* This should always be true but check for the moment */
1533 WARN_ON(tty->index != idx);
1534
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001535 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001536 tty_kref_put(tty->link);
1537 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001538}
1539
Alan Coxeeb89d92009-11-30 13:18:29 +00001540/**
1541 * tty_release - vfs callback for close
1542 * @inode: inode of tty
1543 * @filp: file pointer for handle to tty
1544 *
1545 * Called the last time each file handle is closed that references
1546 * this tty. There may however be several such references.
1547 *
1548 * Locking:
1549 * Takes bkl. See tty_release_dev
1550 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 * Even releasing the tty structures is a tricky business.. We have
1552 * to be very careful that the structures are all released at the
1553 * same time, as interrupts might otherwise get the wrong pointers.
1554 *
1555 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1556 * lead to double frees or releasing memory still in use.
1557 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001558
1559int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560{
Nick Piggind996b622010-08-18 04:37:36 +10001561 struct tty_struct *tty = file_tty(filp);
1562 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001564 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 int idx;
1566 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001567
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001568 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
Alan Coxeeb89d92009-11-30 13:18:29 +00001569 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
Arnd Bergmannec79d602010-06-01 22:53:01 +02001571 tty_lock();
Alan Coxd81ed102008-10-13 10:41:42 +01001572 check_tty_count(tty, "tty_release_dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
Arnd Bergmannec79d602010-06-01 22:53:01 +02001574 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
1576 idx = tty->index;
1577 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1578 tty->driver->subtype == PTY_TYPE_MASTER);
1579 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 o_tty = tty->link;
1581
1582#ifdef TTY_PARANOIA_CHECK
1583 if (idx < 0 || idx >= tty->driver->num) {
Alan Coxd81ed102008-10-13 10:41:42 +01001584 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 "free (%s)\n", tty->name);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001586 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001587 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001589 if (!devpts) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 if (tty != tty->driver->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001591 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001592 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 "for (%s)\n", idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001594 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 }
1596 if (tty->termios != tty->driver->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001597 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001598 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 "for (%s)\n",
1600 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001601 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 }
1604#endif
1605
1606#ifdef TTY_DEBUG_HANGUP
Alan Coxd81ed102008-10-13 10:41:42 +01001607 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 tty_name(tty, buf), tty->count);
1609#endif
1610
1611#ifdef TTY_PARANOIA_CHECK
1612 if (tty->driver->other &&
1613 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1614 if (o_tty != tty->driver->other->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001615 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001616 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 "not o_tty for (%s)\n",
1618 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001619 return 0 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 }
1621 if (o_tty->termios != tty->driver->other->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001622 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001623 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 "not o_termios for (%s)\n",
1625 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001626 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 if (o_tty->link != tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001629 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001630 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
Alan Coxeeb89d92009-11-30 13:18:29 +00001631 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 }
1633 }
1634#endif
Alan Coxf34d7a52008-04-30 00:54:13 -07001635 if (tty->ops->close)
1636 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Arnd Bergmannec79d602010-06-01 22:53:01 +02001638 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 /*
1640 * Sanity check: if tty->count is going to zero, there shouldn't be
1641 * any waiters on tty->read_wait or tty->write_wait. We test the
1642 * wait queues and kick everyone out _before_ actually starting to
1643 * close. This ensures that we won't block while releasing the tty
1644 * structure.
1645 *
1646 * The test for the o_tty closing is necessary, since the master and
1647 * slave sides may close in any order. If the slave side closes out
1648 * first, its count will be one, since the master side holds an open.
1649 * Thus this test wouldn't be triggered at the time the slave closes,
1650 * so we do it now.
1651 *
1652 * Note that it's possible for the tty to be opened again while we're
1653 * flushing out waiters. By recalculating the closing flags before
1654 * each iteration we avoid any problems.
1655 */
1656 while (1) {
1657 /* Guard against races with tty->count changes elsewhere and
1658 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001659
Ingo Molnar70522e12006-03-23 03:00:31 -08001660 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001661 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 tty_closing = tty->count <= 1;
1663 o_tty_closing = o_tty &&
1664 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 do_sleep = 0;
1666
1667 if (tty_closing) {
1668 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001669 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 do_sleep++;
1671 }
1672 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001673 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 do_sleep++;
1675 }
1676 }
1677 if (o_tty_closing) {
1678 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001679 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 do_sleep++;
1681 }
1682 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001683 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 do_sleep++;
1685 }
1686 }
1687 if (!do_sleep)
1688 break;
1689
Alan Coxd81ed102008-10-13 10:41:42 +01001690 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 "active!\n", tty_name(tty, buf));
Arnd Bergmannec79d602010-06-01 22:53:01 +02001692 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001693 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001695 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696
1697 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001698 * The closing flags are now consistent with the open counts on
1699 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 * block, so it's safe to proceed with closing.
1701 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 if (pty_master) {
1703 if (--o_tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001704 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 "(%d) for %s\n",
1706 o_tty->count, tty_name(o_tty, buf));
1707 o_tty->count = 0;
1708 }
1709 }
1710 if (--tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001711 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 tty->count, tty_name(tty, buf));
1713 tty->count = 0;
1714 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001715
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 /*
1717 * We've decremented tty->count, so we need to remove this file
1718 * descriptor off the tty->tty_files list; this serves two
1719 * purposes:
1720 * - check_tty_count sees the correct number of file descriptors
1721 * associated with this tty.
1722 * - do_tty_hangup no longer sees this file descriptor as
1723 * something that needs to be handled for hangups.
1724 */
Nick Piggind996b622010-08-18 04:37:36 +10001725 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
1727 /*
1728 * Perform some housekeeping before deciding whether to return.
1729 *
1730 * Set the TTY_CLOSING flag if this was the last open. In the
1731 * case of a pty we may have to wait around for the other side
1732 * to close, and TTY_CLOSING makes sure we can't be reopened.
1733 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001734 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001736 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 set_bit(TTY_CLOSING, &o_tty->flags);
1738
1739 /*
1740 * If _either_ side is closing, make sure there aren't any
1741 * processes that still think tty or o_tty is their controlling
1742 * tty.
1743 */
1744 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001746 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001748 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 read_unlock(&tasklist_lock);
1750 }
1751
Ingo Molnar70522e12006-03-23 03:00:31 -08001752 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001753
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 /* check whether both sides are closing ... */
Alan Coxeeb89d92009-11-30 13:18:29 +00001755 if (!tty_closing || (o_tty && !o_tty_closing)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001756 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001757 return 0;
1758 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001759
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760#ifdef TTY_DEBUG_HANGUP
1761 printk(KERN_DEBUG "freeing tty structure...");
1762#endif
1763 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001764 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001766 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001768 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 * the slots and preserving the termios structure.
1770 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001771 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001774 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001775 devpts_kill_index(inode, idx);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001776 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001777 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778}
1779
Alan Coxaf9b8972006-08-27 01:24:01 -07001780/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001781 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001782 * @inode: inode of device file
1783 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001785 * tty_open and tty_release keep up the tty count that contains the
1786 * number of opens done on a tty. We cannot use the inode-count, as
1787 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001789 * Open-counting is needed for pty masters, as well as for keeping
1790 * track of serial lines: DTR is dropped when the last close happens.
1791 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1792 *
1793 * The termios state of a pty is reset on first open so that
1794 * settings don't persist across reuse.
1795 *
Alan Coxd81ed102008-10-13 10:41:42 +01001796 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001797 * tty->count should protect the rest.
1798 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001800
Alan Coxeeb89d92009-11-30 13:18:29 +00001801static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802{
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001803 struct tty_struct *tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 int noctty, retval;
1805 struct tty_driver *driver;
1806 int index;
1807 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001808 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809
1810 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001811
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812retry_open:
1813 noctty = filp->f_flags & O_NOCTTY;
1814 index = -1;
1815 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001816
Ingo Molnar70522e12006-03-23 03:00:31 -08001817 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001818 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819
Alan Cox37bdfb02008-02-08 04:18:47 -08001820 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001821 tty = get_current_tty();
1822 if (!tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001823 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001824 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 return -ENXIO;
1826 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01001827 driver = tty_driver_kref_get(tty->driver);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001828 index = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1830 /* noctty = 1; */
Alan Cox452a00d2008-10-13 10:39:13 +01001831 /* FIXME: Should we take a driver reference ? */
1832 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 goto got_driver;
1834 }
1835#ifdef CONFIG_VT
Alan Cox37bdfb02008-02-08 04:18:47 -08001836 if (device == MKDEV(TTY_MAJOR, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 extern struct tty_driver *console_driver;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001838 driver = tty_driver_kref_get(console_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 index = fg_console;
1840 noctty = 1;
1841 goto got_driver;
1842 }
1843#endif
Alan Cox37bdfb02008-02-08 04:18:47 -08001844 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
Will Newton296fa7f2008-12-01 11:36:06 +00001845 struct tty_driver *console_driver = console_device(&index);
1846 if (console_driver) {
1847 driver = tty_driver_kref_get(console_driver);
1848 if (driver) {
1849 /* Don't let /dev/console block */
1850 filp->f_flags |= O_NONBLOCK;
1851 noctty = 1;
1852 goto got_driver;
1853 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001855 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001856 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 return -ENODEV;
1858 }
1859
1860 driver = get_tty_driver(device, &index);
1861 if (!driver) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001862 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001863 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 return -ENODEV;
1865 }
1866got_driver:
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001867 if (!tty) {
1868 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001869 tty = tty_driver_lookup_tty(driver, inode, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001870
Eric Paris808ffa32009-01-27 11:50:37 +00001871 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001872 tty_unlock();
Eric Paris808ffa32009-01-27 11:50:37 +00001873 mutex_unlock(&tty_mutex);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001874 return PTR_ERR(tty);
Eric Paris808ffa32009-01-27 11:50:37 +00001875 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001876 }
1877
1878 if (tty) {
1879 retval = tty_reopen(tty);
1880 if (retval)
1881 tty = ERR_PTR(retval);
1882 } else
1883 tty = tty_init_dev(driver, index, 0);
1884
Ingo Molnar70522e12006-03-23 03:00:31 -08001885 mutex_unlock(&tty_mutex);
Alan Cox7d7b93c2008-10-13 10:42:09 +01001886 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001887 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001888 tty_unlock();
Alan Cox73ec06f2008-10-13 10:42:29 +01001889 return PTR_ERR(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001890 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891
Pekka Enbergf573bd12010-08-24 07:48:34 +03001892 retval = tty_add_file(tty, filp);
1893 if (retval) {
1894 tty_unlock();
1895 return retval;
1896 }
Nick Piggind996b622010-08-18 04:37:36 +10001897
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 check_tty_count(tty, "tty_open");
1899 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1900 tty->driver->subtype == PTY_TYPE_MASTER)
1901 noctty = 1;
1902#ifdef TTY_DEBUG_HANGUP
1903 printk(KERN_DEBUG "opening %s...", tty->name);
1904#endif
1905 if (!retval) {
Alan Coxf34d7a52008-04-30 00:54:13 -07001906 if (tty->ops->open)
1907 retval = tty->ops->open(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 else
1909 retval = -ENODEV;
1910 }
1911 filp->f_flags = saved_flags;
1912
Alan Cox37bdfb02008-02-08 04:18:47 -08001913 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1914 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 retval = -EBUSY;
1916
1917 if (retval) {
1918#ifdef TTY_DEBUG_HANGUP
1919 printk(KERN_DEBUG "error %d in opening %s...", retval,
1920 tty->name);
1921#endif
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001922 tty_unlock(); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00001923 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001924 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001926
1927 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001929
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 schedule();
1931 /*
1932 * Need to reset f_op in case a hangup happened.
1933 */
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001934 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 if (filp->f_op == &hung_up_tty_fops)
1936 filp->f_op = &tty_fops;
Arnd Bergmannec79d602010-06-01 22:53:01 +02001937 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 goto retry_open;
1939 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001940 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001941
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001942
1943 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001944 tty_lock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001945 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 if (!noctty &&
1947 current->signal->leader &&
1948 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001949 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07001950 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001951 spin_unlock_irq(&current->sighand->siglock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001952 tty_unlock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001953 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 return 0;
1955}
1956
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001957
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958
Alan Coxaf9b8972006-08-27 01:24:01 -07001959/**
1960 * tty_poll - check tty status
1961 * @filp: file being polled
1962 * @wait: poll wait structures to update
1963 *
1964 * Call the line discipline polling method to obtain the poll
1965 * status of the device.
1966 *
1967 * Locking: locks called line discipline but ldisc poll method
1968 * may be re-entered freely by other callers.
1969 */
1970
Alan Cox37bdfb02008-02-08 04:18:47 -08001971static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972{
Nick Piggind996b622010-08-18 04:37:36 +10001973 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 struct tty_ldisc *ld;
1975 int ret = 0;
1976
Josef Sipeka7113a92006-12-08 02:36:55 -08001977 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001979
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001981 if (ld->ops->poll)
1982 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 tty_ldisc_deref(ld);
1984 return ret;
1985}
1986
Arnd Bergmannec79d602010-06-01 22:53:01 +02001987static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988{
Nick Piggind996b622010-08-18 04:37:36 +10001989 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07001990 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001991 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992
Josef Sipeka7113a92006-12-08 02:36:55 -08001993 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001994 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08001995
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 retval = fasync_helper(fd, filp, on, &tty->fasync);
1997 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001998 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999
2000 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002001 enum pid_type type;
2002 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 if (!waitqueue_active(&tty->read_wait))
2004 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07002005 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002006 if (tty->pgrp) {
2007 pid = tty->pgrp;
2008 type = PIDTYPE_PGID;
2009 } else {
2010 pid = task_pid(current);
2011 type = PIDTYPE_PID;
2012 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002013 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002014 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002015 retval = __f_setown(filp, pid, type, 0);
2016 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002018 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 } else {
2020 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2021 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2022 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002023 retval = 0;
2024out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002025 return retval;
2026}
2027
2028static int tty_fasync(int fd, struct file *filp, int on)
2029{
2030 int retval;
2031 tty_lock();
2032 retval = __tty_fasync(fd, filp, on);
2033 tty_unlock();
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002034 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035}
2036
Alan Coxaf9b8972006-08-27 01:24:01 -07002037/**
2038 * tiocsti - fake input character
2039 * @tty: tty to fake input into
2040 * @p: pointer to character
2041 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002042 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002043 * input management.
2044 *
2045 * FIXME: does not honour flow control ??
2046 *
2047 * Locking:
2048 * Called functions take tty_ldisc_lock
2049 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002050 *
2051 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002052 */
2053
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054static int tiocsti(struct tty_struct *tty, char __user *p)
2055{
2056 char ch, mbz = 0;
2057 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002058
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2060 return -EPERM;
2061 if (get_user(ch, p))
2062 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002063 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002065 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 tty_ldisc_deref(ld);
2067 return 0;
2068}
2069
Alan Coxaf9b8972006-08-27 01:24:01 -07002070/**
2071 * tiocgwinsz - implement window query ioctl
2072 * @tty; tty
2073 * @arg: user buffer for result
2074 *
Alan Cox808a0d32006-09-29 02:00:40 -07002075 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002076 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002077 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002078 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002079 */
2080
Alan Cox37bdfb02008-02-08 04:18:47 -08002081static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082{
Alan Cox808a0d32006-09-29 02:00:40 -07002083 int err;
2084
Arjan van de Ven5785c952006-09-29 02:00:43 -07002085 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002086 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002087 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002088
2089 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090}
2091
Alan Coxaf9b8972006-08-27 01:24:01 -07002092/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002093 * tty_do_resize - resize event
2094 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002095 * @rows: rows (character)
2096 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002097 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002098 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002099 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002100 */
2101
Alan Coxfc6f6232009-01-02 13:43:17 +00002102int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103{
Alan Coxfc6f6232009-01-02 13:43:17 +00002104 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002105 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106
Alan Coxfc6f6232009-01-02 13:43:17 +00002107 /* Lock the tty */
2108 mutex_lock(&tty->termios_mutex);
2109 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002110 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002111 /* Get the PID values and reference them so we can
2112 avoid holding the tty ctrl lock while sending signals */
2113 spin_lock_irqsave(&tty->ctrl_lock, flags);
2114 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002115 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2116
2117 if (pgrp)
2118 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002119 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002120
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002121 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002122done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002123 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124 return 0;
2125}
2126
Alan Coxaf9b8972006-08-27 01:24:01 -07002127/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002128 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002129 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002130 * @arg: user buffer for result
2131 *
2132 * Copies the user idea of the window size to the kernel. Traditionally
2133 * this is just advisory information but for the Linux console it
2134 * actually has driver level meaning and triggers a VC resize.
2135 *
2136 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002137 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002138 * tty termios mutex and ctrl_lock. The console takes its own lock
2139 * then calls into the default method.
2140 */
2141
Alan Coxfc6f6232009-01-02 13:43:17 +00002142static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002143{
2144 struct winsize tmp_ws;
2145 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2146 return -EFAULT;
2147
2148 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002149 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002150 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002151 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002152}
2153
2154/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002155 * tioccons - allow admin to move logical console
2156 * @file: the file to become console
2157 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002158 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002159 *
2160 * Locking: uses redirect_lock to guard the redirect information
2161 */
2162
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163static int tioccons(struct file *file)
2164{
2165 if (!capable(CAP_SYS_ADMIN))
2166 return -EPERM;
2167 if (file->f_op->write == redirected_tty_write) {
2168 struct file *f;
2169 spin_lock(&redirect_lock);
2170 f = redirect;
2171 redirect = NULL;
2172 spin_unlock(&redirect_lock);
2173 if (f)
2174 fput(f);
2175 return 0;
2176 }
2177 spin_lock(&redirect_lock);
2178 if (redirect) {
2179 spin_unlock(&redirect_lock);
2180 return -EBUSY;
2181 }
2182 get_file(file);
2183 redirect = file;
2184 spin_unlock(&redirect_lock);
2185 return 0;
2186}
2187
Alan Coxaf9b8972006-08-27 01:24:01 -07002188/**
2189 * fionbio - non blocking ioctl
2190 * @file: file to set blocking value
2191 * @p: user parameter
2192 *
2193 * Historical tty interfaces had a blocking control ioctl before
2194 * the generic functionality existed. This piece of history is preserved
2195 * in the expected tty API of posix OS's.
2196 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002197 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002198 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199
2200static int fionbio(struct file *file, int __user *p)
2201{
2202 int nonblock;
2203
2204 if (get_user(nonblock, p))
2205 return -EFAULT;
2206
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002207 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 if (nonblock)
2209 file->f_flags |= O_NONBLOCK;
2210 else
2211 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002212 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 return 0;
2214}
2215
Alan Coxaf9b8972006-08-27 01:24:01 -07002216/**
2217 * tiocsctty - set controlling tty
2218 * @tty: tty structure
2219 * @arg: user argument
2220 *
2221 * This ioctl is used to manage job control. It permits a session
2222 * leader to set this tty as the controlling tty for the session.
2223 *
2224 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002225 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002226 * Takes tasklist_lock internally to walk sessions
2227 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002228 */
2229
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230static int tiocsctty(struct tty_struct *tty, int arg)
2231{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002232 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002233 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002234 return ret;
2235
2236 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 /*
2238 * The process must be a session leader and
2239 * not have a controlling tty already.
2240 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002241 if (!current->signal->leader || current->signal->tty) {
2242 ret = -EPERM;
2243 goto unlock;
2244 }
2245
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002246 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 /*
2248 * This tty is already the controlling
2249 * tty for another session group!
2250 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002251 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 /*
2253 * Steal it away
2254 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002256 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002258 } else {
2259 ret = -EPERM;
2260 goto unlock;
2261 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002263 proc_set_tty(current, tty);
2264unlock:
Alan Cox28298232006-09-29 02:00:58 -07002265 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002266 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267}
2268
Alan Coxaf9b8972006-08-27 01:24:01 -07002269/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002270 * tty_get_pgrp - return a ref counted pgrp pid
2271 * @tty: tty to read
2272 *
2273 * Returns a refcounted instance of the pid struct for the process
2274 * group controlling the tty.
2275 */
2276
2277struct pid *tty_get_pgrp(struct tty_struct *tty)
2278{
2279 unsigned long flags;
2280 struct pid *pgrp;
2281
2282 spin_lock_irqsave(&tty->ctrl_lock, flags);
2283 pgrp = get_pid(tty->pgrp);
2284 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2285
2286 return pgrp;
2287}
2288EXPORT_SYMBOL_GPL(tty_get_pgrp);
2289
2290/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002291 * tiocgpgrp - get process group
2292 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002293 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002294 * @p: returned pid
2295 *
2296 * Obtain the process group of the tty. If there is no process group
2297 * return an error.
2298 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002299 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002300 */
2301
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2303{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002304 struct pid *pid;
2305 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 /*
2307 * (tty == real_tty) is a cheap way of
2308 * testing if the tty is NOT a master pty.
2309 */
2310 if (tty == real_tty && current->signal->tty != real_tty)
2311 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002312 pid = tty_get_pgrp(real_tty);
2313 ret = put_user(pid_vnr(pid), p);
2314 put_pid(pid);
2315 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316}
2317
Alan Coxaf9b8972006-08-27 01:24:01 -07002318/**
2319 * tiocspgrp - attempt to set process group
2320 * @tty: tty passed by user
2321 * @real_tty: tty side device matching tty passed by user
2322 * @p: pid pointer
2323 *
2324 * Set the process group of the tty to the session passed. Only
2325 * permitted where the tty session is our session.
2326 *
Alan Cox47f86832008-04-30 00:53:30 -07002327 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002328 */
2329
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2331{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002332 struct pid *pgrp;
2333 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002335 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
2337 if (retval == -EIO)
2338 return -ENOTTY;
2339 if (retval)
2340 return retval;
2341 if (!current->signal->tty ||
2342 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002343 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002345 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002347 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002349 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002350 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002351 retval = -ESRCH;
2352 if (!pgrp)
2353 goto out_unlock;
2354 retval = -EPERM;
2355 if (session_of_pgrp(pgrp) != task_session(current))
2356 goto out_unlock;
2357 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002358 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002359 put_pid(real_tty->pgrp);
2360 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002361 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002362out_unlock:
2363 rcu_read_unlock();
2364 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365}
2366
Alan Coxaf9b8972006-08-27 01:24:01 -07002367/**
2368 * tiocgsid - get session id
2369 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002370 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002371 * @p: pointer to returned session id
2372 *
2373 * Obtain the session id of the tty. If there is no session
2374 * return an error.
2375 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002376 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002377 */
2378
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2380{
2381 /*
2382 * (tty == real_tty) is a cheap way of
2383 * testing if the tty is NOT a master pty.
2384 */
2385 if (tty == real_tty && current->signal->tty != real_tty)
2386 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002387 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002389 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390}
2391
Alan Coxaf9b8972006-08-27 01:24:01 -07002392/**
2393 * tiocsetd - set line discipline
2394 * @tty: tty device
2395 * @p: pointer to user data
2396 *
2397 * Set the line discipline according to user request.
2398 *
2399 * Locking: see tty_set_ldisc, this function is just a helper
2400 */
2401
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402static int tiocsetd(struct tty_struct *tty, int __user *p)
2403{
2404 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002405 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406
2407 if (get_user(ldisc, p))
2408 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002409
Alan Cox04f378b2008-04-30 00:53:29 -07002410 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002411
2412 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413}
2414
Alan Coxaf9b8972006-08-27 01:24:01 -07002415/**
2416 * send_break - performed time break
2417 * @tty: device to break on
2418 * @duration: timeout in mS
2419 *
2420 * Perform a timed break on hardware that lacks its own driver level
2421 * timed break functionality.
2422 *
2423 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002424 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002425 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002426 */
2427
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002428static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429{
Alan Cox9e989662008-07-22 11:18:03 +01002430 int retval;
2431
2432 if (tty->ops->break_ctl == NULL)
2433 return 0;
2434
2435 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2436 retval = tty->ops->break_ctl(tty, duration);
2437 else {
2438 /* Do the work ourselves */
2439 if (tty_write_lock(tty, 0) < 0)
2440 return -EINTR;
2441 retval = tty->ops->break_ctl(tty, -1);
2442 if (retval)
2443 goto out;
2444 if (!signal_pending(current))
2445 msleep_interruptible(duration);
2446 retval = tty->ops->break_ctl(tty, 0);
2447out:
2448 tty_write_unlock(tty);
2449 if (signal_pending(current))
2450 retval = -EINTR;
2451 }
2452 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453}
2454
Alan Coxaf9b8972006-08-27 01:24:01 -07002455/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002456 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002457 * @tty: tty device
2458 * @file: user file pointer
2459 * @p: pointer to result
2460 *
2461 * Obtain the modem status bits from the tty driver if the feature
2462 * is supported. Return -EINVAL if it is not available.
2463 *
2464 * Locking: none (up to the driver)
2465 */
2466
Alan Cox60b33c12011-02-14 16:26:14 +00002467static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468{
2469 int retval = -EINVAL;
2470
Alan Coxf34d7a52008-04-30 00:54:13 -07002471 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002472 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473
2474 if (retval >= 0)
2475 retval = put_user(retval, p);
2476 }
2477 return retval;
2478}
2479
Alan Coxaf9b8972006-08-27 01:24:01 -07002480/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002481 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002482 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002483 * @cmd: command - clear bits, set bits or set all
2484 * @p: pointer to desired bits
2485 *
2486 * Set the modem status bits from the tty driver if the feature
2487 * is supported. Return -EINVAL if it is not available.
2488 *
2489 * Locking: none (up to the driver)
2490 */
2491
Alan Cox20b9d172011-02-14 16:26:50 +00002492static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 unsigned __user *p)
2494{
Alan Coxae677512008-07-16 21:56:54 +01002495 int retval;
2496 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497
Alan Coxae677512008-07-16 21:56:54 +01002498 if (tty->ops->tiocmset == NULL)
2499 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500
Alan Coxae677512008-07-16 21:56:54 +01002501 retval = get_user(val, p);
2502 if (retval)
2503 return retval;
2504 set = clear = 0;
2505 switch (cmd) {
2506 case TIOCMBIS:
2507 set = val;
2508 break;
2509 case TIOCMBIC:
2510 clear = val;
2511 break;
2512 case TIOCMSET:
2513 set = val;
2514 clear = ~val;
2515 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 }
Alan Coxae677512008-07-16 21:56:54 +01002517 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2518 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002519 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520}
2521
Alan Coxd281da72010-09-16 18:21:24 +01002522static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2523{
2524 int retval = -EINVAL;
2525 struct serial_icounter_struct icount;
2526 memset(&icount, 0, sizeof(icount));
2527 if (tty->ops->get_icount)
2528 retval = tty->ops->get_icount(tty, &icount);
2529 if (retval != 0)
2530 return retval;
2531 if (copy_to_user(arg, &icount, sizeof(icount)))
2532 return -EFAULT;
2533 return 0;
2534}
2535
Alan Coxe8b70e72009-06-11 12:48:02 +01002536struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2537{
2538 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2539 tty->driver->subtype == PTY_TYPE_MASTER)
2540 tty = tty->link;
2541 return tty;
2542}
2543EXPORT_SYMBOL(tty_pair_get_tty);
2544
2545struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2546{
2547 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2548 tty->driver->subtype == PTY_TYPE_MASTER)
2549 return tty;
2550 return tty->link;
2551}
2552EXPORT_SYMBOL(tty_pair_get_pty);
2553
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554/*
2555 * Split this up, as gcc can choke on it otherwise..
2556 */
Alan Cox04f378b2008-04-30 00:53:29 -07002557long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558{
Nick Piggind996b622010-08-18 04:37:36 +10002559 struct tty_struct *tty = file_tty(file);
2560 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 void __user *p = (void __user *)arg;
2562 int retval;
2563 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002564 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002565
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2567 return -EINVAL;
2568
Alan Coxe8b70e72009-06-11 12:48:02 +01002569 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570
2571 /*
2572 * Factor out some common prep work
2573 */
2574 switch (cmd) {
2575 case TIOCSETD:
2576 case TIOCSBRK:
2577 case TIOCCBRK:
2578 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002579 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 retval = tty_check_change(tty);
2581 if (retval)
2582 return retval;
2583 if (cmd != TIOCCBRK) {
2584 tty_wait_until_sent(tty, 0);
2585 if (signal_pending(current))
2586 return -EINTR;
2587 }
2588 break;
2589 }
2590
Alan Cox9e989662008-07-22 11:18:03 +01002591 /*
2592 * Now do the stuff.
2593 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002595 case TIOCSTI:
2596 return tiocsti(tty, p);
2597 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002598 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002599 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002600 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002601 case TIOCCONS:
2602 return real_tty != tty ? -EINVAL : tioccons(file);
2603 case FIONBIO:
2604 return fionbio(file, p);
2605 case TIOCEXCL:
2606 set_bit(TTY_EXCLUSIVE, &tty->flags);
2607 return 0;
2608 case TIOCNXCL:
2609 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2610 return 0;
2611 case TIOCNOTTY:
2612 if (current->signal->tty != tty)
2613 return -ENOTTY;
2614 no_tty();
2615 return 0;
2616 case TIOCSCTTY:
2617 return tiocsctty(tty, arg);
2618 case TIOCGPGRP:
2619 return tiocgpgrp(tty, real_tty, p);
2620 case TIOCSPGRP:
2621 return tiocspgrp(tty, real_tty, p);
2622 case TIOCGSID:
2623 return tiocgsid(tty, real_tty, p);
2624 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002625 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002626 case TIOCSETD:
2627 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002628 case TIOCVHANGUP:
2629 if (!capable(CAP_SYS_ADMIN))
2630 return -EPERM;
2631 tty_vhangup(tty);
2632 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002633 case TIOCGDEV:
2634 {
2635 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2636 return put_user(ret, (unsigned int __user *)p);
2637 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002638 /*
2639 * Break handling
2640 */
2641 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002642 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002643 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002644 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002645 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002646 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002647 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002648 return 0;
2649 case TCSBRK: /* SVID version: non-zero arg --> no break */
2650 /* non-zero arg means wait for all output data
2651 * to be sent (performed above) but don't send break.
2652 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002654 if (!arg)
2655 return send_break(tty, 250);
2656 return 0;
2657 case TCSBRKP: /* support for POSIX tcsendbreak() */
2658 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659
Alan Cox37bdfb02008-02-08 04:18:47 -08002660 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002661 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002662 case TIOCMSET:
2663 case TIOCMBIC:
2664 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002665 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002666 case TIOCGICOUNT:
2667 retval = tty_tiocgicount(tty, p);
2668 /* For the moment allow fall through to the old method */
2669 if (retval != -EINVAL)
2670 return retval;
2671 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002672 case TCFLSH:
2673 switch (arg) {
2674 case TCIFLUSH:
2675 case TCIOFLUSH:
2676 /* flush tty buffer and allow ldisc to process ioctl */
2677 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002678 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002679 }
2680 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002682 if (tty->ops->ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002683 retval = (tty->ops->ioctl)(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 if (retval != -ENOIOCTLCMD)
2685 return retval;
2686 }
2687 ld = tty_ldisc_ref_wait(tty);
2688 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002689 if (ld->ops->ioctl) {
2690 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691 if (retval == -ENOIOCTLCMD)
2692 retval = -EINVAL;
2693 }
2694 tty_ldisc_deref(ld);
2695 return retval;
2696}
2697
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002698#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002699static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002700 unsigned long arg)
2701{
2702 struct inode *inode = file->f_dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10002703 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002704 struct tty_ldisc *ld;
2705 int retval = -ENOIOCTLCMD;
2706
2707 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2708 return -EINVAL;
2709
Alan Coxf34d7a52008-04-30 00:54:13 -07002710 if (tty->ops->compat_ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002711 retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002712 if (retval != -ENOIOCTLCMD)
2713 return retval;
2714 }
2715
2716 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002717 if (ld->ops->compat_ioctl)
2718 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002719 tty_ldisc_deref(ld);
2720
2721 return retval;
2722}
2723#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724
2725/*
2726 * This implements the "Secure Attention Key" --- the idea is to
2727 * prevent trojan horses by killing all processes associated with this
2728 * tty when the user hits the "Secure Attention Key". Required for
2729 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002730 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 * This code could be nicer; ideally it should send a HUP, wait a few
2732 * seconds, then send a INT, and then a KILL signal. But you then
2733 * have to coordinate with the init process, since all processes associated
2734 * with the current tty must be dead before the new getty is allowed
2735 * to spawn.
2736 *
2737 * Now, if it would be correct ;-/ The current code has a nasty hole -
2738 * it doesn't catch files in flight. We may send the descriptor to ourselves
2739 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2740 *
2741 * Nasty bug: do_SAK is being called in interrupt context. This can
2742 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2743 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002744void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745{
2746#ifdef TTY_SOFT_SAK
2747 tty_hangup(tty);
2748#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002749 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002750 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751 int i;
2752 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002753 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002754
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 if (!tty)
2756 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002757 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002758
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002759 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760
Alan Coxf34d7a52008-04-30 00:54:13 -07002761 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002762
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002764 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002765 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002766 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002767 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002768 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002769 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002770 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002771 /* Now kill any processes that happen to have the
2772 * tty open.
2773 */
2774 do_each_thread(g, p) {
2775 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002777 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002778 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 send_sig(SIGKILL, p, 1);
2780 continue;
2781 }
2782 task_lock(p);
2783 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002784 /*
2785 * We don't take a ref to the file, so we must
2786 * hold ->file_lock instead.
2787 */
2788 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002789 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002790 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 filp = fcheck_files(p->files, i);
2792 if (!filp)
2793 continue;
2794 if (filp->f_op->read == tty_read &&
Nick Piggind996b622010-08-18 04:37:36 +10002795 file_tty(filp) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796 printk(KERN_NOTICE "SAK: killed process %d"
2797 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002798 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002799 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 break;
2801 }
2802 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002803 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 }
2805 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002806 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807 read_unlock(&tasklist_lock);
2808#endif
2809}
2810
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002811static void do_SAK_work(struct work_struct *work)
2812{
2813 struct tty_struct *tty =
2814 container_of(work, struct tty_struct, SAK_work);
2815 __do_SAK(tty);
2816}
2817
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818/*
2819 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2820 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2821 * the values which we write to it will be identical to the values which it
2822 * already has. --akpm
2823 */
2824void do_SAK(struct tty_struct *tty)
2825{
2826 if (!tty)
2827 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 schedule_work(&tty->SAK_work);
2829}
2830
2831EXPORT_SYMBOL(do_SAK);
2832
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002833static int dev_match_devt(struct device *dev, void *data)
2834{
2835 dev_t *devt = data;
2836 return dev->devt == *devt;
2837}
2838
2839/* Must put_device() after it's unused! */
2840static struct device *tty_get_device(struct tty_struct *tty)
2841{
2842 dev_t devt = tty_devnum(tty);
2843 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2844}
2845
2846
Alan Coxaf9b8972006-08-27 01:24:01 -07002847/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002848 * initialize_tty_struct
2849 * @tty: tty to initialize
2850 *
2851 * This subroutine initializes a tty structure that has been newly
2852 * allocated.
2853 *
2854 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002856
Alan Coxbf970ee2008-10-13 10:42:39 +01002857void initialize_tty_struct(struct tty_struct *tty,
2858 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859{
2860 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002861 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002863 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002864 tty->session = NULL;
2865 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002867 tty->buf.head = tty->buf.tail = NULL;
2868 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002869 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002870 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 init_waitqueue_head(&tty->write_wait);
2872 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002873 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002874 mutex_init(&tty->atomic_read_lock);
2875 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002876 mutex_init(&tty->output_lock);
2877 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002879 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002881 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002882
2883 tty->driver = driver;
2884 tty->ops = driver->ops;
2885 tty->index = idx;
2886 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002887 tty->dev = tty_get_device(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888}
2889
Alan Coxf34d7a52008-04-30 00:54:13 -07002890/**
2891 * tty_put_char - write one character to a tty
2892 * @tty: tty
2893 * @ch: character
2894 *
2895 * Write one byte to the tty using the provided put_char method
2896 * if present. Returns the number of characters successfully output.
2897 *
2898 * Note: the specific put_char operation in the driver layer may go
2899 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002901
Alan Coxf34d7a52008-04-30 00:54:13 -07002902int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903{
Alan Coxf34d7a52008-04-30 00:54:13 -07002904 if (tty->ops->put_char)
2905 return tty->ops->put_char(tty, ch);
2906 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907}
Alan Coxf34d7a52008-04-30 00:54:13 -07002908EXPORT_SYMBOL_GPL(tty_put_char);
2909
Alan Coxd81ed102008-10-13 10:41:42 +01002910struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911
2912/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002913 * tty_register_device - register a tty device
2914 * @driver: the tty driver that describes the tty device
2915 * @index: the index in the tty driver for this tty device
2916 * @device: a struct device that is associated with this tty device.
2917 * This field is optional, if there is no known struct device
2918 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002920 * Returns a pointer to the struct device for this tty device
2921 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002922 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002923 * This call is required to be made to register an individual tty device
2924 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2925 * that bit is not set, this function should not be called by a tty
2926 * driver.
2927 *
2928 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002930
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002931struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2932 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933{
2934 char name[64];
2935 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2936
2937 if (index >= driver->num) {
2938 printk(KERN_ERR "Attempt to register invalid tty line number "
2939 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002940 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 }
2942
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943 if (driver->type == TTY_DRIVER_TYPE_PTY)
2944 pty_line_name(driver, index, name);
2945 else
2946 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002947
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07002948 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002950EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951
2952/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002953 * tty_unregister_device - unregister a tty device
2954 * @driver: the tty driver that describes the tty device
2955 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002957 * If a tty device is registered with a call to tty_register_device() then
2958 * this function must be called when the tty device is gone.
2959 *
2960 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002962
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963void tty_unregister_device(struct tty_driver *driver, unsigned index)
2964{
Alan Cox37bdfb02008-02-08 04:18:47 -08002965 device_destroy(tty_class,
2966 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968EXPORT_SYMBOL(tty_unregister_device);
2969
2970struct tty_driver *alloc_tty_driver(int lines)
2971{
2972 struct tty_driver *driver;
2973
Jean Delvare506eb992007-07-15 23:40:14 -07002974 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01002976 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 driver->magic = TTY_DRIVER_MAGIC;
2978 driver->num = lines;
2979 /* later we'll move allocation of tables here */
2980 }
2981 return driver;
2982}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002983EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984
Alan Cox7d7b93c2008-10-13 10:42:09 +01002985static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002987 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2988 int i;
2989 struct ktermios *tp;
2990 void *p;
2991
2992 if (driver->flags & TTY_DRIVER_INSTALLED) {
2993 /*
2994 * Free the termios and termios_locked structures because
2995 * we don't want to get memory leaks when modular tty
2996 * drivers are removed from the kernel.
2997 */
2998 for (i = 0; i < driver->num; i++) {
2999 tp = driver->termios[i];
3000 if (tp) {
3001 driver->termios[i] = NULL;
3002 kfree(tp);
3003 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003004 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3005 tty_unregister_device(driver, i);
3006 }
3007 p = driver->ttys;
3008 proc_tty_unregister_driver(driver);
3009 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01003010 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003011 kfree(p);
3012 cdev_del(&driver->cdev);
3013 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 kfree(driver);
3015}
3016
Alan Cox7d7b93c2008-10-13 10:42:09 +01003017void tty_driver_kref_put(struct tty_driver *driver)
3018{
3019 kref_put(&driver->kref, destruct_tty_driver);
3020}
3021EXPORT_SYMBOL(tty_driver_kref_put);
3022
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003023void tty_set_operations(struct tty_driver *driver,
3024 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025{
Alan Coxf34d7a52008-04-30 00:54:13 -07003026 driver->ops = op;
3027};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028EXPORT_SYMBOL(tty_set_operations);
3029
Alan Cox7d7b93c2008-10-13 10:42:09 +01003030void put_tty_driver(struct tty_driver *d)
3031{
3032 tty_driver_kref_put(d);
3033}
3034EXPORT_SYMBOL(put_tty_driver);
3035
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036/*
3037 * Called by a tty driver to register itself.
3038 */
3039int tty_register_driver(struct tty_driver *driver)
3040{
3041 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003042 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003043 dev_t dev;
3044 void **p = NULL;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003045 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046
Andy Whitcroft543691a2007-05-06 14:49:33 -07003047 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01003048 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049 if (!p)
3050 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051 }
3052
3053 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003054 error = alloc_chrdev_region(&dev, driver->minor_start,
3055 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 if (!error) {
3057 driver->major = MAJOR(dev);
3058 driver->minor_start = MINOR(dev);
3059 }
3060 } else {
3061 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003062 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 }
3064 if (error < 0) {
3065 kfree(p);
3066 return error;
3067 }
3068
3069 if (p) {
3070 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08003071 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072 } else {
3073 driver->ttys = NULL;
3074 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075 }
3076
3077 cdev_init(&driver->cdev, &tty_fops);
3078 driver->cdev.owner = driver->owner;
3079 error = cdev_add(&driver->cdev, dev, driver->num);
3080 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081 unregister_chrdev_region(dev, driver->num);
3082 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01003083 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 kfree(p);
3085 return error;
3086 }
3087
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003088 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003090 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003091
3092 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003093 for (i = 0; i < driver->num; i++) {
3094 d = tty_register_device(driver, i, NULL);
3095 if (IS_ERR(d)) {
3096 error = PTR_ERR(d);
3097 goto err;
3098 }
3099 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 }
3101 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003102 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003104
3105err:
3106 for (i--; i >= 0; i--)
3107 tty_unregister_device(driver, i);
3108
3109 mutex_lock(&tty_mutex);
3110 list_del(&driver->tty_drivers);
3111 mutex_unlock(&tty_mutex);
3112
3113 unregister_chrdev_region(dev, driver->num);
3114 driver->ttys = NULL;
3115 driver->termios = NULL;
3116 kfree(p);
3117 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118}
3119
3120EXPORT_SYMBOL(tty_register_driver);
3121
3122/*
3123 * Called by a tty driver to unregister itself.
3124 */
3125int tty_unregister_driver(struct tty_driver *driver)
3126{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003127#if 0
3128 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129 if (driver->refcount)
3130 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003131#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003132 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3133 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003134 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003136 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 return 0;
3138}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003139
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140EXPORT_SYMBOL(tty_unregister_driver);
3141
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003142dev_t tty_devnum(struct tty_struct *tty)
3143{
3144 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3145}
3146EXPORT_SYMBOL(tty_devnum);
3147
3148void proc_clear_tty(struct task_struct *p)
3149{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003150 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003151 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003152 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003153 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003154 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003155 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003156 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003157}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003158
Alan Cox47f86832008-04-30 00:53:30 -07003159/* Called under the sighand lock */
3160
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003161static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003162{
3163 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003164 unsigned long flags;
3165 /* We should not have a session or pgrp to put here but.... */
3166 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003167 put_pid(tty->session);
3168 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003169 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003170 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3171 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003172 if (tsk->signal->tty) {
3173 printk(KERN_DEBUG "tty not NULL!!\n");
3174 tty_kref_put(tsk->signal->tty);
3175 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003176 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003177 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003178 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003179 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003180}
3181
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003182static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003183{
3184 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003185 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003186 spin_unlock_irq(&tsk->sighand->siglock);
3187}
3188
3189struct tty_struct *get_current_tty(void)
3190{
3191 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003192 unsigned long flags;
3193
3194 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003195 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003196 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003197 return tty;
3198}
Heiko Carstensa311f742006-12-13 00:33:41 -08003199EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200
Alan Coxd81ed102008-10-13 10:41:42 +01003201void tty_default_fops(struct file_operations *fops)
3202{
3203 *fops = tty_fops;
3204}
3205
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206/*
3207 * Initialize the console device. This is called *early*, so
3208 * we can't necessarily depend on lots of kernel help here.
3209 * Just do some early initializations, and do the complex setup
3210 * later.
3211 */
3212void __init console_init(void)
3213{
3214 initcall_t *call;
3215
3216 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003217 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218
3219 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003220 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221 * inform about problems etc..
3222 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223 call = __con_initcall_start;
3224 while (call < __con_initcall_end) {
3225 (*call)();
3226 call++;
3227 }
3228}
3229
Kay Sieverse454cea2009-09-18 23:01:12 +02003230static char *tty_devnode(struct device *dev, mode_t *mode)
3231{
3232 if (!mode)
3233 return NULL;
3234 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3235 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3236 *mode = 0666;
3237 return NULL;
3238}
3239
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240static int __init tty_class_init(void)
3241{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003242 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243 if (IS_ERR(tty_class))
3244 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003245 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246 return 0;
3247}
3248
3249postcore_initcall(tty_class_init);
3250
3251/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253
Kay Sieversfbc92a32010-12-01 18:51:05 +01003254static ssize_t show_cons_active(struct device *dev,
3255 struct device_attribute *attr, char *buf)
3256{
3257 struct console *cs[16];
3258 int i = 0;
3259 struct console *c;
3260 ssize_t count = 0;
3261
Torben Hohnac751ef2011-01-25 15:07:35 -08003262 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003263 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003264 if (!c->device)
3265 continue;
3266 if (!c->write)
3267 continue;
3268 if ((c->flags & CON_ENABLED) == 0)
3269 continue;
3270 cs[i++] = c;
3271 if (i >= ARRAY_SIZE(cs))
3272 break;
3273 }
3274 while (i--)
3275 count += sprintf(buf + count, "%s%d%c",
3276 cs[i]->name, cs[i]->index, i ? ' ':'\n');
Torben Hohnac751ef2011-01-25 15:07:35 -08003277 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003278
3279 return count;
3280}
3281static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3282
3283static struct device *consdev;
3284
3285void console_sysfs_notify(void)
3286{
3287 if (consdev)
3288 sysfs_notify(&consdev->kobj, NULL, "active");
3289}
3290
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291/*
3292 * Ok, now we can initialize the rest of the tty devices and can count
3293 * on memory allocations, interrupts etc..
3294 */
David Howells31d1d482010-08-06 16:34:43 +01003295int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296{
3297 cdev_init(&tty_cdev, &tty_fops);
3298 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3299 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3300 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003301 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302
3303 cdev_init(&console_cdev, &console_fops);
3304 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3305 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3306 panic("Couldn't register /dev/console driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003307 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003308 "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003309 if (IS_ERR(consdev))
3310 consdev = NULL;
3311 else
Kay Sieversa2a6a822011-01-09 16:39:14 +01003312 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003313
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003315 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003316#endif
3317 return 0;
3318}
David Howells31d1d482010-08-06 16:34:43 +01003319