blob: c05c5af5aa044029561e38de9683e12a26c0c0c4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/char/tty_io.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
8 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9 * or rs-channels. It also implements echoing, cooked mode etc.
10 *
11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12 *
13 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14 * tty_struct and tty_queue structures. Previously there was an array
15 * of 256 tty_struct's which was statically allocated, and the
16 * tty_queue structures were allocated at boot time. Both are now
17 * dynamically allocated only when the tty is open.
18 *
19 * Also restructured routines so that there is more of a separation
20 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21 * the low-level tty routines (serial.c, pty.c, console.c). This
Alan Cox37bdfb02008-02-08 04:18:47 -080022 * makes for cleaner and more compact code. -TYT, 9/17/92
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 *
24 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25 * which can be dynamically activated and de-activated by the line
26 * discipline handling modules (like SLIP).
27 *
28 * NOTE: pay no attention to the line discipline code (yet); its
29 * interface is still subject to change in this version...
30 * -- TYT, 1/31/92
31 *
32 * Added functionality to the OPOST tty handling. No delays, but all
33 * other bits should be there.
34 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
35 *
36 * Rewrote canonical mode and added more termios flags.
37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38 *
39 * Reorganized FASYNC support so mouse code can share it.
40 * -- ctm@ardi.com, 9Sep95
41 *
42 * New TIOCLINUX variants added.
43 * -- mj@k332.feld.cvut.cz, 19-Nov-95
Alan Cox37bdfb02008-02-08 04:18:47 -080044 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * Restrict vt switching via ioctl()
46 * -- grif@cs.ucr.edu, 5-Dec-95
47 *
48 * Move console and virtual terminal code to more appropriate files,
49 * implement CONFIG_VT and generalize console device interface.
50 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
51 *
Alan Coxd81ed102008-10-13 10:41:42 +010052 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 * -- Bill Hawes <whawes@star.net>, June 97
54 *
55 * Added devfs support.
56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
57 *
58 * Added support for a Unix98-style ptmx device.
59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
60 *
61 * Reduced memory usage for older ARM systems
62 * -- Russell King <rmk@arm.linux.org.uk>
63 *
64 * Move do_SAK() into process context. Less stack use in devfs functions.
Alan Cox37bdfb02008-02-08 04:18:47 -080065 * alloc_tty_struct() always uses kmalloc()
66 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 */
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/types.h>
70#include <linux/major.h>
71#include <linux/errno.h>
72#include <linux/signal.h>
73#include <linux/fcntl.h>
74#include <linux/sched.h>
75#include <linux/interrupt.h>
76#include <linux/tty.h>
77#include <linux/tty_driver.h>
78#include <linux/tty_flip.h>
79#include <linux/devpts_fs.h>
80#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040081#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#include <linux/console.h>
83#include <linux/timer.h>
84#include <linux/ctype.h>
85#include <linux/kd.h>
86#include <linux/mm.h>
87#include <linux/string.h>
88#include <linux/slab.h>
89#include <linux/poll.h>
90#include <linux/proc_fs.h>
91#include <linux/init.h>
92#include <linux/module.h>
93#include <linux/smp_lock.h>
94#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#include <linux/wait.h>
96#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070097#include <linux/delay.h>
Alan Coxa352def2008-07-16 21:53:12 +010098#include <linux/seq_file.h>
Alan Coxd281da72010-09-16 18:21:24 +010099#include <linux/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Alan Coxa352def2008-07-16 21:53:12 +0100101#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102#include <asm/system.h>
103
104#include <linux/kbd_kern.h>
105#include <linux/vt_kern.h>
106#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108#include <linux/kmod.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700109#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111#undef TTY_DEBUG_HANGUP
112
113#define TTY_PARANOIA_CHECK 1
114#define CHECK_TTY_COUNT 1
115
Alan Coxedc6afc2006-12-08 02:38:44 -0800116struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 .c_iflag = ICRNL | IXON,
118 .c_oflag = OPOST | ONLCR,
119 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
120 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
121 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800122 .c_cc = INIT_C_CC,
123 .c_ispeed = 38400,
124 .c_ospeed = 38400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125};
126
127EXPORT_SYMBOL(tty_std_termios);
128
129/* This list gets poked at by procfs and various bits of boot up code. This
130 could do with some rationalisation such as pulling the tty proc function
131 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133LIST_HEAD(tty_drivers); /* linked list of tty drivers */
134
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800135/* Mutex to protect creating and releasing a tty. This is shared with
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 vt.c for deeply disgusting hack reasons */
Ingo Molnar70522e12006-03-23 03:00:31 -0800137DEFINE_MUTEX(tty_mutex);
Alan Coxde2a84f2006-09-29 02:00:57 -0700138EXPORT_SYMBOL(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Nick Pigginee2ffa02010-08-18 04:37:35 +1000140/* Spinlock to protect the tty->tty_files list */
141DEFINE_SPINLOCK(tty_files_lock);
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
144static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800145ssize_t redirected_tty_write(struct file *, const char __user *,
146 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147static unsigned int tty_poll(struct file *, poll_table *);
148static int tty_open(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700149long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700150#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800151static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700152 unsigned long arg);
153#else
154#define tty_compat_ioctl NULL
155#endif
Arnd Bergmannec79d602010-06-01 22:53:01 +0200156static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800157static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800158static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700159static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700160static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
Alan Coxaf9b8972006-08-27 01:24:01 -0700162/**
163 * alloc_tty_struct - allocate a tty object
164 *
165 * Return a new empty tty structure. The data fields have not
166 * been initialized in any way but has been zeroed
167 *
168 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700169 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Alan Coxbf970ee2008-10-13 10:42:39 +0100171struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172{
Alan Cox1266b1e2006-09-29 02:00:40 -0700173 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174}
175
Alan Coxaf9b8972006-08-27 01:24:01 -0700176/**
177 * free_tty_struct - free a disused tty
178 * @tty: tty struct to free
179 *
180 * Free the write buffers, tty queue and tty memory itself.
181 *
182 * Locking: none. Must be called after tty is definitely unused
183 */
184
Alan Coxbf970ee2008-10-13 10:42:39 +0100185void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +0400187 if (tty->dev)
188 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800190 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 kfree(tty);
192}
193
Nick Piggind996b622010-08-18 04:37:36 +1000194static inline struct tty_struct *file_tty(struct file *file)
195{
196 return ((struct tty_file_private *)file->private_data)->tty;
197}
198
199/* Associate a new file with the tty structure */
Pekka Enbergf573bd12010-08-24 07:48:34 +0300200int tty_add_file(struct tty_struct *tty, struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000201{
202 struct tty_file_private *priv;
203
Pekka Enbergf573bd12010-08-24 07:48:34 +0300204 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
205 if (!priv)
206 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000207
208 priv->tty = tty;
209 priv->file = file;
210 file->private_data = priv;
211
212 spin_lock(&tty_files_lock);
213 list_add(&priv->list, &tty->tty_files);
214 spin_unlock(&tty_files_lock);
Pekka Enbergf573bd12010-08-24 07:48:34 +0300215
216 return 0;
Nick Piggind996b622010-08-18 04:37:36 +1000217}
218
219/* Delete file from its tty */
220void tty_del_file(struct file *file)
221{
222 struct tty_file_private *priv = file->private_data;
223
224 spin_lock(&tty_files_lock);
225 list_del(&priv->list);
226 spin_unlock(&tty_files_lock);
227 file->private_data = NULL;
228 kfree(priv);
229}
230
231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
233
Alan Coxaf9b8972006-08-27 01:24:01 -0700234/**
235 * tty_name - return tty naming
236 * @tty: tty structure
237 * @buf: buffer for output
238 *
239 * Convert a tty structure into a name. The name reflects the kernel
240 * naming policy and if udev is in use may not reflect user space
241 *
242 * Locking: none
243 */
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245char *tty_name(struct tty_struct *tty, char *buf)
246{
247 if (!tty) /* Hmm. NULL pointer. That's fun. */
248 strcpy(buf, "NULL tty");
249 else
250 strcpy(buf, tty->name);
251 return buf;
252}
253
254EXPORT_SYMBOL(tty_name);
255
Andrew Mortond769a662005-05-05 16:15:50 -0700256int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 const char *routine)
258{
259#ifdef TTY_PARANOIA_CHECK
260 if (!tty) {
261 printk(KERN_WARNING
262 "null TTY for (%d:%d) in %s\n",
263 imajor(inode), iminor(inode), routine);
264 return 1;
265 }
266 if (tty->magic != TTY_MAGIC) {
267 printk(KERN_WARNING
268 "bad magic number for tty struct (%d:%d) in %s\n",
269 imajor(inode), iminor(inode), routine);
270 return 1;
271 }
272#endif
273 return 0;
274}
275
276static int check_tty_count(struct tty_struct *tty, const char *routine)
277{
278#ifdef CHECK_TTY_COUNT
279 struct list_head *p;
280 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800281
Nick Pigginee2ffa02010-08-18 04:37:35 +1000282 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 list_for_each(p, &tty->tty_files) {
284 count++;
285 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000286 spin_unlock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
288 tty->driver->subtype == PTY_TYPE_SLAVE &&
289 tty->link && tty->link->count)
290 count++;
291 if (tty->count != count) {
292 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
293 "!= #fd's(%d) in %s\n",
294 tty->name, tty->count, count, routine);
295 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800296 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297#endif
298 return 0;
299}
300
Alan Coxaf9b8972006-08-27 01:24:01 -0700301/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700302 * get_tty_driver - find device of a tty
303 * @dev_t: device identifier
304 * @index: returns the index of the tty
305 *
306 * This routine returns a tty driver structure, given a device number
307 * and also passes back the index number.
308 *
309 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312static struct tty_driver *get_tty_driver(dev_t device, int *index)
313{
314 struct tty_driver *p;
315
316 list_for_each_entry(p, &tty_drivers, tty_drivers) {
317 dev_t base = MKDEV(p->major, p->minor_start);
318 if (device < base || device >= base + p->num)
319 continue;
320 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100321 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 }
323 return NULL;
324}
325
Jason Wesself2d937f2008-04-17 20:05:37 +0200326#ifdef CONFIG_CONSOLE_POLL
327
328/**
329 * tty_find_polling_driver - find device of a polled tty
330 * @name: name string to match
331 * @line: pointer to resulting tty line nr
332 *
333 * This routine returns a tty driver structure, given a name
334 * and the condition that the tty driver is capable of polled
335 * operation.
336 */
337struct tty_driver *tty_find_polling_driver(char *name, int *line)
338{
339 struct tty_driver *p, *res = NULL;
340 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500341 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100342 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200343
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500344 for (str = name; *str; str++)
345 if ((*str >= '0' && *str <= '9') || *str == ',')
346 break;
347 if (!*str)
348 return NULL;
349
350 len = str - name;
351 tty_line = simple_strtoul(str, &str, 10);
352
Jason Wesself2d937f2008-04-17 20:05:37 +0200353 mutex_lock(&tty_mutex);
354 /* Search through the tty devices to look for a match */
355 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500356 if (strncmp(name, p->name, len) != 0)
357 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100358 stp = str;
359 if (*stp == ',')
360 stp++;
361 if (*stp == '\0')
362 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200363
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200364 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100365 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100366 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200367 *line = tty_line;
368 break;
369 }
370 }
371 mutex_unlock(&tty_mutex);
372
373 return res;
374}
375EXPORT_SYMBOL_GPL(tty_find_polling_driver);
376#endif
377
Alan Coxaf9b8972006-08-27 01:24:01 -0700378/**
379 * tty_check_change - check for POSIX terminal changes
380 * @tty: tty to check
381 *
382 * If we try to write to, or set the state of, a terminal and we're
383 * not in the foreground, send a SIGTTOU. If the signal is blocked or
384 * ignored, go ahead and perform the operation. (POSIX 7.2)
385 *
Alan Cox978e5952008-04-30 00:53:59 -0700386 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700388
Alan Cox37bdfb02008-02-08 04:18:47 -0800389int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390{
Alan Cox47f86832008-04-30 00:53:30 -0700391 unsigned long flags;
392 int ret = 0;
393
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 if (current->signal->tty != tty)
395 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700396
397 spin_lock_irqsave(&tty->ctrl_lock, flags);
398
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800399 if (!tty->pgrp) {
400 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700401 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800403 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700404 goto out_unlock;
405 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700407 goto out;
408 if (is_current_pgrp_orphaned()) {
409 ret = -EIO;
410 goto out;
411 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700412 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
413 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700414 ret = -ERESTARTSYS;
415out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700416 return ret;
417out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700418 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
419 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420}
421
422EXPORT_SYMBOL(tty_check_change);
423
Alan Cox37bdfb02008-02-08 04:18:47 -0800424static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 size_t count, loff_t *ppos)
426{
427 return 0;
428}
429
Alan Cox37bdfb02008-02-08 04:18:47 -0800430static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 size_t count, loff_t *ppos)
432{
433 return -EIO;
434}
435
436/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800437static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
440}
441
Alan Cox04f378b2008-04-30 00:53:29 -0700442static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
443 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700444{
445 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
446}
447
Alan Cox37bdfb02008-02-08 04:18:47 -0800448static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700449 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450{
451 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
452}
453
Arjan van de Ven62322d22006-07-03 00:24:21 -0700454static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 .llseek = no_llseek,
456 .read = tty_read,
457 .write = tty_write,
458 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700459 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700460 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 .open = tty_open,
462 .release = tty_release,
463 .fasync = tty_fasync,
464};
465
Arjan van de Ven62322d22006-07-03 00:24:21 -0700466static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 .llseek = no_llseek,
468 .read = tty_read,
469 .write = redirected_tty_write,
470 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700471 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700472 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 .open = tty_open,
474 .release = tty_release,
475 .fasync = tty_fasync,
476};
477
Arjan van de Ven62322d22006-07-03 00:24:21 -0700478static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 .llseek = no_llseek,
480 .read = hung_up_tty_read,
481 .write = hung_up_tty_write,
482 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700483 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700484 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 .release = tty_release,
486};
487
488static DEFINE_SPINLOCK(redirect_lock);
489static struct file *redirect;
490
491/**
492 * tty_wakeup - request more data
493 * @tty: terminal
494 *
495 * Internal and external helper for wakeups of tty. This function
496 * informs the line discipline if present that the driver is ready
497 * to receive more output data.
498 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500void tty_wakeup(struct tty_struct *tty)
501{
502 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
505 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800506 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100507 if (ld->ops->write_wakeup)
508 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 tty_ldisc_deref(ld);
510 }
511 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700512 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513}
514
515EXPORT_SYMBOL_GPL(tty_wakeup);
516
517/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200518 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000519 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700520 *
Alan Cox1bad8792008-07-22 23:38:04 +0100521 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700522 * synchronous but doesn't hold any locks, so we need to make sure we
523 * have the appropriate locks for what we're doing.
524 *
525 * The hangup event clears any pending redirections onto the hung up
526 * device. It ensures future writes will error and it does the needed
527 * line discipline hangup and signal delivery. The tty object itself
528 * remains intact.
529 *
530 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200531 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800532 * redirect lock for undoing redirection
533 * file list lock for manipulating list of ttys
534 * tty_ldisc_lock from called functions
535 * termios_mutex resetting termios data
536 * tasklist_lock to walk task list for hangup event
537 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200539void __tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
Alan Cox37bdfb02008-02-08 04:18:47 -0800541 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 struct file *filp, *f = NULL;
543 struct task_struct *p;
Nick Piggind996b622010-08-18 04:37:36 +1000544 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700546 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100547 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
549 if (!tty)
550 return;
551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
553 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000554 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 f = redirect;
556 redirect = NULL;
557 }
558 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800559
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200560 tty_lock();
561
Arnd Bergmannec79d602010-06-01 22:53:01 +0200562 /* inuse_filps is protected by the single tty lock,
563 this really needs to change if we want to flush the
564 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200565 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000566
Nick Pigginee2ffa02010-08-18 04:37:35 +1000567 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000569 list_for_each_entry(priv, &tty->tty_files, list) {
570 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 if (filp->f_op->write == redirected_tty_write)
572 cons_filp = filp;
573 if (filp->f_op->write != tty_write)
574 continue;
575 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200576 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 filp->f_op = &hung_up_tty_fops;
578 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000579 spin_unlock(&tty_files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800580
Alan Coxc65c9bc2009-06-11 12:50:12 +0100581 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800584 if (tty->session) {
585 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800586 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100587 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100589 /* We defer the dereferences outside fo
590 the tasklist lock */
591 refs++;
592 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800593 if (!p->signal->leader) {
594 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800596 }
597 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
598 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800599 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700600 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800601 if (tty->pgrp)
602 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700603 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800604 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800605 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 }
607 read_unlock(&tasklist_lock);
608
Alan Cox47f86832008-04-30 00:53:30 -0700609 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100610 clear_bit(TTY_THROTTLED, &tty->flags);
611 clear_bit(TTY_PUSH, &tty->flags);
612 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600613 put_pid(tty->session);
614 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800615 tty->session = NULL;
616 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 tty->ctrl_status = 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100618 set_bit(TTY_HUPPED, &tty->flags);
Alan Cox47f86832008-04-30 00:53:30 -0700619 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
620
Alan Cox9c9f4de2008-10-13 10:37:26 +0100621 /* Account for the p->signal references we killed */
622 while (refs--)
623 tty_kref_put(tty);
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800626 * If one of the devices matches a console pointer, we
627 * cannot just call hangup() because that will cause
628 * tty->count and state->count to go out of sync.
629 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 */
631 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700632 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700634 tty->ops->close(tty, cons_filp);
635 } else if (tty->ops->hangup)
636 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800637 /*
638 * We don't want to have driver/ldisc interactions beyond
639 * the ones we did here. The driver layer expects no
640 * calls after ->hangup() from the ldisc side. However we
641 * can't yet guarantee all that.
642 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 set_bit(TTY_HUPPED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100644 tty_ldisc_enable(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200645
646 tty_unlock();
647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (f)
649 fput(f);
650}
651
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200652static void do_tty_hangup(struct work_struct *work)
653{
654 struct tty_struct *tty =
655 container_of(work, struct tty_struct, hangup_work);
656
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200657 __tty_hangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200658}
659
Alan Coxaf9b8972006-08-27 01:24:01 -0700660/**
661 * tty_hangup - trigger a hangup event
662 * @tty: tty to hangup
663 *
664 * A carrier loss (virtual or otherwise) has occurred on this like
665 * schedule a hangup sequence to run after this event.
666 */
667
Alan Cox37bdfb02008-02-08 04:18:47 -0800668void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
670#ifdef TTY_DEBUG_HANGUP
671 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
673#endif
674 schedule_work(&tty->hangup_work);
675}
676
677EXPORT_SYMBOL(tty_hangup);
678
Alan Coxaf9b8972006-08-27 01:24:01 -0700679/**
680 * tty_vhangup - process vhangup
681 * @tty: tty to hangup
682 *
683 * The user has asked via system call for the terminal to be hung up.
684 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200685 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700686 */
687
Alan Cox37bdfb02008-02-08 04:18:47 -0800688void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689{
690#ifdef TTY_DEBUG_HANGUP
691 char buf[64];
692
693 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
694#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200695 __tty_hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
Alan Cox37bdfb02008-02-08 04:18:47 -0800697
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698EXPORT_SYMBOL(tty_vhangup);
699
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200700
Alan Coxaf9b8972006-08-27 01:24:01 -0700701/**
Alan Cox2cb59982008-10-13 10:40:30 +0100702 * tty_vhangup_self - process vhangup for own ctty
703 *
704 * Perform a vhangup on the current controlling tty
705 */
706
707void tty_vhangup_self(void)
708{
709 struct tty_struct *tty;
710
Alan Cox2cb59982008-10-13 10:40:30 +0100711 tty = get_current_tty();
712 if (tty) {
713 tty_vhangup(tty);
714 tty_kref_put(tty);
715 }
Alan Cox2cb59982008-10-13 10:40:30 +0100716}
717
718/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700719 * tty_hung_up_p - was tty hung up
720 * @filp: file pointer of tty
721 *
722 * Return true if the tty has been subject to a vhangup or a carrier
723 * loss
724 */
725
Alan Cox37bdfb02008-02-08 04:18:47 -0800726int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727{
728 return (filp->f_op == &hung_up_tty_fops);
729}
730
731EXPORT_SYMBOL(tty_hung_up_p);
732
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800733static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800734{
735 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800736 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800737 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800738 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800739}
740
Alan Coxaf9b8972006-08-27 01:24:01 -0700741/**
742 * disassociate_ctty - disconnect controlling tty
743 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700745 * This function is typically called only by the session leader, when
746 * it wants to disassociate itself from its controlling tty.
747 *
748 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
750 * (2) Clears the tty from being controlling the session
751 * (3) Clears the controlling tty for all processes in the
752 * session group.
753 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700754 * The argument on_exit is set to 1 if called when a process is
755 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
756 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800757 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200758 * BTM is taken for hysterical raisins, and held when
759 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800760 * tty_mutex is taken to protect tty
761 * ->siglock is taken to protect ->signal/->sighand
762 * tasklist_lock is taken to walk process list for sessions
763 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700765
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766void disassociate_ctty(int on_exit)
767{
768 struct tty_struct *tty;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800769 struct pid *tty_pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
Alan Cox5ec93d12009-11-30 13:18:45 +0000771 if (!current->signal->leader)
772 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800774 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 if (tty) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800776 tty_pgrp = get_pid(tty->pgrp);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200777 if (on_exit) {
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200778 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200779 tty_vhangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200780 }
Alan Cox452a00d2008-10-13 10:39:13 +0100781 tty_kref_put(tty);
Eric W. Biederman680a9672007-02-12 00:52:52 -0800782 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800783 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800784 spin_lock_irq(&current->sighand->siglock);
785 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800786 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800787 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800788 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800789 kill_pgrp(old_pgrp, SIGHUP, on_exit);
790 kill_pgrp(old_pgrp, SIGCONT, on_exit);
791 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 return;
794 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800795 if (tty_pgrp) {
796 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 if (!on_exit)
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800798 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
799 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 }
801
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800802 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700803 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800804 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800805 spin_unlock_irq(&current->sighand->siglock);
806
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800807 tty = get_current_tty();
808 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700809 unsigned long flags;
810 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800811 put_pid(tty->session);
812 put_pid(tty->pgrp);
813 tty->session = NULL;
814 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700815 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100816 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800817 } else {
818#ifdef TTY_DEBUG_HANGUP
819 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
820 " = NULL", tty);
821#endif
822 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
824 /* Now clear signal->tty under the lock */
825 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800826 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828}
829
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700830/**
831 *
832 * no_tty - Ensure the current process does not have a controlling tty
833 */
834void no_tty(void)
835{
836 struct task_struct *tsk = current;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200837 tty_lock();
Alan Cox5ec93d12009-11-30 13:18:45 +0000838 disassociate_ctty(0);
Arnd Bergmannec79d602010-06-01 22:53:01 +0200839 tty_unlock();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700840 proc_clear_tty(tsk);
841}
842
Alan Coxaf9b8972006-08-27 01:24:01 -0700843
844/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200845 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700846 * @tty: tty to stop
847 *
848 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200849 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700850 * on an already stopped device and will not re-call the driver
851 * method.
852 *
853 * This functionality is used by both the line disciplines for
854 * halting incoming flow and by the driver. It may therefore be
855 * called from any context, may be under the tty atomic_write_lock
856 * but not always.
857 *
858 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700859 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700860 */
861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862void stop_tty(struct tty_struct *tty)
863{
Alan Cox04f378b2008-04-30 00:53:29 -0700864 unsigned long flags;
865 spin_lock_irqsave(&tty->ctrl_lock, flags);
866 if (tty->stopped) {
867 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700869 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 tty->stopped = 1;
871 if (tty->link && tty->link->packet) {
872 tty->ctrl_status &= ~TIOCPKT_START;
873 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700874 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 }
Alan Cox04f378b2008-04-30 00:53:29 -0700876 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700877 if (tty->ops->stop)
878 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879}
880
881EXPORT_SYMBOL(stop_tty);
882
Alan Coxaf9b8972006-08-27 01:24:01 -0700883/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200884 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700885 * @tty: tty to start
886 *
887 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200888 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700889 * is the tty was previous stopped and is being started then the
890 * driver start method is invoked and the line discipline woken.
891 *
892 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700893 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700894 */
895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896void start_tty(struct tty_struct *tty)
897{
Alan Cox04f378b2008-04-30 00:53:29 -0700898 unsigned long flags;
899 spin_lock_irqsave(&tty->ctrl_lock, flags);
900 if (!tty->stopped || tty->flow_stopped) {
901 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700903 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 tty->stopped = 0;
905 if (tty->link && tty->link->packet) {
906 tty->ctrl_status &= ~TIOCPKT_STOP;
907 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700908 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 }
Alan Cox04f378b2008-04-30 00:53:29 -0700910 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700911 if (tty->ops->start)
912 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 /* If we have a running line discipline it may need kicking */
914 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915}
916
917EXPORT_SYMBOL(start_tty);
918
Alan Coxaf9b8972006-08-27 01:24:01 -0700919/**
920 * tty_read - read method for tty device files
921 * @file: pointer to tty file
922 * @buf: user buffer
923 * @count: size of user buffer
924 * @ppos: unused
925 *
926 * Perform the read system call function on this terminal device. Checks
927 * for hung up devices before calling the line discipline method.
928 *
929 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700930 * Locks the line discipline internally while needed. Multiple
931 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700932 */
933
Alan Cox37bdfb02008-02-08 04:18:47 -0800934static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 loff_t *ppos)
936{
937 int i;
Nick Piggind996b622010-08-18 04:37:36 +1000938 struct inode *inode = file->f_path.dentry->d_inode;
939 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 struct tty_ldisc *ld;
941
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (tty_paranoia_check(tty, inode, "tty_read"))
943 return -EIO;
944 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
945 return -EIO;
946
947 /* We want to wait for the line discipline to sort out in this
948 situation */
949 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100950 if (ld->ops->read)
951 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 else
953 i = -EIO;
954 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 if (i > 0)
956 inode->i_atime = current_fs_time(inode->i_sb);
957 return i;
958}
959
Alan Cox9c1729d2007-07-15 23:39:43 -0700960void tty_write_unlock(struct tty_struct *tty)
961{
962 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700963 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700964}
965
966int tty_write_lock(struct tty_struct *tty, int ndelay)
967{
968 if (!mutex_trylock(&tty->atomic_write_lock)) {
969 if (ndelay)
970 return -EAGAIN;
971 if (mutex_lock_interruptible(&tty->atomic_write_lock))
972 return -ERESTARTSYS;
973 }
974 return 0;
975}
976
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977/*
978 * Split writes up in sane blocksizes to avoid
979 * denial-of-service type attacks
980 */
981static inline ssize_t do_tty_write(
982 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
983 struct tty_struct *tty,
984 struct file *file,
985 const char __user *buf,
986 size_t count)
987{
Alan Cox9c1729d2007-07-15 23:39:43 -0700988 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -0800990
Alan Cox9c1729d2007-07-15 23:39:43 -0700991 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
992 if (ret < 0)
993 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
995 /*
996 * We chunk up writes into a temporary buffer. This
997 * simplifies low-level drivers immensely, since they
998 * don't have locking issues and user mode accesses.
999 *
1000 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1001 * big chunk-size..
1002 *
1003 * The default chunk-size is 2kB, because the NTTY
1004 * layer has problems with bigger chunks. It will
1005 * claim to be able to handle more characters than
1006 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001007 *
1008 * FIXME: This can probably go away now except that 64K chunks
1009 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 */
1011 chunk = 2048;
1012 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1013 chunk = 65536;
1014 if (count < chunk)
1015 chunk = count;
1016
Ingo Molnar70522e12006-03-23 03:00:31 -08001017 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001019 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
1021 if (chunk < 1024)
1022 chunk = 1024;
1023
Jason Wessel402fda92008-10-13 10:45:36 +01001024 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1025 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001026 ret = -ENOMEM;
1027 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 }
1029 kfree(tty->write_buf);
1030 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001031 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 }
1033
1034 /* Do the write .. */
1035 for (;;) {
1036 size_t size = count;
1037 if (size > chunk)
1038 size = chunk;
1039 ret = -EFAULT;
1040 if (copy_from_user(tty->write_buf, buf, size))
1041 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 if (ret <= 0)
1044 break;
1045 written += ret;
1046 buf += ret;
1047 count -= ret;
1048 if (!count)
1049 break;
1050 ret = -ERESTARTSYS;
1051 if (signal_pending(current))
1052 break;
1053 cond_resched();
1054 }
1055 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001056 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 inode->i_mtime = current_fs_time(inode->i_sb);
1058 ret = written;
1059 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001060out:
1061 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 return ret;
1063}
1064
Alan Cox95f9bfc2008-10-13 10:39:23 +01001065/**
1066 * tty_write_message - write a message to a certain tty, not just the console.
1067 * @tty: the destination tty_struct
1068 * @msg: the message to write
1069 *
1070 * This is used for messages that need to be redirected to a specific tty.
1071 * We don't put it into the syslog queue right now maybe in the future if
1072 * really needed.
1073 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001074 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001075 */
1076
1077void tty_write_message(struct tty_struct *tty, char *msg)
1078{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001079 if (tty) {
1080 mutex_lock(&tty->atomic_write_lock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001081 tty_lock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001082 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001083 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001084 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001085 } else
Arnd Bergmannec79d602010-06-01 22:53:01 +02001086 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001087 tty_write_unlock(tty);
1088 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001089 return;
1090}
1091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
Alan Coxaf9b8972006-08-27 01:24:01 -07001093/**
1094 * tty_write - write method for tty device file
1095 * @file: tty file pointer
1096 * @buf: user data to write
1097 * @count: bytes to write
1098 * @ppos: unused
1099 *
1100 * Write data to a tty device via the line discipline.
1101 *
1102 * Locking:
1103 * Locks the line discipline as required
1104 * Writes to the tty driver are serialized by the atomic_write_lock
1105 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001106 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001107 */
1108
Alan Cox37bdfb02008-02-08 04:18:47 -08001109static ssize_t tty_write(struct file *file, const char __user *buf,
1110 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111{
Josef Sipeka7113a92006-12-08 02:36:55 -08001112 struct inode *inode = file->f_path.dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10001113 struct tty_struct *tty = file_tty(file);
1114 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 if (tty_paranoia_check(tty, inode, "tty_write"))
1118 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001119 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001120 (test_bit(TTY_IO_ERROR, &tty->flags)))
1121 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001122 /* Short term debug to catch buggy drivers */
1123 if (tty->ops->write_room == NULL)
1124 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1125 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001126 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001127 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 ret = -EIO;
1129 else
Alan Coxa352def2008-07-16 21:53:12 +01001130 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 tty_ldisc_deref(ld);
1132 return ret;
1133}
1134
Alan Cox37bdfb02008-02-08 04:18:47 -08001135ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1136 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137{
1138 struct file *p = NULL;
1139
1140 spin_lock(&redirect_lock);
1141 if (redirect) {
1142 get_file(redirect);
1143 p = redirect;
1144 }
1145 spin_unlock(&redirect_lock);
1146
1147 if (p) {
1148 ssize_t res;
1149 res = vfs_write(p, buf, count, &p->f_pos);
1150 fput(p);
1151 return res;
1152 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 return tty_write(file, buf, count, ppos);
1154}
1155
1156static char ptychar[] = "pqrstuvwxyzabcde";
1157
Alan Coxaf9b8972006-08-27 01:24:01 -07001158/**
1159 * pty_line_name - generate name for a pty
1160 * @driver: the tty driver in use
1161 * @index: the minor number
1162 * @p: output buffer of at least 6 bytes
1163 *
1164 * Generate a name from a driver reference and write it to the output
1165 * buffer.
1166 *
1167 * Locking: None
1168 */
1169static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170{
1171 int i = index + driver->name_base;
1172 /* ->name is initialized to "ttyp", but "tty" is expected */
1173 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001174 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1175 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176}
1177
Alan Coxaf9b8972006-08-27 01:24:01 -07001178/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001179 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001180 * @driver: the tty driver in use
1181 * @index: the minor number
1182 * @p: output buffer of at least 7 bytes
1183 *
1184 * Generate a name from a driver reference and write it to the output
1185 * buffer.
1186 *
1187 * Locking: None
1188 */
1189static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190{
1191 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1192}
1193
Alan Cox99f1fe12008-10-13 10:42:00 +01001194/**
1195 * tty_driver_lookup_tty() - find an existing tty, if any
1196 * @driver: the driver for the tty
1197 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001198 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001199 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001200 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001201 * Locking: tty_mutex must be held. If tty is found, the mutex must
1202 * be held until the 'fast-open' is also done. Will change once we
1203 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001204 */
Jason Wessela47d5452009-01-02 13:43:04 +00001205static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001206 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001207{
1208 struct tty_struct *tty;
1209
Alan Cox99f1fe12008-10-13 10:42:00 +01001210 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001211 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001212
Alan Cox8b0a88d2008-10-13 10:42:19 +01001213 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001214 return tty;
1215}
1216
Alan Cox99f1fe12008-10-13 10:42:00 +01001217/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001218 * tty_init_termios - helper for termios setup
1219 * @tty: the tty to set up
1220 *
1221 * Initialise the termios structures for this tty. Thus runs under
1222 * the tty_mutex currently so we can be relaxed about ordering.
1223 */
1224
1225int tty_init_termios(struct tty_struct *tty)
1226{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001227 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001228 int idx = tty->index;
1229
1230 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001231 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001232 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1233 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001234 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001235 memcpy(tp, &tty->driver->init_termios,
1236 sizeof(struct ktermios));
1237 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001238 }
1239 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001240 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001241
1242 /* Compatibility until drivers always set this */
1243 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1244 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1245 return 0;
1246}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001247EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001248
1249/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001250 * tty_driver_install_tty() - install a tty entry in the driver
1251 * @driver: the driver for the tty
1252 * @tty: the tty
1253 *
1254 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001255 * will be set by the time this is called. This method is responsible
1256 * for ensuring any need additional structures are allocated and
1257 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001258 *
1259 * Locking: tty_mutex for now
1260 */
1261static int tty_driver_install_tty(struct tty_driver *driver,
1262 struct tty_struct *tty)
1263{
Alan Coxbf970ee2008-10-13 10:42:39 +01001264 int idx = tty->index;
Alan Coxeeb89d92009-11-30 13:18:29 +00001265 int ret;
Alan Coxbf970ee2008-10-13 10:42:39 +01001266
Alan Coxeeb89d92009-11-30 13:18:29 +00001267 if (driver->ops->install) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001268 ret = driver->ops->install(driver, tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001269 return ret;
1270 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001271
1272 if (tty_init_termios(tty) == 0) {
1273 tty_driver_kref_get(driver);
1274 tty->count++;
1275 driver->ttys[idx] = tty;
1276 return 0;
1277 }
1278 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001279}
1280
1281/**
1282 * tty_driver_remove_tty() - remove a tty from the driver tables
1283 * @driver: the driver for the tty
1284 * @idx: the minor number
1285 *
1286 * Remvoe a tty object from the driver tables. The tty->index field
1287 * will be set by the time this is called.
1288 *
1289 * Locking: tty_mutex for now
1290 */
1291static void tty_driver_remove_tty(struct tty_driver *driver,
1292 struct tty_struct *tty)
1293{
1294 if (driver->ops->remove)
1295 driver->ops->remove(driver, tty);
1296 else
1297 driver->ttys[tty->index] = NULL;
1298}
1299
1300/*
1301 * tty_reopen() - fast re-open of an open tty
1302 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001303 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001304 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001305 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001306 * Locking: tty_mutex must be held from the time the tty was found
1307 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001308 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001309static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001310{
1311 struct tty_driver *driver = tty->driver;
1312
1313 if (test_bit(TTY_CLOSING, &tty->flags))
1314 return -EIO;
1315
1316 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1317 driver->subtype == PTY_TYPE_MASTER) {
1318 /*
1319 * special case for PTY masters: only one open permitted,
1320 * and the slave side open count is incremented as well.
1321 */
1322 if (tty->count)
1323 return -EIO;
1324
1325 tty->link->count++;
1326 }
1327 tty->count++;
1328 tty->driver = driver; /* N.B. why do this every time?? */
1329
Alan Cox1aa4bed2009-06-16 17:01:33 +01001330 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001331 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001332 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001333
1334 return 0;
1335}
1336
Alan Coxaf9b8972006-08-27 01:24:01 -07001337/**
Alan Coxd81ed102008-10-13 10:41:42 +01001338 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001339 * @driver: tty driver we are opening a device on
1340 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001341 * @ret_tty: returned tty structure
1342 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001343 *
1344 * Prepare a tty device. This may not be a "new" clean device but
1345 * could also be an active device. The pty drivers require special
1346 * handling because of this.
1347 *
1348 * Locking:
1349 * The function is called under the tty_mutex, which
1350 * protects us from the tty struct or driver itself going away.
1351 *
1352 * On exit the tty device has the line discipline attached and
1353 * a reference count of 1. If a pair was created for pty/tty use
1354 * and the other was a pty master then it too has a reference count of 1.
1355 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001357 * failed open. The new code protects the open with a mutex, so it's
1358 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 * relaxed for the (most common) case of reopening a tty.
1360 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001361
Alan Cox73ec06f2008-10-13 10:42:29 +01001362struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1363 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364{
Alan Coxbf970ee2008-10-13 10:42:39 +01001365 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001366 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001368 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001369 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Coxeeb89d92009-11-30 13:18:29 +00001370 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {
Alan Cox73ec06f2008-10-13 10:42:29 +01001371 return ERR_PTR(-EIO);
Alan Coxeeb89d92009-11-30 13:18:29 +00001372 }
Alan Cox73ec06f2008-10-13 10:42:29 +01001373
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 /*
1375 * First time open is complex, especially for PTY devices.
1376 * This code guarantees that either everything succeeds and the
1377 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001378 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 * and locked termios may be retained.)
1380 */
1381
Alan Cox73ec06f2008-10-13 10:42:29 +01001382 if (!try_module_get(driver->owner))
1383 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 tty = alloc_tty_struct();
Alan Cox37bdfb02008-02-08 04:18:47 -08001386 if (!tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 goto fail_no_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +01001388 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Alan Cox73ec06f2008-10-13 10:42:29 +01001390 retval = tty_driver_install_tty(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001391 if (retval < 0) {
1392 free_tty_struct(tty);
1393 module_put(driver->owner);
1394 return ERR_PTR(retval);
1395 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001396
Alan Cox37bdfb02008-02-08 04:18:47 -08001397 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001399 * If we fail here just call release_tty to clean up. No need
1400 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001402 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001403 if (retval)
1404 goto release_mem_out;
Alan Cox73ec06f2008-10-13 10:42:29 +01001405 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407fail_no_mem:
1408 module_put(driver->owner);
Alan Cox73ec06f2008-10-13 10:42:29 +01001409 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001411 /* call the tty release_tty routine to clean out this slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412release_mem_out:
Akinobu Mita40509142006-09-29 02:01:27 -07001413 if (printk_ratelimit())
Alan Coxd81ed102008-10-13 10:41:42 +01001414 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001415 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001416 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001417 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418}
1419
Alan Coxfeebed62008-10-13 10:41:30 +01001420void tty_free_termios(struct tty_struct *tty)
1421{
1422 struct ktermios *tp;
1423 int idx = tty->index;
1424 /* Kill this flag and push into drivers for locking etc */
1425 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1426 /* FIXME: Locking on ->termios array */
1427 tp = tty->termios;
1428 tty->driver->termios[idx] = NULL;
1429 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001430 }
1431}
1432EXPORT_SYMBOL(tty_free_termios);
1433
1434void tty_shutdown(struct tty_struct *tty)
1435{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001436 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001437 tty_free_termios(tty);
1438}
1439EXPORT_SYMBOL(tty_shutdown);
1440
Alan Coxaf9b8972006-08-27 01:24:01 -07001441/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001442 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001443 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001444 *
1445 * Releases memory associated with a tty structure, and clears out the
1446 * driver table slots. This function is called when a device is no longer
1447 * in use. It also gets called when setup of a device fails.
1448 *
1449 * Locking:
1450 * tty_mutex - sometimes only
1451 * takes the file list lock internally when working on the list
1452 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001453 *
1454 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001455 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 */
Alan Coxb50989d2009-09-19 13:13:22 -07001457static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458{
Alan Coxb50989d2009-09-19 13:13:22 -07001459 struct tty_struct *tty =
1460 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001461 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
Dave Youngf278a2f2009-09-27 16:00:42 +00001463 if (tty->ops->cleanup)
1464 tty->ops->cleanup(tty);
1465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001467 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001468 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001469
Nick Pigginee2ffa02010-08-18 04:37:35 +10001470 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 list_del_init(&tty->tty_files);
Nick Pigginee2ffa02010-08-18 04:37:35 +10001472 spin_unlock(&tty_files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001473
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001474 put_pid(tty->pgrp);
1475 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 free_tty_struct(tty);
1477}
1478
Alan Coxb50989d2009-09-19 13:13:22 -07001479static void queue_release_one_tty(struct kref *kref)
1480{
1481 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001482
1483 if (tty->ops->shutdown)
1484 tty->ops->shutdown(tty);
1485 else
1486 tty_shutdown(tty);
1487
Alan Coxb50989d2009-09-19 13:13:22 -07001488 /* The hangup queue is now free so we can reuse it rather than
1489 waste a chunk of memory for each port */
1490 INIT_WORK(&tty->hangup_work, release_one_tty);
1491 schedule_work(&tty->hangup_work);
1492}
1493
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001494/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001495 * tty_kref_put - release a tty kref
1496 * @tty: tty device
1497 *
1498 * Release a reference to a tty device and if need be let the kref
1499 * layer destruct the object for us
1500 */
1501
1502void tty_kref_put(struct tty_struct *tty)
1503{
1504 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001505 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001506}
1507EXPORT_SYMBOL(tty_kref_put);
1508
1509/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001510 * release_tty - release tty structure memory
1511 *
1512 * Release both @tty and a possible linked partner (think pty pair),
1513 * and decrement the refcount of the backing module.
1514 *
1515 * Locking:
1516 * tty_mutex - sometimes only
1517 * takes the file list lock internally when working on the list
1518 * of ttys that the driver keeps.
1519 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001520 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001521 */
1522static void release_tty(struct tty_struct *tty, int idx)
1523{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001524 /* This should always be true but check for the moment */
1525 WARN_ON(tty->index != idx);
1526
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001527 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001528 tty_kref_put(tty->link);
1529 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001530}
1531
Alan Coxeeb89d92009-11-30 13:18:29 +00001532/**
1533 * tty_release - vfs callback for close
1534 * @inode: inode of tty
1535 * @filp: file pointer for handle to tty
1536 *
1537 * Called the last time each file handle is closed that references
1538 * this tty. There may however be several such references.
1539 *
1540 * Locking:
1541 * Takes bkl. See tty_release_dev
1542 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 * Even releasing the tty structures is a tricky business.. We have
1544 * to be very careful that the structures are all released at the
1545 * same time, as interrupts might otherwise get the wrong pointers.
1546 *
1547 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1548 * lead to double frees or releasing memory still in use.
1549 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001550
1551int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552{
Nick Piggind996b622010-08-18 04:37:36 +10001553 struct tty_struct *tty = file_tty(filp);
1554 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001556 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 int idx;
1558 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001559
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001560 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
Alan Coxeeb89d92009-11-30 13:18:29 +00001561 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562
Arnd Bergmannec79d602010-06-01 22:53:01 +02001563 tty_lock();
Alan Coxd81ed102008-10-13 10:41:42 +01001564 check_tty_count(tty, "tty_release_dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
Arnd Bergmannec79d602010-06-01 22:53:01 +02001566 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567
1568 idx = tty->index;
1569 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1570 tty->driver->subtype == PTY_TYPE_MASTER);
1571 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 o_tty = tty->link;
1573
1574#ifdef TTY_PARANOIA_CHECK
1575 if (idx < 0 || idx >= tty->driver->num) {
Alan Coxd81ed102008-10-13 10:41:42 +01001576 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 "free (%s)\n", tty->name);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001578 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001579 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001581 if (!devpts) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 if (tty != tty->driver->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001583 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001584 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 "for (%s)\n", idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001586 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 }
1588 if (tty->termios != tty->driver->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001589 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001590 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 "for (%s)\n",
1592 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001593 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 }
1596#endif
1597
1598#ifdef TTY_DEBUG_HANGUP
Alan Coxd81ed102008-10-13 10:41:42 +01001599 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 tty_name(tty, buf), tty->count);
1601#endif
1602
1603#ifdef TTY_PARANOIA_CHECK
1604 if (tty->driver->other &&
1605 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1606 if (o_tty != tty->driver->other->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001607 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001608 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 "not o_tty for (%s)\n",
1610 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001611 return 0 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 }
1613 if (o_tty->termios != tty->driver->other->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001614 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001615 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 "not o_termios for (%s)\n",
1617 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001618 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 if (o_tty->link != tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001621 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001622 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
Alan Coxeeb89d92009-11-30 13:18:29 +00001623 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 }
1625 }
1626#endif
Alan Coxf34d7a52008-04-30 00:54:13 -07001627 if (tty->ops->close)
1628 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
Arnd Bergmannec79d602010-06-01 22:53:01 +02001630 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 /*
1632 * Sanity check: if tty->count is going to zero, there shouldn't be
1633 * any waiters on tty->read_wait or tty->write_wait. We test the
1634 * wait queues and kick everyone out _before_ actually starting to
1635 * close. This ensures that we won't block while releasing the tty
1636 * structure.
1637 *
1638 * The test for the o_tty closing is necessary, since the master and
1639 * slave sides may close in any order. If the slave side closes out
1640 * first, its count will be one, since the master side holds an open.
1641 * Thus this test wouldn't be triggered at the time the slave closes,
1642 * so we do it now.
1643 *
1644 * Note that it's possible for the tty to be opened again while we're
1645 * flushing out waiters. By recalculating the closing flags before
1646 * each iteration we avoid any problems.
1647 */
1648 while (1) {
1649 /* Guard against races with tty->count changes elsewhere and
1650 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001651
Ingo Molnar70522e12006-03-23 03:00:31 -08001652 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001653 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 tty_closing = tty->count <= 1;
1655 o_tty_closing = o_tty &&
1656 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 do_sleep = 0;
1658
1659 if (tty_closing) {
1660 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001661 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 do_sleep++;
1663 }
1664 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001665 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 do_sleep++;
1667 }
1668 }
1669 if (o_tty_closing) {
1670 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001671 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 do_sleep++;
1673 }
1674 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001675 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 do_sleep++;
1677 }
1678 }
1679 if (!do_sleep)
1680 break;
1681
Alan Coxd81ed102008-10-13 10:41:42 +01001682 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 "active!\n", tty_name(tty, buf));
Arnd Bergmannec79d602010-06-01 22:53:01 +02001684 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001685 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001687 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
1689 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001690 * The closing flags are now consistent with the open counts on
1691 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 * block, so it's safe to proceed with closing.
1693 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 if (pty_master) {
1695 if (--o_tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001696 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 "(%d) for %s\n",
1698 o_tty->count, tty_name(o_tty, buf));
1699 o_tty->count = 0;
1700 }
1701 }
1702 if (--tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001703 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 tty->count, tty_name(tty, buf));
1705 tty->count = 0;
1706 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001707
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 /*
1709 * We've decremented tty->count, so we need to remove this file
1710 * descriptor off the tty->tty_files list; this serves two
1711 * purposes:
1712 * - check_tty_count sees the correct number of file descriptors
1713 * associated with this tty.
1714 * - do_tty_hangup no longer sees this file descriptor as
1715 * something that needs to be handled for hangups.
1716 */
Nick Piggind996b622010-08-18 04:37:36 +10001717 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
1719 /*
1720 * Perform some housekeeping before deciding whether to return.
1721 *
1722 * Set the TTY_CLOSING flag if this was the last open. In the
1723 * case of a pty we may have to wait around for the other side
1724 * to close, and TTY_CLOSING makes sure we can't be reopened.
1725 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001726 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001728 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 set_bit(TTY_CLOSING, &o_tty->flags);
1730
1731 /*
1732 * If _either_ side is closing, make sure there aren't any
1733 * processes that still think tty or o_tty is their controlling
1734 * tty.
1735 */
1736 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001738 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001740 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 read_unlock(&tasklist_lock);
1742 }
1743
Ingo Molnar70522e12006-03-23 03:00:31 -08001744 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001745
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 /* check whether both sides are closing ... */
Alan Coxeeb89d92009-11-30 13:18:29 +00001747 if (!tty_closing || (o_tty && !o_tty_closing)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001748 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001749 return 0;
1750 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001751
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752#ifdef TTY_DEBUG_HANGUP
1753 printk(KERN_DEBUG "freeing tty structure...");
1754#endif
1755 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001756 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001758 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001760 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 * the slots and preserving the termios structure.
1762 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001763 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001766 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001767 devpts_kill_index(inode, idx);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001768 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001769 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770}
1771
Alan Coxaf9b8972006-08-27 01:24:01 -07001772/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001773 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001774 * @inode: inode of device file
1775 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001777 * tty_open and tty_release keep up the tty count that contains the
1778 * number of opens done on a tty. We cannot use the inode-count, as
1779 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001781 * Open-counting is needed for pty masters, as well as for keeping
1782 * track of serial lines: DTR is dropped when the last close happens.
1783 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1784 *
1785 * The termios state of a pty is reset on first open so that
1786 * settings don't persist across reuse.
1787 *
Alan Coxd81ed102008-10-13 10:41:42 +01001788 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001789 * tty->count should protect the rest.
1790 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001792
Alan Coxeeb89d92009-11-30 13:18:29 +00001793static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794{
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001795 struct tty_struct *tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 int noctty, retval;
1797 struct tty_driver *driver;
1798 int index;
1799 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001800 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
1802 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001803
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804retry_open:
1805 noctty = filp->f_flags & O_NOCTTY;
1806 index = -1;
1807 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001808
Ingo Molnar70522e12006-03-23 03:00:31 -08001809 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001810 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811
Alan Cox37bdfb02008-02-08 04:18:47 -08001812 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001813 tty = get_current_tty();
1814 if (!tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001815 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001816 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 return -ENXIO;
1818 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01001819 driver = tty_driver_kref_get(tty->driver);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001820 index = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1822 /* noctty = 1; */
Alan Cox452a00d2008-10-13 10:39:13 +01001823 /* FIXME: Should we take a driver reference ? */
1824 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 goto got_driver;
1826 }
1827#ifdef CONFIG_VT
Alan Cox37bdfb02008-02-08 04:18:47 -08001828 if (device == MKDEV(TTY_MAJOR, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 extern struct tty_driver *console_driver;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001830 driver = tty_driver_kref_get(console_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 index = fg_console;
1832 noctty = 1;
1833 goto got_driver;
1834 }
1835#endif
Alan Cox37bdfb02008-02-08 04:18:47 -08001836 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
Will Newton296fa7f2008-12-01 11:36:06 +00001837 struct tty_driver *console_driver = console_device(&index);
1838 if (console_driver) {
1839 driver = tty_driver_kref_get(console_driver);
1840 if (driver) {
1841 /* Don't let /dev/console block */
1842 filp->f_flags |= O_NONBLOCK;
1843 noctty = 1;
1844 goto got_driver;
1845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001847 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001848 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 return -ENODEV;
1850 }
1851
1852 driver = get_tty_driver(device, &index);
1853 if (!driver) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001854 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001855 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 return -ENODEV;
1857 }
1858got_driver:
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001859 if (!tty) {
1860 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001861 tty = tty_driver_lookup_tty(driver, inode, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001862
Eric Paris808ffa32009-01-27 11:50:37 +00001863 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001864 tty_unlock();
Eric Paris808ffa32009-01-27 11:50:37 +00001865 mutex_unlock(&tty_mutex);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001866 return PTR_ERR(tty);
Eric Paris808ffa32009-01-27 11:50:37 +00001867 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001868 }
1869
1870 if (tty) {
1871 retval = tty_reopen(tty);
1872 if (retval)
1873 tty = ERR_PTR(retval);
1874 } else
1875 tty = tty_init_dev(driver, index, 0);
1876
Ingo Molnar70522e12006-03-23 03:00:31 -08001877 mutex_unlock(&tty_mutex);
Alan Cox7d7b93c2008-10-13 10:42:09 +01001878 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001879 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001880 tty_unlock();
Alan Cox73ec06f2008-10-13 10:42:29 +01001881 return PTR_ERR(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001882 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883
Pekka Enbergf573bd12010-08-24 07:48:34 +03001884 retval = tty_add_file(tty, filp);
1885 if (retval) {
1886 tty_unlock();
1887 return retval;
1888 }
Nick Piggind996b622010-08-18 04:37:36 +10001889
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 check_tty_count(tty, "tty_open");
1891 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1892 tty->driver->subtype == PTY_TYPE_MASTER)
1893 noctty = 1;
1894#ifdef TTY_DEBUG_HANGUP
1895 printk(KERN_DEBUG "opening %s...", tty->name);
1896#endif
1897 if (!retval) {
Alan Coxf34d7a52008-04-30 00:54:13 -07001898 if (tty->ops->open)
1899 retval = tty->ops->open(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 else
1901 retval = -ENODEV;
1902 }
1903 filp->f_flags = saved_flags;
1904
Alan Cox37bdfb02008-02-08 04:18:47 -08001905 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1906 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 retval = -EBUSY;
1908
1909 if (retval) {
1910#ifdef TTY_DEBUG_HANGUP
1911 printk(KERN_DEBUG "error %d in opening %s...", retval,
1912 tty->name);
1913#endif
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001914 tty_unlock(); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00001915 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001916 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001918
1919 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001921
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 schedule();
1923 /*
1924 * Need to reset f_op in case a hangup happened.
1925 */
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001926 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 if (filp->f_op == &hung_up_tty_fops)
1928 filp->f_op = &tty_fops;
Arnd Bergmannec79d602010-06-01 22:53:01 +02001929 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 goto retry_open;
1931 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001932 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001933
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001934
1935 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001936 tty_lock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001937 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 if (!noctty &&
1939 current->signal->leader &&
1940 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001941 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07001942 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001943 spin_unlock_irq(&current->sighand->siglock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001944 tty_unlock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001945 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 return 0;
1947}
1948
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001949
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950
Alan Coxaf9b8972006-08-27 01:24:01 -07001951/**
1952 * tty_poll - check tty status
1953 * @filp: file being polled
1954 * @wait: poll wait structures to update
1955 *
1956 * Call the line discipline polling method to obtain the poll
1957 * status of the device.
1958 *
1959 * Locking: locks called line discipline but ldisc poll method
1960 * may be re-entered freely by other callers.
1961 */
1962
Alan Cox37bdfb02008-02-08 04:18:47 -08001963static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964{
Nick Piggind996b622010-08-18 04:37:36 +10001965 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 struct tty_ldisc *ld;
1967 int ret = 0;
1968
Josef Sipeka7113a92006-12-08 02:36:55 -08001969 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001971
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001973 if (ld->ops->poll)
1974 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 tty_ldisc_deref(ld);
1976 return ret;
1977}
1978
Arnd Bergmannec79d602010-06-01 22:53:01 +02001979static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980{
Nick Piggind996b622010-08-18 04:37:36 +10001981 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07001982 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001983 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984
Josef Sipeka7113a92006-12-08 02:36:55 -08001985 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001986 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08001987
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 retval = fasync_helper(fd, filp, on, &tty->fasync);
1989 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001990 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
1992 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001993 enum pid_type type;
1994 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 if (!waitqueue_active(&tty->read_wait))
1996 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07001997 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001998 if (tty->pgrp) {
1999 pid = tty->pgrp;
2000 type = PIDTYPE_PGID;
2001 } else {
2002 pid = task_pid(current);
2003 type = PIDTYPE_PID;
2004 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002005 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002006 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002007 retval = __f_setown(filp, pid, type, 0);
2008 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002010 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 } else {
2012 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2013 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2014 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002015 retval = 0;
2016out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002017 return retval;
2018}
2019
2020static int tty_fasync(int fd, struct file *filp, int on)
2021{
2022 int retval;
2023 tty_lock();
2024 retval = __tty_fasync(fd, filp, on);
2025 tty_unlock();
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002026 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027}
2028
Alan Coxaf9b8972006-08-27 01:24:01 -07002029/**
2030 * tiocsti - fake input character
2031 * @tty: tty to fake input into
2032 * @p: pointer to character
2033 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002034 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002035 * input management.
2036 *
2037 * FIXME: does not honour flow control ??
2038 *
2039 * Locking:
2040 * Called functions take tty_ldisc_lock
2041 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002042 *
2043 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002044 */
2045
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046static int tiocsti(struct tty_struct *tty, char __user *p)
2047{
2048 char ch, mbz = 0;
2049 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002050
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2052 return -EPERM;
2053 if (get_user(ch, p))
2054 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002055 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002057 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 tty_ldisc_deref(ld);
2059 return 0;
2060}
2061
Alan Coxaf9b8972006-08-27 01:24:01 -07002062/**
2063 * tiocgwinsz - implement window query ioctl
2064 * @tty; tty
2065 * @arg: user buffer for result
2066 *
Alan Cox808a0d32006-09-29 02:00:40 -07002067 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002068 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002069 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002070 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002071 */
2072
Alan Cox37bdfb02008-02-08 04:18:47 -08002073static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074{
Alan Cox808a0d32006-09-29 02:00:40 -07002075 int err;
2076
Arjan van de Ven5785c952006-09-29 02:00:43 -07002077 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002078 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002079 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002080
2081 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082}
2083
Alan Coxaf9b8972006-08-27 01:24:01 -07002084/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002085 * tty_do_resize - resize event
2086 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002087 * @rows: rows (character)
2088 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002089 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002090 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002091 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002092 */
2093
Alan Coxfc6f6232009-01-02 13:43:17 +00002094int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095{
Alan Coxfc6f6232009-01-02 13:43:17 +00002096 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002097 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098
Alan Coxfc6f6232009-01-02 13:43:17 +00002099 /* Lock the tty */
2100 mutex_lock(&tty->termios_mutex);
2101 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002102 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002103 /* Get the PID values and reference them so we can
2104 avoid holding the tty ctrl lock while sending signals */
2105 spin_lock_irqsave(&tty->ctrl_lock, flags);
2106 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002107 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2108
2109 if (pgrp)
2110 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002111 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002112
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002113 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002114done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002115 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 return 0;
2117}
2118
Alan Coxaf9b8972006-08-27 01:24:01 -07002119/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002120 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002121 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002122 * @arg: user buffer for result
2123 *
2124 * Copies the user idea of the window size to the kernel. Traditionally
2125 * this is just advisory information but for the Linux console it
2126 * actually has driver level meaning and triggers a VC resize.
2127 *
2128 * Locking:
2129 * Driver dependant. The default do_resize method takes the
2130 * tty termios mutex and ctrl_lock. The console takes its own lock
2131 * then calls into the default method.
2132 */
2133
Alan Coxfc6f6232009-01-02 13:43:17 +00002134static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002135{
2136 struct winsize tmp_ws;
2137 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2138 return -EFAULT;
2139
2140 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002141 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002142 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002143 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002144}
2145
2146/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002147 * tioccons - allow admin to move logical console
2148 * @file: the file to become console
2149 *
2150 * Allow the adminstrator to move the redirected console device
2151 *
2152 * Locking: uses redirect_lock to guard the redirect information
2153 */
2154
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155static int tioccons(struct file *file)
2156{
2157 if (!capable(CAP_SYS_ADMIN))
2158 return -EPERM;
2159 if (file->f_op->write == redirected_tty_write) {
2160 struct file *f;
2161 spin_lock(&redirect_lock);
2162 f = redirect;
2163 redirect = NULL;
2164 spin_unlock(&redirect_lock);
2165 if (f)
2166 fput(f);
2167 return 0;
2168 }
2169 spin_lock(&redirect_lock);
2170 if (redirect) {
2171 spin_unlock(&redirect_lock);
2172 return -EBUSY;
2173 }
2174 get_file(file);
2175 redirect = file;
2176 spin_unlock(&redirect_lock);
2177 return 0;
2178}
2179
Alan Coxaf9b8972006-08-27 01:24:01 -07002180/**
2181 * fionbio - non blocking ioctl
2182 * @file: file to set blocking value
2183 * @p: user parameter
2184 *
2185 * Historical tty interfaces had a blocking control ioctl before
2186 * the generic functionality existed. This piece of history is preserved
2187 * in the expected tty API of posix OS's.
2188 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002189 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002190 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
2192static int fionbio(struct file *file, int __user *p)
2193{
2194 int nonblock;
2195
2196 if (get_user(nonblock, p))
2197 return -EFAULT;
2198
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002199 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 if (nonblock)
2201 file->f_flags |= O_NONBLOCK;
2202 else
2203 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002204 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 return 0;
2206}
2207
Alan Coxaf9b8972006-08-27 01:24:01 -07002208/**
2209 * tiocsctty - set controlling tty
2210 * @tty: tty structure
2211 * @arg: user argument
2212 *
2213 * This ioctl is used to manage job control. It permits a session
2214 * leader to set this tty as the controlling tty for the session.
2215 *
2216 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002217 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002218 * Takes tasklist_lock internally to walk sessions
2219 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002220 */
2221
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222static int tiocsctty(struct tty_struct *tty, int arg)
2223{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002224 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002225 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002226 return ret;
2227
2228 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229 /*
2230 * The process must be a session leader and
2231 * not have a controlling tty already.
2232 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002233 if (!current->signal->leader || current->signal->tty) {
2234 ret = -EPERM;
2235 goto unlock;
2236 }
2237
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002238 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 /*
2240 * This tty is already the controlling
2241 * tty for another session group!
2242 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002243 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 /*
2245 * Steal it away
2246 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002248 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002250 } else {
2251 ret = -EPERM;
2252 goto unlock;
2253 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002255 proc_set_tty(current, tty);
2256unlock:
Alan Cox28298232006-09-29 02:00:58 -07002257 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002258 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259}
2260
Alan Coxaf9b8972006-08-27 01:24:01 -07002261/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002262 * tty_get_pgrp - return a ref counted pgrp pid
2263 * @tty: tty to read
2264 *
2265 * Returns a refcounted instance of the pid struct for the process
2266 * group controlling the tty.
2267 */
2268
2269struct pid *tty_get_pgrp(struct tty_struct *tty)
2270{
2271 unsigned long flags;
2272 struct pid *pgrp;
2273
2274 spin_lock_irqsave(&tty->ctrl_lock, flags);
2275 pgrp = get_pid(tty->pgrp);
2276 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2277
2278 return pgrp;
2279}
2280EXPORT_SYMBOL_GPL(tty_get_pgrp);
2281
2282/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002283 * tiocgpgrp - get process group
2284 * @tty: tty passed by user
2285 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2286 * @p: returned pid
2287 *
2288 * Obtain the process group of the tty. If there is no process group
2289 * return an error.
2290 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002291 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002292 */
2293
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2295{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002296 struct pid *pid;
2297 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 /*
2299 * (tty == real_tty) is a cheap way of
2300 * testing if the tty is NOT a master pty.
2301 */
2302 if (tty == real_tty && current->signal->tty != real_tty)
2303 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002304 pid = tty_get_pgrp(real_tty);
2305 ret = put_user(pid_vnr(pid), p);
2306 put_pid(pid);
2307 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308}
2309
Alan Coxaf9b8972006-08-27 01:24:01 -07002310/**
2311 * tiocspgrp - attempt to set process group
2312 * @tty: tty passed by user
2313 * @real_tty: tty side device matching tty passed by user
2314 * @p: pid pointer
2315 *
2316 * Set the process group of the tty to the session passed. Only
2317 * permitted where the tty session is our session.
2318 *
Alan Cox47f86832008-04-30 00:53:30 -07002319 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002320 */
2321
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2323{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002324 struct pid *pgrp;
2325 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002327 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328
2329 if (retval == -EIO)
2330 return -ENOTTY;
2331 if (retval)
2332 return retval;
2333 if (!current->signal->tty ||
2334 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002335 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002337 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002339 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002341 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002342 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002343 retval = -ESRCH;
2344 if (!pgrp)
2345 goto out_unlock;
2346 retval = -EPERM;
2347 if (session_of_pgrp(pgrp) != task_session(current))
2348 goto out_unlock;
2349 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002350 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002351 put_pid(real_tty->pgrp);
2352 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002353 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002354out_unlock:
2355 rcu_read_unlock();
2356 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357}
2358
Alan Coxaf9b8972006-08-27 01:24:01 -07002359/**
2360 * tiocgsid - get session id
2361 * @tty: tty passed by user
2362 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2363 * @p: pointer to returned session id
2364 *
2365 * Obtain the session id of the tty. If there is no session
2366 * return an error.
2367 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002368 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002369 */
2370
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2372{
2373 /*
2374 * (tty == real_tty) is a cheap way of
2375 * testing if the tty is NOT a master pty.
2376 */
2377 if (tty == real_tty && current->signal->tty != real_tty)
2378 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002379 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002381 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382}
2383
Alan Coxaf9b8972006-08-27 01:24:01 -07002384/**
2385 * tiocsetd - set line discipline
2386 * @tty: tty device
2387 * @p: pointer to user data
2388 *
2389 * Set the line discipline according to user request.
2390 *
2391 * Locking: see tty_set_ldisc, this function is just a helper
2392 */
2393
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394static int tiocsetd(struct tty_struct *tty, int __user *p)
2395{
2396 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002397 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398
2399 if (get_user(ldisc, p))
2400 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002401
Alan Cox04f378b2008-04-30 00:53:29 -07002402 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002403
2404 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405}
2406
Alan Coxaf9b8972006-08-27 01:24:01 -07002407/**
2408 * send_break - performed time break
2409 * @tty: device to break on
2410 * @duration: timeout in mS
2411 *
2412 * Perform a timed break on hardware that lacks its own driver level
2413 * timed break functionality.
2414 *
2415 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002416 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002417 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002418 */
2419
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002420static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421{
Alan Cox9e989662008-07-22 11:18:03 +01002422 int retval;
2423
2424 if (tty->ops->break_ctl == NULL)
2425 return 0;
2426
2427 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2428 retval = tty->ops->break_ctl(tty, duration);
2429 else {
2430 /* Do the work ourselves */
2431 if (tty_write_lock(tty, 0) < 0)
2432 return -EINTR;
2433 retval = tty->ops->break_ctl(tty, -1);
2434 if (retval)
2435 goto out;
2436 if (!signal_pending(current))
2437 msleep_interruptible(duration);
2438 retval = tty->ops->break_ctl(tty, 0);
2439out:
2440 tty_write_unlock(tty);
2441 if (signal_pending(current))
2442 retval = -EINTR;
2443 }
2444 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445}
2446
Alan Coxaf9b8972006-08-27 01:24:01 -07002447/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002448 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002449 * @tty: tty device
2450 * @file: user file pointer
2451 * @p: pointer to result
2452 *
2453 * Obtain the modem status bits from the tty driver if the feature
2454 * is supported. Return -EINVAL if it is not available.
2455 *
2456 * Locking: none (up to the driver)
2457 */
2458
2459static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460{
2461 int retval = -EINVAL;
2462
Alan Coxf34d7a52008-04-30 00:54:13 -07002463 if (tty->ops->tiocmget) {
2464 retval = tty->ops->tiocmget(tty, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465
2466 if (retval >= 0)
2467 retval = put_user(retval, p);
2468 }
2469 return retval;
2470}
2471
Alan Coxaf9b8972006-08-27 01:24:01 -07002472/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002473 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002474 * @tty: tty device
2475 * @file: user file pointer
2476 * @cmd: command - clear bits, set bits or set all
2477 * @p: pointer to desired bits
2478 *
2479 * Set the modem status bits from the tty driver if the feature
2480 * is supported. Return -EINVAL if it is not available.
2481 *
2482 * Locking: none (up to the driver)
2483 */
2484
2485static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 unsigned __user *p)
2487{
Alan Coxae677512008-07-16 21:56:54 +01002488 int retval;
2489 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490
Alan Coxae677512008-07-16 21:56:54 +01002491 if (tty->ops->tiocmset == NULL)
2492 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493
Alan Coxae677512008-07-16 21:56:54 +01002494 retval = get_user(val, p);
2495 if (retval)
2496 return retval;
2497 set = clear = 0;
2498 switch (cmd) {
2499 case TIOCMBIS:
2500 set = val;
2501 break;
2502 case TIOCMBIC:
2503 clear = val;
2504 break;
2505 case TIOCMSET:
2506 set = val;
2507 clear = ~val;
2508 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 }
Alan Coxae677512008-07-16 21:56:54 +01002510 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2511 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2512 return tty->ops->tiocmset(tty, file, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513}
2514
Alan Coxd281da72010-09-16 18:21:24 +01002515static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2516{
2517 int retval = -EINVAL;
2518 struct serial_icounter_struct icount;
2519 memset(&icount, 0, sizeof(icount));
2520 if (tty->ops->get_icount)
2521 retval = tty->ops->get_icount(tty, &icount);
2522 if (retval != 0)
2523 return retval;
2524 if (copy_to_user(arg, &icount, sizeof(icount)))
2525 return -EFAULT;
2526 return 0;
2527}
2528
Alan Coxe8b70e72009-06-11 12:48:02 +01002529struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2530{
2531 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2532 tty->driver->subtype == PTY_TYPE_MASTER)
2533 tty = tty->link;
2534 return tty;
2535}
2536EXPORT_SYMBOL(tty_pair_get_tty);
2537
2538struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2539{
2540 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2541 tty->driver->subtype == PTY_TYPE_MASTER)
2542 return tty;
2543 return tty->link;
2544}
2545EXPORT_SYMBOL(tty_pair_get_pty);
2546
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547/*
2548 * Split this up, as gcc can choke on it otherwise..
2549 */
Alan Cox04f378b2008-04-30 00:53:29 -07002550long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551{
Nick Piggind996b622010-08-18 04:37:36 +10002552 struct tty_struct *tty = file_tty(file);
2553 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554 void __user *p = (void __user *)arg;
2555 int retval;
2556 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002557 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002558
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2560 return -EINVAL;
2561
Alan Coxe8b70e72009-06-11 12:48:02 +01002562 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563
2564 /*
2565 * Factor out some common prep work
2566 */
2567 switch (cmd) {
2568 case TIOCSETD:
2569 case TIOCSBRK:
2570 case TIOCCBRK:
2571 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002572 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573 retval = tty_check_change(tty);
2574 if (retval)
2575 return retval;
2576 if (cmd != TIOCCBRK) {
2577 tty_wait_until_sent(tty, 0);
2578 if (signal_pending(current))
2579 return -EINTR;
2580 }
2581 break;
2582 }
2583
Alan Cox9e989662008-07-22 11:18:03 +01002584 /*
2585 * Now do the stuff.
2586 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002588 case TIOCSTI:
2589 return tiocsti(tty, p);
2590 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002591 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002592 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002593 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002594 case TIOCCONS:
2595 return real_tty != tty ? -EINVAL : tioccons(file);
2596 case FIONBIO:
2597 return fionbio(file, p);
2598 case TIOCEXCL:
2599 set_bit(TTY_EXCLUSIVE, &tty->flags);
2600 return 0;
2601 case TIOCNXCL:
2602 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2603 return 0;
2604 case TIOCNOTTY:
2605 if (current->signal->tty != tty)
2606 return -ENOTTY;
2607 no_tty();
2608 return 0;
2609 case TIOCSCTTY:
2610 return tiocsctty(tty, arg);
2611 case TIOCGPGRP:
2612 return tiocgpgrp(tty, real_tty, p);
2613 case TIOCSPGRP:
2614 return tiocspgrp(tty, real_tty, p);
2615 case TIOCGSID:
2616 return tiocgsid(tty, real_tty, p);
2617 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002618 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002619 case TIOCSETD:
2620 return tiocsetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002621 /*
2622 * Break handling
2623 */
2624 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002625 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002626 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002627 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002628 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002629 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002630 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002631 return 0;
2632 case TCSBRK: /* SVID version: non-zero arg --> no break */
2633 /* non-zero arg means wait for all output data
2634 * to be sent (performed above) but don't send break.
2635 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002637 if (!arg)
2638 return send_break(tty, 250);
2639 return 0;
2640 case TCSBRKP: /* support for POSIX tcsendbreak() */
2641 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642
Alan Cox37bdfb02008-02-08 04:18:47 -08002643 case TIOCMGET:
2644 return tty_tiocmget(tty, file, p);
2645 case TIOCMSET:
2646 case TIOCMBIC:
2647 case TIOCMBIS:
2648 return tty_tiocmset(tty, file, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002649 case TIOCGICOUNT:
2650 retval = tty_tiocgicount(tty, p);
2651 /* For the moment allow fall through to the old method */
2652 if (retval != -EINVAL)
2653 return retval;
2654 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002655 case TCFLSH:
2656 switch (arg) {
2657 case TCIFLUSH:
2658 case TCIOFLUSH:
2659 /* flush tty buffer and allow ldisc to process ioctl */
2660 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002661 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002662 }
2663 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002665 if (tty->ops->ioctl) {
2666 retval = (tty->ops->ioctl)(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 if (retval != -ENOIOCTLCMD)
2668 return retval;
2669 }
2670 ld = tty_ldisc_ref_wait(tty);
2671 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002672 if (ld->ops->ioctl) {
2673 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 if (retval == -ENOIOCTLCMD)
2675 retval = -EINVAL;
2676 }
2677 tty_ldisc_deref(ld);
2678 return retval;
2679}
2680
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002681#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002682static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002683 unsigned long arg)
2684{
2685 struct inode *inode = file->f_dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10002686 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002687 struct tty_ldisc *ld;
2688 int retval = -ENOIOCTLCMD;
2689
2690 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2691 return -EINVAL;
2692
Alan Coxf34d7a52008-04-30 00:54:13 -07002693 if (tty->ops->compat_ioctl) {
2694 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002695 if (retval != -ENOIOCTLCMD)
2696 return retval;
2697 }
2698
2699 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002700 if (ld->ops->compat_ioctl)
2701 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002702 tty_ldisc_deref(ld);
2703
2704 return retval;
2705}
2706#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707
2708/*
2709 * This implements the "Secure Attention Key" --- the idea is to
2710 * prevent trojan horses by killing all processes associated with this
2711 * tty when the user hits the "Secure Attention Key". Required for
2712 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002713 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 * This code could be nicer; ideally it should send a HUP, wait a few
2715 * seconds, then send a INT, and then a KILL signal. But you then
2716 * have to coordinate with the init process, since all processes associated
2717 * with the current tty must be dead before the new getty is allowed
2718 * to spawn.
2719 *
2720 * Now, if it would be correct ;-/ The current code has a nasty hole -
2721 * it doesn't catch files in flight. We may send the descriptor to ourselves
2722 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2723 *
2724 * Nasty bug: do_SAK is being called in interrupt context. This can
2725 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2726 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002727void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728{
2729#ifdef TTY_SOFT_SAK
2730 tty_hangup(tty);
2731#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002732 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002733 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734 int i;
2735 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002736 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002737
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738 if (!tty)
2739 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002740 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002741
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002742 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743
Alan Coxf34d7a52008-04-30 00:54:13 -07002744 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002745
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002747 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002748 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002749 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002750 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002751 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002752 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002753 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002754 /* Now kill any processes that happen to have the
2755 * tty open.
2756 */
2757 do_each_thread(g, p) {
2758 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002760 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002761 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 send_sig(SIGKILL, p, 1);
2763 continue;
2764 }
2765 task_lock(p);
2766 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002767 /*
2768 * We don't take a ref to the file, so we must
2769 * hold ->file_lock instead.
2770 */
2771 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002772 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002773 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 filp = fcheck_files(p->files, i);
2775 if (!filp)
2776 continue;
2777 if (filp->f_op->read == tty_read &&
Nick Piggind996b622010-08-18 04:37:36 +10002778 file_tty(filp) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 printk(KERN_NOTICE "SAK: killed process %d"
2780 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002781 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002782 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 break;
2784 }
2785 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002786 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 }
2788 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002789 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 read_unlock(&tasklist_lock);
2791#endif
2792}
2793
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002794static void do_SAK_work(struct work_struct *work)
2795{
2796 struct tty_struct *tty =
2797 container_of(work, struct tty_struct, SAK_work);
2798 __do_SAK(tty);
2799}
2800
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801/*
2802 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2803 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2804 * the values which we write to it will be identical to the values which it
2805 * already has. --akpm
2806 */
2807void do_SAK(struct tty_struct *tty)
2808{
2809 if (!tty)
2810 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 schedule_work(&tty->SAK_work);
2812}
2813
2814EXPORT_SYMBOL(do_SAK);
2815
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002816static int dev_match_devt(struct device *dev, void *data)
2817{
2818 dev_t *devt = data;
2819 return dev->devt == *devt;
2820}
2821
2822/* Must put_device() after it's unused! */
2823static struct device *tty_get_device(struct tty_struct *tty)
2824{
2825 dev_t devt = tty_devnum(tty);
2826 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2827}
2828
2829
Alan Coxaf9b8972006-08-27 01:24:01 -07002830/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002831 * initialize_tty_struct
2832 * @tty: tty to initialize
2833 *
2834 * This subroutine initializes a tty structure that has been newly
2835 * allocated.
2836 *
2837 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002839
Alan Coxbf970ee2008-10-13 10:42:39 +01002840void initialize_tty_struct(struct tty_struct *tty,
2841 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842{
2843 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002844 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002846 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002847 tty->session = NULL;
2848 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002850 tty->buf.head = tty->buf.tail = NULL;
2851 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002852 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002853 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 init_waitqueue_head(&tty->write_wait);
2855 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002856 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002857 mutex_init(&tty->atomic_read_lock);
2858 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002859 mutex_init(&tty->output_lock);
2860 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002862 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002864 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002865
2866 tty->driver = driver;
2867 tty->ops = driver->ops;
2868 tty->index = idx;
2869 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002870 tty->dev = tty_get_device(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871}
2872
Alan Coxf34d7a52008-04-30 00:54:13 -07002873/**
2874 * tty_put_char - write one character to a tty
2875 * @tty: tty
2876 * @ch: character
2877 *
2878 * Write one byte to the tty using the provided put_char method
2879 * if present. Returns the number of characters successfully output.
2880 *
2881 * Note: the specific put_char operation in the driver layer may go
2882 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002884
Alan Coxf34d7a52008-04-30 00:54:13 -07002885int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886{
Alan Coxf34d7a52008-04-30 00:54:13 -07002887 if (tty->ops->put_char)
2888 return tty->ops->put_char(tty, ch);
2889 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890}
Alan Coxf34d7a52008-04-30 00:54:13 -07002891EXPORT_SYMBOL_GPL(tty_put_char);
2892
Alan Coxd81ed102008-10-13 10:41:42 +01002893struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894
2895/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002896 * tty_register_device - register a tty device
2897 * @driver: the tty driver that describes the tty device
2898 * @index: the index in the tty driver for this tty device
2899 * @device: a struct device that is associated with this tty device.
2900 * This field is optional, if there is no known struct device
2901 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002903 * Returns a pointer to the struct device for this tty device
2904 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002905 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002906 * This call is required to be made to register an individual tty device
2907 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2908 * that bit is not set, this function should not be called by a tty
2909 * driver.
2910 *
2911 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002913
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002914struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2915 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916{
2917 char name[64];
2918 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2919
2920 if (index >= driver->num) {
2921 printk(KERN_ERR "Attempt to register invalid tty line number "
2922 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002923 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 }
2925
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926 if (driver->type == TTY_DRIVER_TYPE_PTY)
2927 pty_line_name(driver, index, name);
2928 else
2929 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002930
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07002931 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002933EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934
2935/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002936 * tty_unregister_device - unregister a tty device
2937 * @driver: the tty driver that describes the tty device
2938 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002940 * If a tty device is registered with a call to tty_register_device() then
2941 * this function must be called when the tty device is gone.
2942 *
2943 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002945
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946void tty_unregister_device(struct tty_driver *driver, unsigned index)
2947{
Alan Cox37bdfb02008-02-08 04:18:47 -08002948 device_destroy(tty_class,
2949 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951EXPORT_SYMBOL(tty_unregister_device);
2952
2953struct tty_driver *alloc_tty_driver(int lines)
2954{
2955 struct tty_driver *driver;
2956
Jean Delvare506eb992007-07-15 23:40:14 -07002957 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01002959 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 driver->magic = TTY_DRIVER_MAGIC;
2961 driver->num = lines;
2962 /* later we'll move allocation of tables here */
2963 }
2964 return driver;
2965}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002966EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967
Alan Cox7d7b93c2008-10-13 10:42:09 +01002968static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002970 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2971 int i;
2972 struct ktermios *tp;
2973 void *p;
2974
2975 if (driver->flags & TTY_DRIVER_INSTALLED) {
2976 /*
2977 * Free the termios and termios_locked structures because
2978 * we don't want to get memory leaks when modular tty
2979 * drivers are removed from the kernel.
2980 */
2981 for (i = 0; i < driver->num; i++) {
2982 tp = driver->termios[i];
2983 if (tp) {
2984 driver->termios[i] = NULL;
2985 kfree(tp);
2986 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01002987 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
2988 tty_unregister_device(driver, i);
2989 }
2990 p = driver->ttys;
2991 proc_tty_unregister_driver(driver);
2992 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002993 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01002994 kfree(p);
2995 cdev_del(&driver->cdev);
2996 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 kfree(driver);
2998}
2999
Alan Cox7d7b93c2008-10-13 10:42:09 +01003000void tty_driver_kref_put(struct tty_driver *driver)
3001{
3002 kref_put(&driver->kref, destruct_tty_driver);
3003}
3004EXPORT_SYMBOL(tty_driver_kref_put);
3005
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003006void tty_set_operations(struct tty_driver *driver,
3007 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008{
Alan Coxf34d7a52008-04-30 00:54:13 -07003009 driver->ops = op;
3010};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011EXPORT_SYMBOL(tty_set_operations);
3012
Alan Cox7d7b93c2008-10-13 10:42:09 +01003013void put_tty_driver(struct tty_driver *d)
3014{
3015 tty_driver_kref_put(d);
3016}
3017EXPORT_SYMBOL(put_tty_driver);
3018
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019/*
3020 * Called by a tty driver to register itself.
3021 */
3022int tty_register_driver(struct tty_driver *driver)
3023{
3024 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003025 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 dev_t dev;
3027 void **p = NULL;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003028 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029
Andy Whitcroft543691a62007-05-06 14:49:33 -07003030 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01003031 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 if (!p)
3033 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 }
3035
3036 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003037 error = alloc_chrdev_region(&dev, driver->minor_start,
3038 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 if (!error) {
3040 driver->major = MAJOR(dev);
3041 driver->minor_start = MINOR(dev);
3042 }
3043 } else {
3044 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003045 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046 }
3047 if (error < 0) {
3048 kfree(p);
3049 return error;
3050 }
3051
3052 if (p) {
3053 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08003054 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055 } else {
3056 driver->ttys = NULL;
3057 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 }
3059
3060 cdev_init(&driver->cdev, &tty_fops);
3061 driver->cdev.owner = driver->owner;
3062 error = cdev_add(&driver->cdev, dev, driver->num);
3063 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064 unregister_chrdev_region(dev, driver->num);
3065 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01003066 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 kfree(p);
3068 return error;
3069 }
3070
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003071 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003073 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003074
3075 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003076 for (i = 0; i < driver->num; i++) {
3077 d = tty_register_device(driver, i, NULL);
3078 if (IS_ERR(d)) {
3079 error = PTR_ERR(d);
3080 goto err;
3081 }
3082 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 }
3084 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003085 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003087
3088err:
3089 for (i--; i >= 0; i--)
3090 tty_unregister_device(driver, i);
3091
3092 mutex_lock(&tty_mutex);
3093 list_del(&driver->tty_drivers);
3094 mutex_unlock(&tty_mutex);
3095
3096 unregister_chrdev_region(dev, driver->num);
3097 driver->ttys = NULL;
3098 driver->termios = NULL;
3099 kfree(p);
3100 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003101}
3102
3103EXPORT_SYMBOL(tty_register_driver);
3104
3105/*
3106 * Called by a tty driver to unregister itself.
3107 */
3108int tty_unregister_driver(struct tty_driver *driver)
3109{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003110#if 0
3111 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112 if (driver->refcount)
3113 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003114#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3116 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003117 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003119 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003120 return 0;
3121}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003122
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123EXPORT_SYMBOL(tty_unregister_driver);
3124
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003125dev_t tty_devnum(struct tty_struct *tty)
3126{
3127 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3128}
3129EXPORT_SYMBOL(tty_devnum);
3130
3131void proc_clear_tty(struct task_struct *p)
3132{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003133 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003134 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003135 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003136 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003137 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003138 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003139 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003140}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003141
Alan Cox47f86832008-04-30 00:53:30 -07003142/* Called under the sighand lock */
3143
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003144static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003145{
3146 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003147 unsigned long flags;
3148 /* We should not have a session or pgrp to put here but.... */
3149 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003150 put_pid(tty->session);
3151 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003152 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003153 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3154 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003155 if (tsk->signal->tty) {
3156 printk(KERN_DEBUG "tty not NULL!!\n");
3157 tty_kref_put(tsk->signal->tty);
3158 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003159 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003160 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003161 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003162 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003163}
3164
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003165static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003166{
3167 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003168 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003169 spin_unlock_irq(&tsk->sighand->siglock);
3170}
3171
3172struct tty_struct *get_current_tty(void)
3173{
3174 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003175 unsigned long flags;
3176
3177 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003178 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003179 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003180 return tty;
3181}
Heiko Carstensa311f742006-12-13 00:33:41 -08003182EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183
Alan Coxd81ed102008-10-13 10:41:42 +01003184void tty_default_fops(struct file_operations *fops)
3185{
3186 *fops = tty_fops;
3187}
3188
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189/*
3190 * Initialize the console device. This is called *early*, so
3191 * we can't necessarily depend on lots of kernel help here.
3192 * Just do some early initializations, and do the complex setup
3193 * later.
3194 */
3195void __init console_init(void)
3196{
3197 initcall_t *call;
3198
3199 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003200 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201
3202 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003203 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204 * inform about problems etc..
3205 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206 call = __con_initcall_start;
3207 while (call < __con_initcall_end) {
3208 (*call)();
3209 call++;
3210 }
3211}
3212
Kay Sieverse454cea2009-09-18 23:01:12 +02003213static char *tty_devnode(struct device *dev, mode_t *mode)
3214{
3215 if (!mode)
3216 return NULL;
3217 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3218 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3219 *mode = 0666;
3220 return NULL;
3221}
3222
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223static int __init tty_class_init(void)
3224{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003225 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226 if (IS_ERR(tty_class))
3227 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003228 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229 return 0;
3230}
3231
3232postcore_initcall(tty_class_init);
3233
3234/* 3/2004 jmc: why do these devices exist? */
3235
3236static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237
3238/*
3239 * Ok, now we can initialize the rest of the tty devices and can count
3240 * on memory allocations, interrupts etc..
3241 */
David Howells31d1d482010-08-06 16:34:43 +01003242int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243{
3244 cdev_init(&tty_cdev, &tty_fops);
3245 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3246 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3247 panic("Couldn't register /dev/tty driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003248 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003249 "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003250
3251 cdev_init(&console_cdev, &console_fops);
3252 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3253 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3254 panic("Couldn't register /dev/console driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003255 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003256 "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003259 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260#endif
3261 return 0;
3262}
David Howells31d1d482010-08-06 16:34:43 +01003263