blob: da9fde85075499404c3e77ffb9291ac58f5d7785 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 1991, 1992 Linus Torvalds
3 */
4
5/*
6 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
7 * or rs-channels. It also implements echoing, cooked mode etc.
8 *
9 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
10 *
11 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
12 * tty_struct and tty_queue structures. Previously there was an array
13 * of 256 tty_struct's which was statically allocated, and the
14 * tty_queue structures were allocated at boot time. Both are now
15 * dynamically allocated only when the tty is open.
16 *
17 * Also restructured routines so that there is more of a separation
18 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
19 * the low-level tty routines (serial.c, pty.c, console.c). This
Alan Cox37bdfb02008-02-08 04:18:47 -080020 * makes for cleaner and more compact code. -TYT, 9/17/92
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 *
22 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
23 * which can be dynamically activated and de-activated by the line
24 * discipline handling modules (like SLIP).
25 *
26 * NOTE: pay no attention to the line discipline code (yet); its
27 * interface is still subject to change in this version...
28 * -- TYT, 1/31/92
29 *
30 * Added functionality to the OPOST tty handling. No delays, but all
31 * other bits should be there.
32 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
33 *
34 * Rewrote canonical mode and added more termios flags.
35 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
36 *
37 * Reorganized FASYNC support so mouse code can share it.
38 * -- ctm@ardi.com, 9Sep95
39 *
40 * New TIOCLINUX variants added.
41 * -- mj@k332.feld.cvut.cz, 19-Nov-95
Alan Cox37bdfb02008-02-08 04:18:47 -080042 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * Restrict vt switching via ioctl()
44 * -- grif@cs.ucr.edu, 5-Dec-95
45 *
46 * Move console and virtual terminal code to more appropriate files,
47 * implement CONFIG_VT and generalize console device interface.
48 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
49 *
Alan Coxd81ed102008-10-13 10:41:42 +010050 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 * -- Bill Hawes <whawes@star.net>, June 97
52 *
53 * Added devfs support.
54 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
55 *
56 * Added support for a Unix98-style ptmx device.
57 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
58 *
59 * Reduced memory usage for older ARM systems
60 * -- Russell King <rmk@arm.linux.org.uk>
61 *
62 * Move do_SAK() into process context. Less stack use in devfs functions.
Alan Cox37bdfb02008-02-08 04:18:47 -080063 * alloc_tty_struct() always uses kmalloc()
64 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 */
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/types.h>
68#include <linux/major.h>
69#include <linux/errno.h>
70#include <linux/signal.h>
71#include <linux/fcntl.h>
72#include <linux/sched.h>
73#include <linux/interrupt.h>
74#include <linux/tty.h>
75#include <linux/tty_driver.h>
76#include <linux/tty_flip.h>
77#include <linux/devpts_fs.h>
78#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040079#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#include <linux/console.h>
81#include <linux/timer.h>
82#include <linux/ctype.h>
83#include <linux/kd.h>
84#include <linux/mm.h>
85#include <linux/string.h>
86#include <linux/slab.h>
87#include <linux/poll.h>
88#include <linux/proc_fs.h>
89#include <linux/init.h>
90#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070091#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070092#include <linux/wait.h>
93#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070094#include <linux/delay.h>
Alan Coxa352def2008-07-16 21:53:12 +010095#include <linux/seq_file.h>
Alan Coxd281da72010-09-16 18:21:24 +010096#include <linux/serial.h>
Manuel Zerpies5a3c6b22011-06-16 14:07:22 +020097#include <linux/ratelimit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Alan Coxa352def2008-07-16 21:53:12 +010099#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
101#include <linux/kbd_kern.h>
102#include <linux/vt_kern.h>
103#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105#include <linux/kmod.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700106#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108#undef TTY_DEBUG_HANGUP
109
110#define TTY_PARANOIA_CHECK 1
111#define CHECK_TTY_COUNT 1
112
Alan Coxedc6afc2006-12-08 02:38:44 -0800113struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800119 .c_cc = INIT_C_CC,
120 .c_ispeed = 38400,
121 .c_ospeed = 38400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122};
123
124EXPORT_SYMBOL(tty_std_termios);
125
126/* This list gets poked at by procfs and various bits of boot up code. This
127 could do with some rationalisation such as pulling the tty proc function
128 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800132/* Mutex to protect creating and releasing a tty. This is shared with
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 vt.c for deeply disgusting hack reasons */
Ingo Molnar70522e12006-03-23 03:00:31 -0800134DEFINE_MUTEX(tty_mutex);
Alan Coxde2a84f2006-09-29 02:00:57 -0700135EXPORT_SYMBOL(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
Nick Pigginee2ffa02010-08-18 04:37:35 +1000137/* Spinlock to protect the tty->tty_files list */
138DEFINE_SPINLOCK(tty_files_lock);
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
141static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800142ssize_t redirected_tty_write(struct file *, const char __user *,
143 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144static unsigned int tty_poll(struct file *, poll_table *);
145static int tty_open(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700146long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700147#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800148static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700149 unsigned long arg);
150#else
151#define tty_compat_ioctl NULL
152#endif
Arnd Bergmannec79d602010-06-01 22:53:01 +0200153static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800154static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800155static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700156static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700157static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Alan Coxaf9b8972006-08-27 01:24:01 -0700159/**
160 * alloc_tty_struct - allocate a tty object
161 *
162 * Return a new empty tty structure. The data fields have not
163 * been initialized in any way but has been zeroed
164 *
165 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700166 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Alan Coxbf970ee2008-10-13 10:42:39 +0100168struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
Alan Cox1266b1e2006-09-29 02:00:40 -0700170 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Alan Coxaf9b8972006-08-27 01:24:01 -0700173/**
174 * free_tty_struct - free a disused tty
175 * @tty: tty struct to free
176 *
177 * Free the write buffers, tty queue and tty memory itself.
178 *
179 * Locking: none. Must be called after tty is definitely unused
180 */
181
Alan Coxbf970ee2008-10-13 10:42:39 +0100182void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
Dan Carpenterdc6802a2012-07-24 12:52:04 +0100184 if (!tty)
185 return;
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +0400186 if (tty->dev)
187 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 kfree(tty->write_buf);
Alan Cox89c8d912012-08-08 16:30:13 +0100189 tty->magic = 0xDEADDEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 kfree(tty);
191}
192
Nick Piggind996b622010-08-18 04:37:36 +1000193static inline struct tty_struct *file_tty(struct file *file)
194{
195 return ((struct tty_file_private *)file->private_data)->tty;
196}
197
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200198int tty_alloc_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000199{
200 struct tty_file_private *priv;
201
Pekka Enbergf573bd12010-08-24 07:48:34 +0300202 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
203 if (!priv)
204 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000205
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200206 file->private_data = priv;
207
208 return 0;
209}
210
211/* Associate a new file with the tty structure */
212void tty_add_file(struct tty_struct *tty, struct file *file)
213{
214 struct tty_file_private *priv = file->private_data;
215
Nick Piggind996b622010-08-18 04:37:36 +1000216 priv->tty = tty;
217 priv->file = file;
Nick Piggind996b622010-08-18 04:37:36 +1000218
219 spin_lock(&tty_files_lock);
220 list_add(&priv->list, &tty->tty_files);
221 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200222}
Pekka Enbergf573bd12010-08-24 07:48:34 +0300223
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200224/**
225 * tty_free_file - free file->private_data
226 *
227 * This shall be used only for fail path handling when tty_add_file was not
228 * called yet.
229 */
230void tty_free_file(struct file *file)
231{
232 struct tty_file_private *priv = file->private_data;
233
234 file->private_data = NULL;
235 kfree(priv);
Nick Piggind996b622010-08-18 04:37:36 +1000236}
237
238/* Delete file from its tty */
Josh Triplett2520e272012-11-18 21:27:47 -0800239static void tty_del_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000240{
241 struct tty_file_private *priv = file->private_data;
242
243 spin_lock(&tty_files_lock);
244 list_del(&priv->list);
245 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200246 tty_free_file(file);
Nick Piggind996b622010-08-18 04:37:36 +1000247}
248
249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
251
Alan Coxaf9b8972006-08-27 01:24:01 -0700252/**
253 * tty_name - return tty naming
254 * @tty: tty structure
255 * @buf: buffer for output
256 *
257 * Convert a tty structure into a name. The name reflects the kernel
258 * naming policy and if udev is in use may not reflect user space
259 *
260 * Locking: none
261 */
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263char *tty_name(struct tty_struct *tty, char *buf)
264{
265 if (!tty) /* Hmm. NULL pointer. That's fun. */
266 strcpy(buf, "NULL tty");
267 else
268 strcpy(buf, tty->name);
269 return buf;
270}
271
272EXPORT_SYMBOL(tty_name);
273
Andrew Mortond769a662005-05-05 16:15:50 -0700274int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 const char *routine)
276{
277#ifdef TTY_PARANOIA_CHECK
278 if (!tty) {
279 printk(KERN_WARNING
280 "null TTY for (%d:%d) in %s\n",
281 imajor(inode), iminor(inode), routine);
282 return 1;
283 }
284 if (tty->magic != TTY_MAGIC) {
285 printk(KERN_WARNING
286 "bad magic number for tty struct (%d:%d) in %s\n",
287 imajor(inode), iminor(inode), routine);
288 return 1;
289 }
290#endif
291 return 0;
292}
293
294static int check_tty_count(struct tty_struct *tty, const char *routine)
295{
296#ifdef CHECK_TTY_COUNT
297 struct list_head *p;
298 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800299
Nick Pigginee2ffa02010-08-18 04:37:35 +1000300 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 list_for_each(p, &tty->tty_files) {
302 count++;
303 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000304 spin_unlock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
306 tty->driver->subtype == PTY_TYPE_SLAVE &&
307 tty->link && tty->link->count)
308 count++;
309 if (tty->count != count) {
310 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
311 "!= #fd's(%d) in %s\n",
312 tty->name, tty->count, count, routine);
313 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800314 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315#endif
316 return 0;
317}
318
Alan Coxaf9b8972006-08-27 01:24:01 -0700319/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700320 * get_tty_driver - find device of a tty
321 * @dev_t: device identifier
322 * @index: returns the index of the tty
323 *
324 * This routine returns a tty driver structure, given a device number
325 * and also passes back the index number.
326 *
327 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330static struct tty_driver *get_tty_driver(dev_t device, int *index)
331{
332 struct tty_driver *p;
333
334 list_for_each_entry(p, &tty_drivers, tty_drivers) {
335 dev_t base = MKDEV(p->major, p->minor_start);
336 if (device < base || device >= base + p->num)
337 continue;
338 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100339 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341 return NULL;
342}
343
Jason Wesself2d937f2008-04-17 20:05:37 +0200344#ifdef CONFIG_CONSOLE_POLL
345
346/**
347 * tty_find_polling_driver - find device of a polled tty
348 * @name: name string to match
349 * @line: pointer to resulting tty line nr
350 *
351 * This routine returns a tty driver structure, given a name
352 * and the condition that the tty driver is capable of polled
353 * operation.
354 */
355struct tty_driver *tty_find_polling_driver(char *name, int *line)
356{
357 struct tty_driver *p, *res = NULL;
358 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500359 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100360 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200361
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500362 for (str = name; *str; str++)
363 if ((*str >= '0' && *str <= '9') || *str == ',')
364 break;
365 if (!*str)
366 return NULL;
367
368 len = str - name;
369 tty_line = simple_strtoul(str, &str, 10);
370
Jason Wesself2d937f2008-04-17 20:05:37 +0200371 mutex_lock(&tty_mutex);
372 /* Search through the tty devices to look for a match */
373 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500374 if (strncmp(name, p->name, len) != 0)
375 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100376 stp = str;
377 if (*stp == ',')
378 stp++;
379 if (*stp == '\0')
380 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200381
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200382 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100383 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100384 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200385 *line = tty_line;
386 break;
387 }
388 }
389 mutex_unlock(&tty_mutex);
390
391 return res;
392}
393EXPORT_SYMBOL_GPL(tty_find_polling_driver);
394#endif
395
Alan Coxaf9b8972006-08-27 01:24:01 -0700396/**
397 * tty_check_change - check for POSIX terminal changes
398 * @tty: tty to check
399 *
400 * If we try to write to, or set the state of, a terminal and we're
401 * not in the foreground, send a SIGTTOU. If the signal is blocked or
402 * ignored, go ahead and perform the operation. (POSIX 7.2)
403 *
Alan Cox978e5952008-04-30 00:53:59 -0700404 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700406
Alan Cox37bdfb02008-02-08 04:18:47 -0800407int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408{
Alan Cox47f86832008-04-30 00:53:30 -0700409 unsigned long flags;
410 int ret = 0;
411
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 if (current->signal->tty != tty)
413 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700414
415 spin_lock_irqsave(&tty->ctrl_lock, flags);
416
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800417 if (!tty->pgrp) {
418 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700419 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800421 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700422 goto out_unlock;
423 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700425 goto out;
426 if (is_current_pgrp_orphaned()) {
427 ret = -EIO;
428 goto out;
429 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700430 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
431 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700432 ret = -ERESTARTSYS;
433out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700434 return ret;
435out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700436 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
437 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438}
439
440EXPORT_SYMBOL(tty_check_change);
441
Alan Cox37bdfb02008-02-08 04:18:47 -0800442static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 size_t count, loff_t *ppos)
444{
445 return 0;
446}
447
Alan Cox37bdfb02008-02-08 04:18:47 -0800448static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 size_t count, loff_t *ppos)
450{
451 return -EIO;
452}
453
454/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800455static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
457 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
458}
459
Alan Cox04f378b2008-04-30 00:53:29 -0700460static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
461 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700462{
463 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
464}
465
Alan Cox37bdfb02008-02-08 04:18:47 -0800466static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700467 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
469 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
470}
471
Arjan van de Ven62322d22006-07-03 00:24:21 -0700472static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 .llseek = no_llseek,
474 .read = tty_read,
475 .write = tty_write,
476 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700477 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700478 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 .open = tty_open,
480 .release = tty_release,
481 .fasync = tty_fasync,
482};
483
Arjan van de Ven62322d22006-07-03 00:24:21 -0700484static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 .llseek = no_llseek,
486 .read = tty_read,
487 .write = redirected_tty_write,
488 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700489 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700490 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 .open = tty_open,
492 .release = tty_release,
493 .fasync = tty_fasync,
494};
495
Arjan van de Ven62322d22006-07-03 00:24:21 -0700496static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 .llseek = no_llseek,
498 .read = hung_up_tty_read,
499 .write = hung_up_tty_write,
500 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700501 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700502 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 .release = tty_release,
504};
505
506static DEFINE_SPINLOCK(redirect_lock);
507static struct file *redirect;
508
509/**
510 * tty_wakeup - request more data
511 * @tty: terminal
512 *
513 * Internal and external helper for wakeups of tty. This function
514 * informs the line discipline if present that the driver is ready
515 * to receive more output data.
516 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518void tty_wakeup(struct tty_struct *tty)
519{
520 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
523 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800524 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100525 if (ld->ops->write_wakeup)
526 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 tty_ldisc_deref(ld);
528 }
529 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700530 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531}
532
533EXPORT_SYMBOL_GPL(tty_wakeup);
534
535/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200536 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000537 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700538 *
Alan Cox1bad8792008-07-22 23:38:04 +0100539 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700540 * synchronous but doesn't hold any locks, so we need to make sure we
541 * have the appropriate locks for what we're doing.
542 *
543 * The hangup event clears any pending redirections onto the hung up
544 * device. It ensures future writes will error and it does the needed
545 * line discipline hangup and signal delivery. The tty object itself
546 * remains intact.
547 *
548 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200549 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800550 * redirect lock for undoing redirection
551 * file list lock for manipulating list of ttys
552 * tty_ldisc_lock from called functions
553 * termios_mutex resetting termios data
554 * tasklist_lock to walk task list for hangup event
555 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 */
Josh Triplett2520e272012-11-18 21:27:47 -0800557static void __tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
Alan Cox37bdfb02008-02-08 04:18:47 -0800559 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 struct file *filp, *f = NULL;
561 struct task_struct *p;
Nick Piggind996b622010-08-18 04:37:36 +1000562 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700564 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100565 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 if (!tty)
568 return;
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000572 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 f = redirect;
574 redirect = NULL;
575 }
576 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800577
Alan Cox89c8d912012-08-08 16:30:13 +0100578 tty_lock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200579
Jiri Slabyacfa7472010-11-29 10:16:54 +0100580 /* some functions below drop BTM, so we need this bit */
581 set_bit(TTY_HUPPING, &tty->flags);
582
Arnd Bergmannec79d602010-06-01 22:53:01 +0200583 /* inuse_filps is protected by the single tty lock,
584 this really needs to change if we want to flush the
585 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200586 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000587
Nick Pigginee2ffa02010-08-18 04:37:35 +1000588 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000590 list_for_each_entry(priv, &tty->tty_files, list) {
591 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 if (filp->f_op->write == redirected_tty_write)
593 cons_filp = filp;
594 if (filp->f_op->write != tty_write)
595 continue;
596 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200597 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 filp->f_op = &hung_up_tty_fops;
599 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000600 spin_unlock(&tty_files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800601
Jiri Slabyacfa7472010-11-29 10:16:54 +0100602 /*
603 * it drops BTM and thus races with reopen
604 * we protect the race by TTY_HUPPING
605 */
Alan Coxc65c9bc2009-06-11 12:50:12 +0100606 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800607
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800609 if (tty->session) {
610 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800611 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100612 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100614 /* We defer the dereferences outside fo
615 the tasklist lock */
616 refs++;
617 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800618 if (!p->signal->leader) {
619 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800621 }
622 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
623 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800624 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700625 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800626 if (tty->pgrp)
627 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700628 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800629 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800630 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
632 read_unlock(&tasklist_lock);
633
Alan Cox47f86832008-04-30 00:53:30 -0700634 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100635 clear_bit(TTY_THROTTLED, &tty->flags);
636 clear_bit(TTY_PUSH, &tty->flags);
637 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600638 put_pid(tty->session);
639 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800640 tty->session = NULL;
641 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 tty->ctrl_status = 0;
Alan Cox47f86832008-04-30 00:53:30 -0700643 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
644
Alan Cox9c9f4de2008-10-13 10:37:26 +0100645 /* Account for the p->signal references we killed */
646 while (refs--)
647 tty_kref_put(tty);
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800650 * If one of the devices matches a console pointer, we
651 * cannot just call hangup() because that will cause
652 * tty->count and state->count to go out of sync.
653 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 */
655 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700656 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700658 tty->ops->close(tty, cons_filp);
659 } else if (tty->ops->hangup)
660 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800661 /*
662 * We don't want to have driver/ldisc interactions beyond
663 * the ones we did here. The driver layer expects no
664 * calls after ->hangup() from the ldisc side. However we
665 * can't yet guarantee all that.
666 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 set_bit(TTY_HUPPED, &tty->flags);
Jiri Slabyacfa7472010-11-29 10:16:54 +0100668 clear_bit(TTY_HUPPING, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100669 tty_ldisc_enable(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200670
Alan Cox89c8d912012-08-08 16:30:13 +0100671 tty_unlock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 if (f)
674 fput(f);
675}
676
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200677static void do_tty_hangup(struct work_struct *work)
678{
679 struct tty_struct *tty =
680 container_of(work, struct tty_struct, hangup_work);
681
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200682 __tty_hangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200683}
684
Alan Coxaf9b8972006-08-27 01:24:01 -0700685/**
686 * tty_hangup - trigger a hangup event
687 * @tty: tty to hangup
688 *
689 * A carrier loss (virtual or otherwise) has occurred on this like
690 * schedule a hangup sequence to run after this event.
691 */
692
Alan Cox37bdfb02008-02-08 04:18:47 -0800693void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
695#ifdef TTY_DEBUG_HANGUP
696 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
698#endif
699 schedule_work(&tty->hangup_work);
700}
701
702EXPORT_SYMBOL(tty_hangup);
703
Alan Coxaf9b8972006-08-27 01:24:01 -0700704/**
705 * tty_vhangup - process vhangup
706 * @tty: tty to hangup
707 *
708 * The user has asked via system call for the terminal to be hung up.
709 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200710 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700711 */
712
Alan Cox37bdfb02008-02-08 04:18:47 -0800713void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
715#ifdef TTY_DEBUG_HANGUP
716 char buf[64];
717
718 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
719#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200720 __tty_hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721}
Alan Cox37bdfb02008-02-08 04:18:47 -0800722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723EXPORT_SYMBOL(tty_vhangup);
724
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200725
Alan Coxaf9b8972006-08-27 01:24:01 -0700726/**
Alan Cox2cb59982008-10-13 10:40:30 +0100727 * tty_vhangup_self - process vhangup for own ctty
728 *
729 * Perform a vhangup on the current controlling tty
730 */
731
732void tty_vhangup_self(void)
733{
734 struct tty_struct *tty;
735
Alan Cox2cb59982008-10-13 10:40:30 +0100736 tty = get_current_tty();
737 if (tty) {
738 tty_vhangup(tty);
739 tty_kref_put(tty);
740 }
Alan Cox2cb59982008-10-13 10:40:30 +0100741}
742
743/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700744 * tty_hung_up_p - was tty hung up
745 * @filp: file pointer of tty
746 *
747 * Return true if the tty has been subject to a vhangup or a carrier
748 * loss
749 */
750
Alan Cox37bdfb02008-02-08 04:18:47 -0800751int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
753 return (filp->f_op == &hung_up_tty_fops);
754}
755
756EXPORT_SYMBOL(tty_hung_up_p);
757
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800758static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800759{
760 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800761 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800762 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800763 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800764}
765
Alan Coxaf9b8972006-08-27 01:24:01 -0700766/**
767 * disassociate_ctty - disconnect controlling tty
768 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700770 * This function is typically called only by the session leader, when
771 * it wants to disassociate itself from its controlling tty.
772 *
773 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
775 * (2) Clears the tty from being controlling the session
776 * (3) Clears the controlling tty for all processes in the
777 * session group.
778 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700779 * The argument on_exit is set to 1 if called when a process is
780 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
781 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800782 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200783 * BTM is taken for hysterical raisins, and held when
784 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800785 * tty_mutex is taken to protect tty
786 * ->siglock is taken to protect ->signal/->sighand
787 * tasklist_lock is taken to walk process list for sessions
788 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700790
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791void disassociate_ctty(int on_exit)
792{
793 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Alan Cox5ec93d12009-11-30 13:18:45 +0000795 if (!current->signal->leader)
796 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800798 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 if (tty) {
Jiri Slaby1411dc42011-11-09 21:33:18 +0100800 struct pid *tty_pgrp = get_pid(tty->pgrp);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200801 if (on_exit) {
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200802 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200803 tty_vhangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200804 }
Alan Cox452a00d2008-10-13 10:39:13 +0100805 tty_kref_put(tty);
Jiri Slaby1411dc42011-11-09 21:33:18 +0100806 if (tty_pgrp) {
807 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
808 if (!on_exit)
809 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
810 put_pid(tty_pgrp);
811 }
Eric W. Biederman680a9672007-02-12 00:52:52 -0800812 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800813 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800814 spin_lock_irq(&current->sighand->siglock);
815 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800816 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800817 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800818 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800819 kill_pgrp(old_pgrp, SIGHUP, on_exit);
820 kill_pgrp(old_pgrp, SIGCONT, on_exit);
821 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 return;
824 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800826 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700827 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800828 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800829 spin_unlock_irq(&current->sighand->siglock);
830
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800831 tty = get_current_tty();
832 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700833 unsigned long flags;
834 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800835 put_pid(tty->session);
836 put_pid(tty->pgrp);
837 tty->session = NULL;
838 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700839 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100840 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800841 } else {
842#ifdef TTY_DEBUG_HANGUP
843 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
844 " = NULL", tty);
845#endif
846 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
848 /* Now clear signal->tty under the lock */
849 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800850 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
853
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700854/**
855 *
856 * no_tty - Ensure the current process does not have a controlling tty
857 */
858void no_tty(void)
859{
Alan Cox3af502b2012-05-03 22:21:53 +0100860 /* FIXME: Review locking here. The tty_lock never covered any race
861 between a new association and proc_clear_tty but possible we need
862 to protect against this anyway */
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700863 struct task_struct *tsk = current;
Alan Cox5ec93d12009-11-30 13:18:45 +0000864 disassociate_ctty(0);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700865 proc_clear_tty(tsk);
866}
867
Alan Coxaf9b8972006-08-27 01:24:01 -0700868
869/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200870 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700871 * @tty: tty to stop
872 *
873 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200874 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700875 * on an already stopped device and will not re-call the driver
876 * method.
877 *
878 * This functionality is used by both the line disciplines for
879 * halting incoming flow and by the driver. It may therefore be
880 * called from any context, may be under the tty atomic_write_lock
881 * but not always.
882 *
883 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700884 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700885 */
886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887void stop_tty(struct tty_struct *tty)
888{
Alan Cox04f378b2008-04-30 00:53:29 -0700889 unsigned long flags;
890 spin_lock_irqsave(&tty->ctrl_lock, flags);
891 if (tty->stopped) {
892 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700894 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 tty->stopped = 1;
896 if (tty->link && tty->link->packet) {
897 tty->ctrl_status &= ~TIOCPKT_START;
898 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700899 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 }
Alan Cox04f378b2008-04-30 00:53:29 -0700901 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700902 if (tty->ops->stop)
903 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904}
905
906EXPORT_SYMBOL(stop_tty);
907
Alan Coxaf9b8972006-08-27 01:24:01 -0700908/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200909 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700910 * @tty: tty to start
911 *
912 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200913 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700914 * is the tty was previous stopped and is being started then the
915 * driver start method is invoked and the line discipline woken.
916 *
917 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700918 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700919 */
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921void start_tty(struct tty_struct *tty)
922{
Alan Cox04f378b2008-04-30 00:53:29 -0700923 unsigned long flags;
924 spin_lock_irqsave(&tty->ctrl_lock, flags);
925 if (!tty->stopped || tty->flow_stopped) {
926 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700928 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 tty->stopped = 0;
930 if (tty->link && tty->link->packet) {
931 tty->ctrl_status &= ~TIOCPKT_STOP;
932 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700933 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 }
Alan Cox04f378b2008-04-30 00:53:29 -0700935 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700936 if (tty->ops->start)
937 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 /* If we have a running line discipline it may need kicking */
939 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940}
941
942EXPORT_SYMBOL(start_tty);
943
Alan Coxaf9b8972006-08-27 01:24:01 -0700944/**
945 * tty_read - read method for tty device files
946 * @file: pointer to tty file
947 * @buf: user buffer
948 * @count: size of user buffer
949 * @ppos: unused
950 *
951 * Perform the read system call function on this terminal device. Checks
952 * for hung up devices before calling the line discipline method.
953 *
954 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700955 * Locks the line discipline internally while needed. Multiple
956 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700957 */
958
Alan Cox37bdfb02008-02-08 04:18:47 -0800959static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 loff_t *ppos)
961{
962 int i;
Nick Piggind996b622010-08-18 04:37:36 +1000963 struct inode *inode = file->f_path.dentry->d_inode;
964 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 struct tty_ldisc *ld;
966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 if (tty_paranoia_check(tty, inode, "tty_read"))
968 return -EIO;
969 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
970 return -EIO;
971
972 /* We want to wait for the line discipline to sort out in this
973 situation */
974 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100975 if (ld->ops->read)
976 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 else
978 i = -EIO;
979 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 if (i > 0)
981 inode->i_atime = current_fs_time(inode->i_sb);
982 return i;
983}
984
Alan Cox9c1729d2007-07-15 23:39:43 -0700985void tty_write_unlock(struct tty_struct *tty)
Jiri Slaby83c67572011-04-20 10:43:18 +0200986 __releases(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700987{
988 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700989 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700990}
991
992int tty_write_lock(struct tty_struct *tty, int ndelay)
Jiri Slaby83c67572011-04-20 10:43:18 +0200993 __acquires(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700994{
995 if (!mutex_trylock(&tty->atomic_write_lock)) {
996 if (ndelay)
997 return -EAGAIN;
998 if (mutex_lock_interruptible(&tty->atomic_write_lock))
999 return -ERESTARTSYS;
1000 }
1001 return 0;
1002}
1003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004/*
1005 * Split writes up in sane blocksizes to avoid
1006 * denial-of-service type attacks
1007 */
1008static inline ssize_t do_tty_write(
1009 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1010 struct tty_struct *tty,
1011 struct file *file,
1012 const char __user *buf,
1013 size_t count)
1014{
Alan Cox9c1729d2007-07-15 23:39:43 -07001015 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -08001017
Alan Cox9c1729d2007-07-15 23:39:43 -07001018 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1019 if (ret < 0)
1020 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
1022 /*
1023 * We chunk up writes into a temporary buffer. This
1024 * simplifies low-level drivers immensely, since they
1025 * don't have locking issues and user mode accesses.
1026 *
1027 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1028 * big chunk-size..
1029 *
1030 * The default chunk-size is 2kB, because the NTTY
1031 * layer has problems with bigger chunks. It will
1032 * claim to be able to handle more characters than
1033 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001034 *
1035 * FIXME: This can probably go away now except that 64K chunks
1036 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 */
1038 chunk = 2048;
1039 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1040 chunk = 65536;
1041 if (count < chunk)
1042 chunk = count;
1043
Ingo Molnar70522e12006-03-23 03:00:31 -08001044 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001046 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
1048 if (chunk < 1024)
1049 chunk = 1024;
1050
Jason Wessel402fda92008-10-13 10:45:36 +01001051 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1052 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001053 ret = -ENOMEM;
1054 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 }
1056 kfree(tty->write_buf);
1057 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001058 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 }
1060
1061 /* Do the write .. */
1062 for (;;) {
1063 size_t size = count;
1064 if (size > chunk)
1065 size = chunk;
1066 ret = -EFAULT;
1067 if (copy_from_user(tty->write_buf, buf, size))
1068 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 if (ret <= 0)
1071 break;
1072 written += ret;
1073 buf += ret;
1074 count -= ret;
1075 if (!count)
1076 break;
1077 ret = -ERESTARTSYS;
1078 if (signal_pending(current))
1079 break;
1080 cond_resched();
1081 }
1082 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001083 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 inode->i_mtime = current_fs_time(inode->i_sb);
1085 ret = written;
1086 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001087out:
1088 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 return ret;
1090}
1091
Alan Cox95f9bfc2008-10-13 10:39:23 +01001092/**
1093 * tty_write_message - write a message to a certain tty, not just the console.
1094 * @tty: the destination tty_struct
1095 * @msg: the message to write
1096 *
1097 * This is used for messages that need to be redirected to a specific tty.
1098 * We don't put it into the syslog queue right now maybe in the future if
1099 * really needed.
1100 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001101 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001102 */
1103
1104void tty_write_message(struct tty_struct *tty, char *msg)
1105{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001106 if (tty) {
1107 mutex_lock(&tty->atomic_write_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01001108 tty_lock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001109 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001110 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001111 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001112 } else
Alan Cox89c8d912012-08-08 16:30:13 +01001113 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001114 tty_write_unlock(tty);
1115 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001116 return;
1117}
1118
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
Alan Coxaf9b8972006-08-27 01:24:01 -07001120/**
1121 * tty_write - write method for tty device file
1122 * @file: tty file pointer
1123 * @buf: user data to write
1124 * @count: bytes to write
1125 * @ppos: unused
1126 *
1127 * Write data to a tty device via the line discipline.
1128 *
1129 * Locking:
1130 * Locks the line discipline as required
1131 * Writes to the tty driver are serialized by the atomic_write_lock
1132 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001133 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001134 */
1135
Alan Cox37bdfb02008-02-08 04:18:47 -08001136static ssize_t tty_write(struct file *file, const char __user *buf,
1137 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138{
Josef Sipeka7113a92006-12-08 02:36:55 -08001139 struct inode *inode = file->f_path.dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10001140 struct tty_struct *tty = file_tty(file);
1141 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 if (tty_paranoia_check(tty, inode, "tty_write"))
1145 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001146 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001147 (test_bit(TTY_IO_ERROR, &tty->flags)))
1148 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001149 /* Short term debug to catch buggy drivers */
1150 if (tty->ops->write_room == NULL)
1151 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1152 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001153 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001154 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 ret = -EIO;
1156 else
Alan Coxa352def2008-07-16 21:53:12 +01001157 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 tty_ldisc_deref(ld);
1159 return ret;
1160}
1161
Alan Cox37bdfb02008-02-08 04:18:47 -08001162ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1163 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164{
1165 struct file *p = NULL;
1166
1167 spin_lock(&redirect_lock);
Al Virocb0942b2012-08-27 14:48:26 -04001168 if (redirect)
1169 p = get_file(redirect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 spin_unlock(&redirect_lock);
1171
1172 if (p) {
1173 ssize_t res;
1174 res = vfs_write(p, buf, count, &p->f_pos);
1175 fput(p);
1176 return res;
1177 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 return tty_write(file, buf, count, ppos);
1179}
1180
1181static char ptychar[] = "pqrstuvwxyzabcde";
1182
Alan Coxaf9b8972006-08-27 01:24:01 -07001183/**
1184 * pty_line_name - generate name for a pty
1185 * @driver: the tty driver in use
1186 * @index: the minor number
1187 * @p: output buffer of at least 6 bytes
1188 *
1189 * Generate a name from a driver reference and write it to the output
1190 * buffer.
1191 *
1192 * Locking: None
1193 */
1194static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195{
1196 int i = index + driver->name_base;
1197 /* ->name is initialized to "ttyp", but "tty" is expected */
1198 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001199 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1200 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201}
1202
Alan Coxaf9b8972006-08-27 01:24:01 -07001203/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001204 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001205 * @driver: the tty driver in use
1206 * @index: the minor number
1207 * @p: output buffer of at least 7 bytes
1208 *
1209 * Generate a name from a driver reference and write it to the output
1210 * buffer.
1211 *
1212 * Locking: None
1213 */
1214static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215{
Jiri Slaby0019b402012-08-08 22:26:43 +02001216 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
1217 strcpy(p, driver->name);
1218 else
1219 sprintf(p, "%s%d", driver->name, index + driver->name_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220}
1221
Alan Cox99f1fe12008-10-13 10:42:00 +01001222/**
1223 * tty_driver_lookup_tty() - find an existing tty, if any
1224 * @driver: the driver for the tty
1225 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001226 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001227 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001228 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001229 * Locking: tty_mutex must be held. If tty is found, the mutex must
1230 * be held until the 'fast-open' is also done. Will change once we
1231 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001232 */
Jason Wessela47d5452009-01-02 13:43:04 +00001233static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001234 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001235{
Alan Cox99f1fe12008-10-13 10:42:00 +01001236 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001237 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001238
Jiri Slabyd4834262012-03-05 14:51:53 +01001239 return driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001240}
1241
Alan Cox99f1fe12008-10-13 10:42:00 +01001242/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001243 * tty_init_termios - helper for termios setup
1244 * @tty: the tty to set up
1245 *
1246 * Initialise the termios structures for this tty. Thus runs under
1247 * the tty_mutex currently so we can be relaxed about ordering.
1248 */
1249
1250int tty_init_termios(struct tty_struct *tty)
1251{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001252 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001253 int idx = tty->index;
1254
Alan Cox36b3c072012-07-17 17:06:57 +01001255 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1256 tty->termios = tty->driver->init_termios;
1257 else {
1258 /* Check for lazy saved data */
1259 tp = tty->driver->termios[idx];
1260 if (tp != NULL)
1261 tty->termios = *tp;
1262 else
1263 tty->termios = tty->driver->init_termios;
Alan Coxbf970ee2008-10-13 10:42:39 +01001264 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001265 /* Compatibility until drivers always set this */
Alan Coxadc8d742012-07-14 15:31:47 +01001266 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1267 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001268 return 0;
1269}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001270EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001271
Jiri Slaby66d450e2012-01-30 21:14:28 +01001272int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1273{
1274 int ret = tty_init_termios(tty);
1275 if (ret)
1276 return ret;
1277
1278 tty_driver_kref_get(driver);
1279 tty->count++;
1280 driver->ttys[tty->index] = tty;
1281 return 0;
1282}
1283EXPORT_SYMBOL_GPL(tty_standard_install);
1284
Alan Coxbf970ee2008-10-13 10:42:39 +01001285/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001286 * tty_driver_install_tty() - install a tty entry in the driver
1287 * @driver: the driver for the tty
1288 * @tty: the tty
1289 *
1290 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001291 * will be set by the time this is called. This method is responsible
1292 * for ensuring any need additional structures are allocated and
1293 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001294 *
1295 * Locking: tty_mutex for now
1296 */
1297static int tty_driver_install_tty(struct tty_driver *driver,
1298 struct tty_struct *tty)
1299{
Jiri Slaby66d450e2012-01-30 21:14:28 +01001300 return driver->ops->install ? driver->ops->install(driver, tty) :
1301 tty_standard_install(driver, tty);
Alan Cox8b0a88d2008-10-13 10:42:19 +01001302}
1303
1304/**
1305 * tty_driver_remove_tty() - remove a tty from the driver tables
1306 * @driver: the driver for the tty
1307 * @idx: the minor number
1308 *
1309 * Remvoe a tty object from the driver tables. The tty->index field
1310 * will be set by the time this is called.
1311 *
1312 * Locking: tty_mutex for now
1313 */
Jiri Slaby24d406a2011-08-10 14:59:28 +02001314void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +01001315{
1316 if (driver->ops->remove)
1317 driver->ops->remove(driver, tty);
1318 else
1319 driver->ttys[tty->index] = NULL;
1320}
1321
1322/*
1323 * tty_reopen() - fast re-open of an open tty
1324 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001325 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001326 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001327 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001328 * Locking: tty_mutex must be held from the time the tty was found
1329 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001330 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001331static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001332{
1333 struct tty_driver *driver = tty->driver;
1334
Jiri Slabye2efafb2010-11-29 10:16:53 +01001335 if (test_bit(TTY_CLOSING, &tty->flags) ||
Jiri Slabyacfa7472010-11-29 10:16:54 +01001336 test_bit(TTY_HUPPING, &tty->flags) ||
Jiri Slabye2efafb2010-11-29 10:16:53 +01001337 test_bit(TTY_LDISC_CHANGING, &tty->flags))
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001338 return -EIO;
1339
1340 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1341 driver->subtype == PTY_TYPE_MASTER) {
1342 /*
1343 * special case for PTY masters: only one open permitted,
1344 * and the slave side open count is incremented as well.
1345 */
1346 if (tty->count)
1347 return -EIO;
1348
1349 tty->link->count++;
1350 }
1351 tty->count++;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001352
Alan Cox1aa4bed2009-06-16 17:01:33 +01001353 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001354 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001355 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001356
1357 return 0;
1358}
1359
Alan Coxaf9b8972006-08-27 01:24:01 -07001360/**
Alan Coxd81ed102008-10-13 10:41:42 +01001361 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001362 * @driver: tty driver we are opening a device on
1363 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001364 * @ret_tty: returned tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -07001365 *
1366 * Prepare a tty device. This may not be a "new" clean device but
1367 * could also be an active device. The pty drivers require special
1368 * handling because of this.
1369 *
1370 * Locking:
1371 * The function is called under the tty_mutex, which
1372 * protects us from the tty struct or driver itself going away.
1373 *
1374 * On exit the tty device has the line discipline attached and
1375 * a reference count of 1. If a pair was created for pty/tty use
1376 * and the other was a pty master then it too has a reference count of 1.
1377 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001379 * failed open. The new code protects the open with a mutex, so it's
1380 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 * relaxed for the (most common) case of reopening a tty.
1382 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001383
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001384struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385{
Alan Coxbf970ee2008-10-13 10:42:39 +01001386 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001387 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 /*
1390 * First time open is complex, especially for PTY devices.
1391 * This code guarantees that either everything succeeds and the
1392 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001393 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 * and locked termios may be retained.)
1395 */
1396
Alan Cox73ec06f2008-10-13 10:42:29 +01001397 if (!try_module_get(driver->owner))
1398 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 tty = alloc_tty_struct();
Jiri Slabyd5543502011-03-23 10:48:32 +01001401 if (!tty) {
1402 retval = -ENOMEM;
1403 goto err_module_put;
1404 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001405 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406
Alan Cox89c8d912012-08-08 16:30:13 +01001407 tty_lock(tty);
Alan Cox73ec06f2008-10-13 10:42:29 +01001408 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001409 if (retval < 0)
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001410 goto err_deinit_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001411
Jiri Slaby04831dc2012-06-04 13:35:36 +02001412 if (!tty->port)
1413 tty->port = driver->ports[idx];
1414
Jiri Slaby5d4121c2012-08-17 14:27:52 +02001415 WARN_RATELIMIT(!tty->port,
1416 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1417 __func__, tty->driver->name);
1418
Jiri Slaby967fab62012-10-18 22:26:46 +02001419 tty->port->itty = tty;
1420
Alan Cox37bdfb02008-02-08 04:18:47 -08001421 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001423 * If we fail here just call release_tty to clean up. No need
1424 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001426 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001427 if (retval)
Jiri Slabyd5543502011-03-23 10:48:32 +01001428 goto err_release_tty;
Alan Cox89c8d912012-08-08 16:30:13 +01001429 /* Return the tty locked so that it cannot vanish under the caller */
Alan Cox73ec06f2008-10-13 10:42:29 +01001430 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001432err_deinit_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001433 tty_unlock(tty);
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001434 deinitialize_tty_struct(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001435 free_tty_struct(tty);
1436err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001438 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001440 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001441err_release_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001442 tty_unlock(tty);
Manuel Zerpies5a3c6b22011-06-16 14:07:22 +02001443 printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001444 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001445 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001446 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447}
1448
Alan Coxfeebed62008-10-13 10:41:30 +01001449void tty_free_termios(struct tty_struct *tty)
1450{
1451 struct ktermios *tp;
1452 int idx = tty->index;
Alan Cox36b3c072012-07-17 17:06:57 +01001453
1454 /* If the port is going to reset then it has no termios to save */
1455 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1456 return;
1457
1458 /* Stash the termios data */
1459 tp = tty->driver->termios[idx];
1460 if (tp == NULL) {
1461 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1462 if (tp == NULL) {
1463 pr_warn("tty: no memory to save termios state.\n");
1464 return;
1465 }
Dan Carpenter4ac5d702012-07-24 12:51:52 +01001466 tty->driver->termios[idx] = tp;
Alan Coxfeebed62008-10-13 10:41:30 +01001467 }
Alan Cox36b3c072012-07-17 17:06:57 +01001468 *tp = tty->termios;
Alan Coxfeebed62008-10-13 10:41:30 +01001469}
1470EXPORT_SYMBOL(tty_free_termios);
1471
Alan Coxfeebed62008-10-13 10:41:30 +01001472
Alan Coxaf9b8972006-08-27 01:24:01 -07001473/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001474 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001475 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001476 *
1477 * Releases memory associated with a tty structure, and clears out the
1478 * driver table slots. This function is called when a device is no longer
1479 * in use. It also gets called when setup of a device fails.
1480 *
1481 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -07001482 * takes the file list lock internally when working on the list
1483 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001484 *
1485 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001486 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 */
Alan Coxb50989d2009-09-19 13:13:22 -07001488static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489{
Alan Coxb50989d2009-09-19 13:13:22 -07001490 struct tty_struct *tty =
1491 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001492 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493
Dave Youngf278a2f2009-09-27 16:00:42 +00001494 if (tty->ops->cleanup)
1495 tty->ops->cleanup(tty);
1496
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001498 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001499 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001500
Nick Pigginee2ffa02010-08-18 04:37:35 +10001501 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 list_del_init(&tty->tty_files);
Nick Pigginee2ffa02010-08-18 04:37:35 +10001503 spin_unlock(&tty_files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001504
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001505 put_pid(tty->pgrp);
1506 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 free_tty_struct(tty);
1508}
1509
Alan Coxb50989d2009-09-19 13:13:22 -07001510static void queue_release_one_tty(struct kref *kref)
1511{
1512 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001513
Alan Coxb50989d2009-09-19 13:13:22 -07001514 /* The hangup queue is now free so we can reuse it rather than
1515 waste a chunk of memory for each port */
1516 INIT_WORK(&tty->hangup_work, release_one_tty);
1517 schedule_work(&tty->hangup_work);
1518}
1519
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001520/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001521 * tty_kref_put - release a tty kref
1522 * @tty: tty device
1523 *
1524 * Release a reference to a tty device and if need be let the kref
1525 * layer destruct the object for us
1526 */
1527
1528void tty_kref_put(struct tty_struct *tty)
1529{
1530 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001531 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001532}
1533EXPORT_SYMBOL(tty_kref_put);
1534
1535/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001536 * release_tty - release tty structure memory
1537 *
1538 * Release both @tty and a possible linked partner (think pty pair),
1539 * and decrement the refcount of the backing module.
1540 *
1541 * Locking:
Alan Coxd1552552012-07-27 18:02:54 +01001542 * tty_mutex
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001543 * takes the file list lock internally when working on the list
1544 * of ttys that the driver keeps.
Alan Cox9c9f4de2008-10-13 10:37:26 +01001545 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001546 */
1547static void release_tty(struct tty_struct *tty, int idx)
1548{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001549 /* This should always be true but check for the moment */
1550 WARN_ON(tty->index != idx);
Alan Coxd1552552012-07-27 18:02:54 +01001551 WARN_ON(!mutex_is_locked(&tty_mutex));
Alan Cox36b3c072012-07-17 17:06:57 +01001552 if (tty->ops->shutdown)
1553 tty->ops->shutdown(tty);
1554 tty_free_termios(tty);
1555 tty_driver_remove_tty(tty->driver, tty);
Jiri Slaby967fab62012-10-18 22:26:46 +02001556 tty->port->itty = NULL;
Alan Cox36b3c072012-07-17 17:06:57 +01001557
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001558 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001559 tty_kref_put(tty->link);
1560 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001561}
1562
Alan Coxeeb89d92009-11-30 13:18:29 +00001563/**
Jiri Slaby955787ca2011-11-11 10:47:23 +01001564 * tty_release_checks - check a tty before real release
1565 * @tty: tty to check
1566 * @o_tty: link of @tty (if any)
1567 * @idx: index of the tty
1568 *
1569 * Performs some paranoid checking before true release of the @tty.
1570 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1571 */
1572static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,
1573 int idx)
1574{
1575#ifdef TTY_PARANOIA_CHECK
1576 if (idx < 0 || idx >= tty->driver->num) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001577 printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1578 __func__, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001579 return -1;
1580 }
1581
1582 /* not much to check for devpts */
1583 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1584 return 0;
1585
1586 if (tty != tty->driver->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001587 printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1588 __func__, idx, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001589 return -1;
1590 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001591 if (tty->driver->other) {
1592 if (o_tty != tty->driver->other->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001593 printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1594 __func__, idx, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001595 return -1;
1596 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001597 if (o_tty->link != tty) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001598 printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001599 return -1;
1600 }
1601 }
1602#endif
1603 return 0;
1604}
1605
1606/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001607 * tty_release - vfs callback for close
1608 * @inode: inode of tty
1609 * @filp: file pointer for handle to tty
1610 *
1611 * Called the last time each file handle is closed that references
1612 * this tty. There may however be several such references.
1613 *
1614 * Locking:
1615 * Takes bkl. See tty_release_dev
1616 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 * Even releasing the tty structures is a tricky business.. We have
1618 * to be very careful that the structures are all released at the
1619 * same time, as interrupts might otherwise get the wrong pointers.
1620 *
1621 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1622 * lead to double frees or releasing memory still in use.
1623 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001624
1625int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626{
Nick Piggind996b622010-08-18 04:37:36 +10001627 struct tty_struct *tty = file_tty(filp);
1628 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 int pty_master, tty_closing, o_tty_closing, do_sleep;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 int idx;
1631 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001632
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001633 if (tty_paranoia_check(tty, inode, __func__))
Alan Coxeeb89d92009-11-30 13:18:29 +00001634 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
Alan Cox89c8d912012-08-08 16:30:13 +01001636 tty_lock(tty);
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001637 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Arnd Bergmannec79d602010-06-01 22:53:01 +02001639 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
1641 idx = tty->index;
1642 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1643 tty->driver->subtype == PTY_TYPE_MASTER);
Alan Cox89c8d912012-08-08 16:30:13 +01001644 /* Review: parallel close */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 o_tty = tty->link;
1646
Jiri Slaby955787ca2011-11-11 10:47:23 +01001647 if (tty_release_checks(tty, o_tty, idx)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001648 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001649 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
1652#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001653 printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1654 tty_name(tty, buf), tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655#endif
1656
Alan Coxf34d7a52008-04-30 00:54:13 -07001657 if (tty->ops->close)
1658 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659
Alan Cox89c8d912012-08-08 16:30:13 +01001660 tty_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 /*
1662 * Sanity check: if tty->count is going to zero, there shouldn't be
1663 * any waiters on tty->read_wait or tty->write_wait. We test the
1664 * wait queues and kick everyone out _before_ actually starting to
1665 * close. This ensures that we won't block while releasing the tty
1666 * structure.
1667 *
1668 * The test for the o_tty closing is necessary, since the master and
1669 * slave sides may close in any order. If the slave side closes out
1670 * first, its count will be one, since the master side holds an open.
1671 * Thus this test wouldn't be triggered at the time the slave closes,
1672 * so we do it now.
1673 *
1674 * Note that it's possible for the tty to be opened again while we're
1675 * flushing out waiters. By recalculating the closing flags before
1676 * each iteration we avoid any problems.
1677 */
1678 while (1) {
1679 /* Guard against races with tty->count changes elsewhere and
1680 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001681
Ingo Molnar70522e12006-03-23 03:00:31 -08001682 mutex_lock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01001683 tty_lock_pair(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 tty_closing = tty->count <= 1;
1685 o_tty_closing = o_tty &&
1686 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 do_sleep = 0;
1688
1689 if (tty_closing) {
1690 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001691 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 do_sleep++;
1693 }
1694 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001695 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 do_sleep++;
1697 }
1698 }
1699 if (o_tty_closing) {
1700 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001701 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 do_sleep++;
1703 }
1704 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001705 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 do_sleep++;
1707 }
1708 }
1709 if (!do_sleep)
1710 break;
1711
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001712 printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1713 __func__, tty_name(tty, buf));
Alan Cox89c8d912012-08-08 16:30:13 +01001714 tty_unlock_pair(tty, o_tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08001715 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001717 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
1719 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001720 * The closing flags are now consistent with the open counts on
1721 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 * block, so it's safe to proceed with closing.
Alan Coxd1552552012-07-27 18:02:54 +01001723 *
1724 * We must *not* drop the tty_mutex until we ensure that a further
1725 * entry into tty_open can not pick up this tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 if (pty_master) {
1728 if (--o_tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001729 printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1730 __func__, o_tty->count, tty_name(o_tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 o_tty->count = 0;
1732 }
1733 }
1734 if (--tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001735 printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1736 __func__, tty->count, tty_name(tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 tty->count = 0;
1738 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001739
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 /*
1741 * We've decremented tty->count, so we need to remove this file
1742 * descriptor off the tty->tty_files list; this serves two
1743 * purposes:
1744 * - check_tty_count sees the correct number of file descriptors
1745 * associated with this tty.
1746 * - do_tty_hangup no longer sees this file descriptor as
1747 * something that needs to be handled for hangups.
1748 */
Nick Piggind996b622010-08-18 04:37:36 +10001749 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
1751 /*
1752 * Perform some housekeeping before deciding whether to return.
1753 *
1754 * Set the TTY_CLOSING flag if this was the last open. In the
1755 * case of a pty we may have to wait around for the other side
1756 * to close, and TTY_CLOSING makes sure we can't be reopened.
1757 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001758 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001760 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 set_bit(TTY_CLOSING, &o_tty->flags);
1762
1763 /*
1764 * If _either_ side is closing, make sure there aren't any
1765 * processes that still think tty or o_tty is their controlling
1766 * tty.
1767 */
1768 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001770 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001772 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 read_unlock(&tasklist_lock);
1774 }
1775
Ingo Molnar70522e12006-03-23 03:00:31 -08001776 mutex_unlock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01001777 tty_unlock_pair(tty, o_tty);
Alan Coxd1552552012-07-27 18:02:54 +01001778 /* At this point the TTY_CLOSING flag should ensure a dead tty
1779 cannot be re-opened by a racing opener */
Paul Fulghumda965822006-02-14 13:53:00 -08001780
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 /* check whether both sides are closing ... */
Alan Coxd1552552012-07-27 18:02:54 +01001782 if (!tty_closing || (o_tty && !o_tty_closing))
Alan Coxeeb89d92009-11-30 13:18:29 +00001783 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001786 printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787#endif
1788 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001789 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001791 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001793 * The release_tty function takes care of the details of clearing
Alan Cox89c8d912012-08-08 16:30:13 +01001794 * the slots and preserving the termios structure. The tty_unlock_pair
1795 * should be safe as we keep a kref while the tty is locked (so the
1796 * unlock never unlocks a freed tty).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 */
Alan Coxd1552552012-07-27 18:02:54 +01001798 mutex_lock(&tty_mutex);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001799 release_tty(tty, idx);
Alan Coxd1552552012-07-27 18:02:54 +01001800 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
Alan Coxeeb89d92009-11-30 13:18:29 +00001802 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803}
1804
Alan Coxaf9b8972006-08-27 01:24:01 -07001805/**
Jiri Slabyb82154a2011-11-09 21:33:19 +01001806 * tty_open_current_tty - get tty of current task for open
1807 * @device: device number
1808 * @filp: file pointer to tty
1809 * @return: tty of the current task iff @device is /dev/tty
1810 *
1811 * We cannot return driver and index like for the other nodes because
1812 * devpts will not work then. It expects inodes to be from devpts FS.
Alan Cox3af502b2012-05-03 22:21:53 +01001813 *
1814 * We need to move to returning a refcounted object from all the lookup
1815 * paths including this one.
Jiri Slabyb82154a2011-11-09 21:33:19 +01001816 */
1817static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1818{
1819 struct tty_struct *tty;
1820
1821 if (device != MKDEV(TTYAUX_MAJOR, 0))
1822 return NULL;
1823
1824 tty = get_current_tty();
1825 if (!tty)
1826 return ERR_PTR(-ENXIO);
1827
1828 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1829 /* noctty = 1; */
1830 tty_kref_put(tty);
1831 /* FIXME: we put a reference and return a TTY! */
Alan Cox3af502b2012-05-03 22:21:53 +01001832 /* This is only safe because the caller holds tty_mutex */
Jiri Slabyb82154a2011-11-09 21:33:19 +01001833 return tty;
1834}
1835
1836/**
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001837 * tty_lookup_driver - lookup a tty driver for a given device file
1838 * @device: device number
1839 * @filp: file pointer to tty
1840 * @noctty: set if the device should not become a controlling tty
1841 * @index: index for the device in the @return driver
1842 * @return: driver for this inode (with increased refcount)
1843 *
1844 * If @return is not erroneous, the caller is responsible to decrement the
1845 * refcount by tty_driver_kref_put.
1846 *
1847 * Locking: tty_mutex protects get_tty_driver
1848 */
1849static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1850 int *noctty, int *index)
1851{
1852 struct tty_driver *driver;
1853
Jiri Slaby2cd00502011-11-09 21:33:22 +01001854 switch (device) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001855#ifdef CONFIG_VT
Jiri Slaby2cd00502011-11-09 21:33:22 +01001856 case MKDEV(TTY_MAJOR, 0): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001857 extern struct tty_driver *console_driver;
1858 driver = tty_driver_kref_get(console_driver);
1859 *index = fg_console;
1860 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001861 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001862 }
1863#endif
Jiri Slaby2cd00502011-11-09 21:33:22 +01001864 case MKDEV(TTYAUX_MAJOR, 1): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001865 struct tty_driver *console_driver = console_device(index);
1866 if (console_driver) {
1867 driver = tty_driver_kref_get(console_driver);
1868 if (driver) {
1869 /* Don't let /dev/console block */
1870 filp->f_flags |= O_NONBLOCK;
1871 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001872 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001873 }
1874 }
1875 return ERR_PTR(-ENODEV);
1876 }
Jiri Slaby2cd00502011-11-09 21:33:22 +01001877 default:
1878 driver = get_tty_driver(device, index);
1879 if (!driver)
1880 return ERR_PTR(-ENODEV);
1881 break;
1882 }
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001883 return driver;
1884}
1885
1886/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001887 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001888 * @inode: inode of device file
1889 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001891 * tty_open and tty_release keep up the tty count that contains the
1892 * number of opens done on a tty. We cannot use the inode-count, as
1893 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001895 * Open-counting is needed for pty masters, as well as for keeping
1896 * track of serial lines: DTR is dropped when the last close happens.
1897 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1898 *
1899 * The termios state of a pty is reset on first open so that
1900 * settings don't persist across reuse.
1901 *
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001902 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001903 * tty->count should protect the rest.
1904 * ->siglock protects ->signal/->sighand
Alan Cox89c8d912012-08-08 16:30:13 +01001905 *
1906 * Note: the tty_unlock/lock cases without a ref are only safe due to
1907 * tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001909
Alan Coxeeb89d92009-11-30 13:18:29 +00001910static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911{
Jiri Slabyb82154a2011-11-09 21:33:19 +01001912 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 int noctty, retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01001914 struct tty_driver *driver = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 int index;
1916 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001917 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918
1919 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001920
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921retry_open:
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02001922 retval = tty_alloc_file(filp);
1923 if (retval)
1924 return -ENOMEM;
1925
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 noctty = filp->f_flags & O_NOCTTY;
1927 index = -1;
1928 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001929
Ingo Molnar70522e12006-03-23 03:00:31 -08001930 mutex_lock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01001931 /* This is protected by the tty_mutex */
Jiri Slabyb82154a2011-11-09 21:33:19 +01001932 tty = tty_open_current_tty(device, filp);
1933 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001934 retval = PTR_ERR(tty);
1935 goto err_unlock;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001936 } else if (!tty) {
1937 driver = tty_lookup_driver(device, filp, &noctty, &index);
1938 if (IS_ERR(driver)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001939 retval = PTR_ERR(driver);
1940 goto err_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001943 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001944 tty = tty_driver_lookup_tty(driver, inode, index);
Eric Paris808ffa32009-01-27 11:50:37 +00001945 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001946 retval = PTR_ERR(tty);
1947 goto err_unlock;
Eric Paris808ffa32009-01-27 11:50:37 +00001948 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001949 }
1950
1951 if (tty) {
Alan Cox89c8d912012-08-08 16:30:13 +01001952 tty_lock(tty);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001953 retval = tty_reopen(tty);
Alan Cox89c8d912012-08-08 16:30:13 +01001954 if (retval < 0) {
1955 tty_unlock(tty);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001956 tty = ERR_PTR(retval);
Alan Cox89c8d912012-08-08 16:30:13 +01001957 }
1958 } else /* Returns with the tty_lock held for now */
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001959 tty = tty_init_dev(driver, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001960
Ingo Molnar70522e12006-03-23 03:00:31 -08001961 mutex_unlock(&tty_mutex);
Jiri Slabyb82154a2011-11-09 21:33:19 +01001962 if (driver)
1963 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001964 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001965 retval = PTR_ERR(tty);
1966 goto err_file;
Alan Coxeeb89d92009-11-30 13:18:29 +00001967 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02001969 tty_add_file(tty, filp);
Nick Piggind996b622010-08-18 04:37:36 +10001970
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001971 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1973 tty->driver->subtype == PTY_TYPE_MASTER)
1974 noctty = 1;
1975#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001976 printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977#endif
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03001978 if (tty->ops->open)
1979 retval = tty->ops->open(tty, filp);
1980 else
1981 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 filp->f_flags = saved_flags;
1983
Alan Cox37bdfb02008-02-08 04:18:47 -08001984 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1985 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 retval = -EBUSY;
1987
1988 if (retval) {
1989#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001990 printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
1991 retval, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992#endif
Alan Cox89c8d912012-08-08 16:30:13 +01001993 tty_unlock(tty); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00001994 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001995 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001997
1998 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002000
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 schedule();
2002 /*
2003 * Need to reset f_op in case a hangup happened.
2004 */
2005 if (filp->f_op == &hung_up_tty_fops)
2006 filp->f_op = &tty_fops;
2007 goto retry_open;
2008 }
Alan Cox89c8d912012-08-08 16:30:13 +01002009 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00002010
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002011
2012 mutex_lock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01002013 tty_lock(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002014 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 if (!noctty &&
2016 current->signal->leader &&
2017 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002018 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07002019 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002020 spin_unlock_irq(&current->sighand->siglock);
Alan Cox89c8d912012-08-08 16:30:13 +01002021 tty_unlock(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002022 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 return 0;
Jiri Slabyba5db442011-11-09 21:33:21 +01002024err_unlock:
Jiri Slabyba5db442011-11-09 21:33:21 +01002025 mutex_unlock(&tty_mutex);
2026 /* after locks to avoid deadlock */
2027 if (!IS_ERR_OR_NULL(driver))
2028 tty_driver_kref_put(driver);
2029err_file:
2030 tty_free_file(filp);
2031 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032}
2033
Jonathan Corbet39d95b92008-05-16 09:10:50 -06002034
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035
Alan Coxaf9b8972006-08-27 01:24:01 -07002036/**
2037 * tty_poll - check tty status
2038 * @filp: file being polled
2039 * @wait: poll wait structures to update
2040 *
2041 * Call the line discipline polling method to obtain the poll
2042 * status of the device.
2043 *
2044 * Locking: locks called line discipline but ldisc poll method
2045 * may be re-entered freely by other callers.
2046 */
2047
Alan Cox37bdfb02008-02-08 04:18:47 -08002048static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049{
Nick Piggind996b622010-08-18 04:37:36 +10002050 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 struct tty_ldisc *ld;
2052 int ret = 0;
2053
Josef Sipeka7113a92006-12-08 02:36:55 -08002054 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002056
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002058 if (ld->ops->poll)
2059 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 tty_ldisc_deref(ld);
2061 return ret;
2062}
2063
Arnd Bergmannec79d602010-06-01 22:53:01 +02002064static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065{
Nick Piggind996b622010-08-18 04:37:36 +10002066 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07002067 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002068 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069
Josef Sipeka7113a92006-12-08 02:36:55 -08002070 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002071 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08002072
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 retval = fasync_helper(fd, filp, on, &tty->fasync);
2074 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002075 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076
2077 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002078 enum pid_type type;
2079 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 if (!waitqueue_active(&tty->read_wait))
2081 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07002082 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002083 if (tty->pgrp) {
2084 pid = tty->pgrp;
2085 type = PIDTYPE_PGID;
2086 } else {
2087 pid = task_pid(current);
2088 type = PIDTYPE_PID;
2089 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002090 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002091 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002092 retval = __f_setown(filp, pid, type, 0);
2093 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002095 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 } else {
2097 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2098 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2099 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002100 retval = 0;
2101out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002102 return retval;
2103}
2104
2105static int tty_fasync(int fd, struct file *filp, int on)
2106{
Alan Cox89c8d912012-08-08 16:30:13 +01002107 struct tty_struct *tty = file_tty(filp);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002108 int retval;
Alan Cox89c8d912012-08-08 16:30:13 +01002109
2110 tty_lock(tty);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002111 retval = __tty_fasync(fd, filp, on);
Alan Cox89c8d912012-08-08 16:30:13 +01002112 tty_unlock(tty);
2113
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002114 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115}
2116
Alan Coxaf9b8972006-08-27 01:24:01 -07002117/**
2118 * tiocsti - fake input character
2119 * @tty: tty to fake input into
2120 * @p: pointer to character
2121 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002122 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002123 * input management.
2124 *
2125 * FIXME: does not honour flow control ??
2126 *
2127 * Locking:
2128 * Called functions take tty_ldisc_lock
2129 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002130 *
2131 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002132 */
2133
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134static int tiocsti(struct tty_struct *tty, char __user *p)
2135{
2136 char ch, mbz = 0;
2137 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002138
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2140 return -EPERM;
2141 if (get_user(ch, p))
2142 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002143 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002145 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 tty_ldisc_deref(ld);
2147 return 0;
2148}
2149
Alan Coxaf9b8972006-08-27 01:24:01 -07002150/**
2151 * tiocgwinsz - implement window query ioctl
2152 * @tty; tty
2153 * @arg: user buffer for result
2154 *
Alan Cox808a0d32006-09-29 02:00:40 -07002155 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002156 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002157 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002158 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002159 */
2160
Alan Cox37bdfb02008-02-08 04:18:47 -08002161static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162{
Alan Cox808a0d32006-09-29 02:00:40 -07002163 int err;
2164
Arjan van de Ven5785c952006-09-29 02:00:43 -07002165 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002166 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002167 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002168
2169 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170}
2171
Alan Coxaf9b8972006-08-27 01:24:01 -07002172/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002173 * tty_do_resize - resize event
2174 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002175 * @rows: rows (character)
2176 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002177 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002178 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002179 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002180 */
2181
Alan Coxfc6f6232009-01-02 13:43:17 +00002182int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183{
Alan Coxfc6f6232009-01-02 13:43:17 +00002184 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002185 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186
Alan Coxfc6f6232009-01-02 13:43:17 +00002187 /* Lock the tty */
2188 mutex_lock(&tty->termios_mutex);
2189 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002190 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002191 /* Get the PID values and reference them so we can
2192 avoid holding the tty ctrl lock while sending signals */
2193 spin_lock_irqsave(&tty->ctrl_lock, flags);
2194 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002195 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2196
2197 if (pgrp)
2198 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002199 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002200
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002201 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002202done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002203 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 return 0;
2205}
2206
Alan Coxaf9b8972006-08-27 01:24:01 -07002207/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002208 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002209 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002210 * @arg: user buffer for result
2211 *
2212 * Copies the user idea of the window size to the kernel. Traditionally
2213 * this is just advisory information but for the Linux console it
2214 * actually has driver level meaning and triggers a VC resize.
2215 *
2216 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002217 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002218 * tty termios mutex and ctrl_lock. The console takes its own lock
2219 * then calls into the default method.
2220 */
2221
Alan Coxfc6f6232009-01-02 13:43:17 +00002222static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002223{
2224 struct winsize tmp_ws;
2225 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2226 return -EFAULT;
2227
2228 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002229 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002230 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002231 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002232}
2233
2234/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002235 * tioccons - allow admin to move logical console
2236 * @file: the file to become console
2237 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002238 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002239 *
2240 * Locking: uses redirect_lock to guard the redirect information
2241 */
2242
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243static int tioccons(struct file *file)
2244{
2245 if (!capable(CAP_SYS_ADMIN))
2246 return -EPERM;
2247 if (file->f_op->write == redirected_tty_write) {
2248 struct file *f;
2249 spin_lock(&redirect_lock);
2250 f = redirect;
2251 redirect = NULL;
2252 spin_unlock(&redirect_lock);
2253 if (f)
2254 fput(f);
2255 return 0;
2256 }
2257 spin_lock(&redirect_lock);
2258 if (redirect) {
2259 spin_unlock(&redirect_lock);
2260 return -EBUSY;
2261 }
Al Virocb0942b2012-08-27 14:48:26 -04002262 redirect = get_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 spin_unlock(&redirect_lock);
2264 return 0;
2265}
2266
Alan Coxaf9b8972006-08-27 01:24:01 -07002267/**
2268 * fionbio - non blocking ioctl
2269 * @file: file to set blocking value
2270 * @p: user parameter
2271 *
2272 * Historical tty interfaces had a blocking control ioctl before
2273 * the generic functionality existed. This piece of history is preserved
2274 * in the expected tty API of posix OS's.
2275 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002276 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002277 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278
2279static int fionbio(struct file *file, int __user *p)
2280{
2281 int nonblock;
2282
2283 if (get_user(nonblock, p))
2284 return -EFAULT;
2285
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002286 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 if (nonblock)
2288 file->f_flags |= O_NONBLOCK;
2289 else
2290 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002291 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 return 0;
2293}
2294
Alan Coxaf9b8972006-08-27 01:24:01 -07002295/**
2296 * tiocsctty - set controlling tty
2297 * @tty: tty structure
2298 * @arg: user argument
2299 *
2300 * This ioctl is used to manage job control. It permits a session
2301 * leader to set this tty as the controlling tty for the session.
2302 *
2303 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002304 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002305 * Takes tasklist_lock internally to walk sessions
2306 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002307 */
2308
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309static int tiocsctty(struct tty_struct *tty, int arg)
2310{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002311 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002312 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002313 return ret;
2314
2315 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 /*
2317 * The process must be a session leader and
2318 * not have a controlling tty already.
2319 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002320 if (!current->signal->leader || current->signal->tty) {
2321 ret = -EPERM;
2322 goto unlock;
2323 }
2324
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002325 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 /*
2327 * This tty is already the controlling
2328 * tty for another session group!
2329 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002330 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 /*
2332 * Steal it away
2333 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002335 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002337 } else {
2338 ret = -EPERM;
2339 goto unlock;
2340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002342 proc_set_tty(current, tty);
2343unlock:
Alan Cox28298232006-09-29 02:00:58 -07002344 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002345 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346}
2347
Alan Coxaf9b8972006-08-27 01:24:01 -07002348/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002349 * tty_get_pgrp - return a ref counted pgrp pid
2350 * @tty: tty to read
2351 *
2352 * Returns a refcounted instance of the pid struct for the process
2353 * group controlling the tty.
2354 */
2355
2356struct pid *tty_get_pgrp(struct tty_struct *tty)
2357{
2358 unsigned long flags;
2359 struct pid *pgrp;
2360
2361 spin_lock_irqsave(&tty->ctrl_lock, flags);
2362 pgrp = get_pid(tty->pgrp);
2363 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2364
2365 return pgrp;
2366}
2367EXPORT_SYMBOL_GPL(tty_get_pgrp);
2368
2369/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002370 * tiocgpgrp - get process group
2371 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002372 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002373 * @p: returned pid
2374 *
2375 * Obtain the process group of the tty. If there is no process group
2376 * return an error.
2377 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002378 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002379 */
2380
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2382{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002383 struct pid *pid;
2384 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 /*
2386 * (tty == real_tty) is a cheap way of
2387 * testing if the tty is NOT a master pty.
2388 */
2389 if (tty == real_tty && current->signal->tty != real_tty)
2390 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002391 pid = tty_get_pgrp(real_tty);
2392 ret = put_user(pid_vnr(pid), p);
2393 put_pid(pid);
2394 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395}
2396
Alan Coxaf9b8972006-08-27 01:24:01 -07002397/**
2398 * tiocspgrp - attempt to set process group
2399 * @tty: tty passed by user
2400 * @real_tty: tty side device matching tty passed by user
2401 * @p: pid pointer
2402 *
2403 * Set the process group of the tty to the session passed. Only
2404 * permitted where the tty session is our session.
2405 *
Alan Cox47f86832008-04-30 00:53:30 -07002406 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002407 */
2408
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2410{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002411 struct pid *pgrp;
2412 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002414 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415
2416 if (retval == -EIO)
2417 return -ENOTTY;
2418 if (retval)
2419 return retval;
2420 if (!current->signal->tty ||
2421 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002422 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002424 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002426 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002428 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002429 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002430 retval = -ESRCH;
2431 if (!pgrp)
2432 goto out_unlock;
2433 retval = -EPERM;
2434 if (session_of_pgrp(pgrp) != task_session(current))
2435 goto out_unlock;
2436 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002437 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002438 put_pid(real_tty->pgrp);
2439 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002440 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002441out_unlock:
2442 rcu_read_unlock();
2443 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444}
2445
Alan Coxaf9b8972006-08-27 01:24:01 -07002446/**
2447 * tiocgsid - get session id
2448 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002449 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002450 * @p: pointer to returned session id
2451 *
2452 * Obtain the session id of the tty. If there is no session
2453 * return an error.
2454 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002455 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002456 */
2457
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2459{
2460 /*
2461 * (tty == real_tty) is a cheap way of
2462 * testing if the tty is NOT a master pty.
2463 */
2464 if (tty == real_tty && current->signal->tty != real_tty)
2465 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002466 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002468 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469}
2470
Alan Coxaf9b8972006-08-27 01:24:01 -07002471/**
2472 * tiocsetd - set line discipline
2473 * @tty: tty device
2474 * @p: pointer to user data
2475 *
2476 * Set the line discipline according to user request.
2477 *
2478 * Locking: see tty_set_ldisc, this function is just a helper
2479 */
2480
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481static int tiocsetd(struct tty_struct *tty, int __user *p)
2482{
2483 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002484 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485
2486 if (get_user(ldisc, p))
2487 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002488
Alan Cox04f378b2008-04-30 00:53:29 -07002489 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002490
2491 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492}
2493
Alan Coxaf9b8972006-08-27 01:24:01 -07002494/**
2495 * send_break - performed time break
2496 * @tty: device to break on
2497 * @duration: timeout in mS
2498 *
2499 * Perform a timed break on hardware that lacks its own driver level
2500 * timed break functionality.
2501 *
2502 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002503 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002504 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002505 */
2506
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002507static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508{
Alan Cox9e989662008-07-22 11:18:03 +01002509 int retval;
2510
2511 if (tty->ops->break_ctl == NULL)
2512 return 0;
2513
2514 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2515 retval = tty->ops->break_ctl(tty, duration);
2516 else {
2517 /* Do the work ourselves */
2518 if (tty_write_lock(tty, 0) < 0)
2519 return -EINTR;
2520 retval = tty->ops->break_ctl(tty, -1);
2521 if (retval)
2522 goto out;
2523 if (!signal_pending(current))
2524 msleep_interruptible(duration);
2525 retval = tty->ops->break_ctl(tty, 0);
2526out:
2527 tty_write_unlock(tty);
2528 if (signal_pending(current))
2529 retval = -EINTR;
2530 }
2531 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532}
2533
Alan Coxaf9b8972006-08-27 01:24:01 -07002534/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002535 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002536 * @tty: tty device
2537 * @file: user file pointer
2538 * @p: pointer to result
2539 *
2540 * Obtain the modem status bits from the tty driver if the feature
2541 * is supported. Return -EINVAL if it is not available.
2542 *
2543 * Locking: none (up to the driver)
2544 */
2545
Alan Cox60b33c12011-02-14 16:26:14 +00002546static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547{
2548 int retval = -EINVAL;
2549
Alan Coxf34d7a52008-04-30 00:54:13 -07002550 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002551 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552
2553 if (retval >= 0)
2554 retval = put_user(retval, p);
2555 }
2556 return retval;
2557}
2558
Alan Coxaf9b8972006-08-27 01:24:01 -07002559/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002560 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002561 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002562 * @cmd: command - clear bits, set bits or set all
2563 * @p: pointer to desired bits
2564 *
2565 * Set the modem status bits from the tty driver if the feature
2566 * is supported. Return -EINVAL if it is not available.
2567 *
2568 * Locking: none (up to the driver)
2569 */
2570
Alan Cox20b9d172011-02-14 16:26:50 +00002571static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572 unsigned __user *p)
2573{
Alan Coxae677512008-07-16 21:56:54 +01002574 int retval;
2575 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576
Alan Coxae677512008-07-16 21:56:54 +01002577 if (tty->ops->tiocmset == NULL)
2578 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579
Alan Coxae677512008-07-16 21:56:54 +01002580 retval = get_user(val, p);
2581 if (retval)
2582 return retval;
2583 set = clear = 0;
2584 switch (cmd) {
2585 case TIOCMBIS:
2586 set = val;
2587 break;
2588 case TIOCMBIC:
2589 clear = val;
2590 break;
2591 case TIOCMSET:
2592 set = val;
2593 clear = ~val;
2594 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 }
Alan Coxae677512008-07-16 21:56:54 +01002596 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2597 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002598 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599}
2600
Alan Coxd281da72010-09-16 18:21:24 +01002601static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2602{
2603 int retval = -EINVAL;
2604 struct serial_icounter_struct icount;
2605 memset(&icount, 0, sizeof(icount));
2606 if (tty->ops->get_icount)
2607 retval = tty->ops->get_icount(tty, &icount);
2608 if (retval != 0)
2609 return retval;
2610 if (copy_to_user(arg, &icount, sizeof(icount)))
2611 return -EFAULT;
2612 return 0;
2613}
2614
Alan Coxe8b70e72009-06-11 12:48:02 +01002615struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2616{
2617 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2618 tty->driver->subtype == PTY_TYPE_MASTER)
2619 tty = tty->link;
2620 return tty;
2621}
2622EXPORT_SYMBOL(tty_pair_get_tty);
2623
2624struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2625{
2626 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2627 tty->driver->subtype == PTY_TYPE_MASTER)
2628 return tty;
2629 return tty->link;
2630}
2631EXPORT_SYMBOL(tty_pair_get_pty);
2632
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633/*
2634 * Split this up, as gcc can choke on it otherwise..
2635 */
Alan Cox04f378b2008-04-30 00:53:29 -07002636long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637{
Nick Piggind996b622010-08-18 04:37:36 +10002638 struct tty_struct *tty = file_tty(file);
2639 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 void __user *p = (void __user *)arg;
2641 int retval;
2642 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002643 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002644
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2646 return -EINVAL;
2647
Alan Coxe8b70e72009-06-11 12:48:02 +01002648 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649
2650 /*
2651 * Factor out some common prep work
2652 */
2653 switch (cmd) {
2654 case TIOCSETD:
2655 case TIOCSBRK:
2656 case TIOCCBRK:
2657 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002658 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 retval = tty_check_change(tty);
2660 if (retval)
2661 return retval;
2662 if (cmd != TIOCCBRK) {
2663 tty_wait_until_sent(tty, 0);
2664 if (signal_pending(current))
2665 return -EINTR;
2666 }
2667 break;
2668 }
2669
Alan Cox9e989662008-07-22 11:18:03 +01002670 /*
2671 * Now do the stuff.
2672 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002674 case TIOCSTI:
2675 return tiocsti(tty, p);
2676 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002677 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002678 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002679 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002680 case TIOCCONS:
2681 return real_tty != tty ? -EINVAL : tioccons(file);
2682 case FIONBIO:
2683 return fionbio(file, p);
2684 case TIOCEXCL:
2685 set_bit(TTY_EXCLUSIVE, &tty->flags);
2686 return 0;
2687 case TIOCNXCL:
2688 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2689 return 0;
Cyrill Gorcunov84fd7bd2012-10-24 23:43:22 +04002690 case TIOCGEXCL:
2691 {
2692 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2693 return put_user(excl, (int __user *)p);
2694 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002695 case TIOCNOTTY:
2696 if (current->signal->tty != tty)
2697 return -ENOTTY;
2698 no_tty();
2699 return 0;
2700 case TIOCSCTTY:
2701 return tiocsctty(tty, arg);
2702 case TIOCGPGRP:
2703 return tiocgpgrp(tty, real_tty, p);
2704 case TIOCSPGRP:
2705 return tiocspgrp(tty, real_tty, p);
2706 case TIOCGSID:
2707 return tiocgsid(tty, real_tty, p);
2708 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002709 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002710 case TIOCSETD:
2711 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002712 case TIOCVHANGUP:
2713 if (!capable(CAP_SYS_ADMIN))
2714 return -EPERM;
2715 tty_vhangup(tty);
2716 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002717 case TIOCGDEV:
2718 {
2719 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2720 return put_user(ret, (unsigned int __user *)p);
2721 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002722 /*
2723 * Break handling
2724 */
2725 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002726 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002727 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002728 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002729 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002730 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002731 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002732 return 0;
2733 case TCSBRK: /* SVID version: non-zero arg --> no break */
2734 /* non-zero arg means wait for all output data
2735 * to be sent (performed above) but don't send break.
2736 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002738 if (!arg)
2739 return send_break(tty, 250);
2740 return 0;
2741 case TCSBRKP: /* support for POSIX tcsendbreak() */
2742 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743
Alan Cox37bdfb02008-02-08 04:18:47 -08002744 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002745 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002746 case TIOCMSET:
2747 case TIOCMBIC:
2748 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002749 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002750 case TIOCGICOUNT:
2751 retval = tty_tiocgicount(tty, p);
2752 /* For the moment allow fall through to the old method */
2753 if (retval != -EINVAL)
2754 return retval;
2755 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002756 case TCFLSH:
2757 switch (arg) {
2758 case TCIFLUSH:
2759 case TCIOFLUSH:
2760 /* flush tty buffer and allow ldisc to process ioctl */
2761 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002762 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002763 }
2764 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002766 if (tty->ops->ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002767 retval = (tty->ops->ioctl)(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 if (retval != -ENOIOCTLCMD)
2769 return retval;
2770 }
2771 ld = tty_ldisc_ref_wait(tty);
2772 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002773 if (ld->ops->ioctl) {
2774 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775 if (retval == -ENOIOCTLCMD)
Wanlong Gaobbb63c52012-08-27 15:23:12 +08002776 retval = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777 }
2778 tty_ldisc_deref(ld);
2779 return retval;
2780}
2781
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002782#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002783static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002784 unsigned long arg)
2785{
2786 struct inode *inode = file->f_dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10002787 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002788 struct tty_ldisc *ld;
2789 int retval = -ENOIOCTLCMD;
2790
2791 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2792 return -EINVAL;
2793
Alan Coxf34d7a52008-04-30 00:54:13 -07002794 if (tty->ops->compat_ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002795 retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002796 if (retval != -ENOIOCTLCMD)
2797 return retval;
2798 }
2799
2800 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002801 if (ld->ops->compat_ioctl)
2802 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Thomas Meyer8193c422011-10-05 23:13:13 +02002803 else
2804 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002805 tty_ldisc_deref(ld);
2806
2807 return retval;
2808}
2809#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810
Al Viroc3c073f2012-08-21 22:32:06 -04002811static int this_tty(const void *t, struct file *file, unsigned fd)
2812{
2813 if (likely(file->f_op->read != tty_read))
2814 return 0;
2815 return file_tty(file) != t ? 0 : fd + 1;
2816}
2817
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818/*
2819 * This implements the "Secure Attention Key" --- the idea is to
2820 * prevent trojan horses by killing all processes associated with this
2821 * tty when the user hits the "Secure Attention Key". Required for
2822 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002823 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 * This code could be nicer; ideally it should send a HUP, wait a few
2825 * seconds, then send a INT, and then a KILL signal. But you then
2826 * have to coordinate with the init process, since all processes associated
2827 * with the current tty must be dead before the new getty is allowed
2828 * to spawn.
2829 *
2830 * Now, if it would be correct ;-/ The current code has a nasty hole -
2831 * it doesn't catch files in flight. We may send the descriptor to ourselves
2832 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2833 *
2834 * Nasty bug: do_SAK is being called in interrupt context. This can
2835 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2836 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002837void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838{
2839#ifdef TTY_SOFT_SAK
2840 tty_hangup(tty);
2841#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002842 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002843 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -08002845
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846 if (!tty)
2847 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002848 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002849
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002850 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851
Alan Coxf34d7a52008-04-30 00:54:13 -07002852 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002853
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002855 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002856 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002857 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002858 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002859 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002860 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002861 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002862 /* Now kill any processes that happen to have the
2863 * tty open.
2864 */
2865 do_each_thread(g, p) {
2866 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002868 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002869 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 send_sig(SIGKILL, p, 1);
2871 continue;
2872 }
2873 task_lock(p);
Al Viroc3c073f2012-08-21 22:32:06 -04002874 i = iterate_fd(p->files, 0, this_tty, tty);
2875 if (i != 0) {
2876 printk(KERN_NOTICE "SAK: killed process %d"
2877 " (%s): fd#%d opened to the tty\n",
2878 task_pid_nr(p), p->comm, i - 1);
2879 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 }
2881 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002882 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 read_unlock(&tasklist_lock);
2884#endif
2885}
2886
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002887static void do_SAK_work(struct work_struct *work)
2888{
2889 struct tty_struct *tty =
2890 container_of(work, struct tty_struct, SAK_work);
2891 __do_SAK(tty);
2892}
2893
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894/*
2895 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2896 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2897 * the values which we write to it will be identical to the values which it
2898 * already has. --akpm
2899 */
2900void do_SAK(struct tty_struct *tty)
2901{
2902 if (!tty)
2903 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904 schedule_work(&tty->SAK_work);
2905}
2906
2907EXPORT_SYMBOL(do_SAK);
2908
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002909static int dev_match_devt(struct device *dev, void *data)
2910{
2911 dev_t *devt = data;
2912 return dev->devt == *devt;
2913}
2914
2915/* Must put_device() after it's unused! */
2916static struct device *tty_get_device(struct tty_struct *tty)
2917{
2918 dev_t devt = tty_devnum(tty);
2919 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2920}
2921
2922
Alan Coxaf9b8972006-08-27 01:24:01 -07002923/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002924 * initialize_tty_struct
2925 * @tty: tty to initialize
2926 *
2927 * This subroutine initializes a tty structure that has been newly
2928 * allocated.
2929 *
2930 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002932
Alan Coxbf970ee2008-10-13 10:42:39 +01002933void initialize_tty_struct(struct tty_struct *tty,
2934 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935{
2936 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002937 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002939 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002940 tty->session = NULL;
2941 tty->pgrp = NULL;
Alan Cox89c8d912012-08-08 16:30:13 +01002942 mutex_init(&tty->legacy_mutex);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002943 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002944 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 init_waitqueue_head(&tty->write_wait);
2946 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002947 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002948 mutex_init(&tty->atomic_write_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002949 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002951 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002952
2953 tty->driver = driver;
2954 tty->ops = driver->ops;
2955 tty->index = idx;
2956 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002957 tty->dev = tty_get_device(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958}
2959
Alan Coxf34d7a52008-04-30 00:54:13 -07002960/**
Jiri Slaby67166712011-03-23 10:48:35 +01002961 * deinitialize_tty_struct
2962 * @tty: tty to deinitialize
2963 *
2964 * This subroutine deinitializes a tty structure that has been newly
2965 * allocated but tty_release cannot be called on that yet.
2966 *
2967 * Locking: none - tty in question must not be exposed at this point
2968 */
2969void deinitialize_tty_struct(struct tty_struct *tty)
2970{
2971 tty_ldisc_deinit(tty);
2972}
2973
2974/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002975 * tty_put_char - write one character to a tty
2976 * @tty: tty
2977 * @ch: character
2978 *
2979 * Write one byte to the tty using the provided put_char method
2980 * if present. Returns the number of characters successfully output.
2981 *
2982 * Note: the specific put_char operation in the driver layer may go
2983 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002985
Alan Coxf34d7a52008-04-30 00:54:13 -07002986int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987{
Alan Coxf34d7a52008-04-30 00:54:13 -07002988 if (tty->ops->put_char)
2989 return tty->ops->put_char(tty, ch);
2990 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991}
Alan Coxf34d7a52008-04-30 00:54:13 -07002992EXPORT_SYMBOL_GPL(tty_put_char);
2993
Alan Coxd81ed102008-10-13 10:41:42 +01002994struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995
Jiri Slaby7e73eca2012-08-08 22:26:44 +02002996static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
2997 unsigned int index, unsigned int count)
2998{
2999 /* init here, since reused cdevs cause crashes */
3000 cdev_init(&driver->cdevs[index], &tty_fops);
3001 driver->cdevs[index].owner = driver->owner;
3002 return cdev_add(&driver->cdevs[index], dev, count);
3003}
3004
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003006 * tty_register_device - register a tty device
3007 * @driver: the tty driver that describes the tty device
3008 * @index: the index in the tty driver for this tty device
3009 * @device: a struct device that is associated with this tty device.
3010 * This field is optional, if there is no known struct device
3011 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003013 * Returns a pointer to the struct device for this tty device
3014 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003015 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003016 * This call is required to be made to register an individual tty device
3017 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3018 * that bit is not set, this function should not be called by a tty
3019 * driver.
3020 *
3021 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003023
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003024struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3025 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026{
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003027 return tty_register_device_attr(driver, index, device, NULL, NULL);
3028}
3029EXPORT_SYMBOL(tty_register_device);
3030
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003031static void tty_device_create_release(struct device *dev)
3032{
3033 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3034 kfree(dev);
3035}
3036
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003037/**
3038 * tty_register_device_attr - register a tty device
3039 * @driver: the tty driver that describes the tty device
3040 * @index: the index in the tty driver for this tty device
3041 * @device: a struct device that is associated with this tty device.
3042 * This field is optional, if there is no known struct device
3043 * for this tty device it can be set to NULL safely.
3044 * @drvdata: Driver data to be set to device.
3045 * @attr_grp: Attribute group to be set on device.
3046 *
3047 * Returns a pointer to the struct device for this tty device
3048 * (or ERR_PTR(-EFOO) on error).
3049 *
3050 * This call is required to be made to register an individual tty device
3051 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3052 * that bit is not set, this function should not be called by a tty
3053 * driver.
3054 *
3055 * Locking: ??
3056 */
3057struct device *tty_register_device_attr(struct tty_driver *driver,
3058 unsigned index, struct device *device,
3059 void *drvdata,
3060 const struct attribute_group **attr_grp)
3061{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062 char name[64];
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003063 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3064 struct device *dev = NULL;
3065 int retval = -ENODEV;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003066 bool cdev = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067
3068 if (index >= driver->num) {
3069 printk(KERN_ERR "Attempt to register invalid tty line number "
3070 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003071 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072 }
3073
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 if (driver->type == TTY_DRIVER_TYPE_PTY)
3075 pty_line_name(driver, index, name);
3076 else
3077 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003078
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003079 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003080 retval = tty_cdev_add(driver, devt, index, 1);
3081 if (retval)
3082 goto error;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003083 cdev = true;
3084 }
3085
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003086 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3087 if (!dev) {
3088 retval = -ENOMEM;
3089 goto error;
3090 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003091
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003092 dev->devt = devt;
3093 dev->class = tty_class;
3094 dev->parent = device;
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003095 dev->release = tty_device_create_release;
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003096 dev_set_name(dev, "%s", name);
3097 dev->groups = attr_grp;
3098 dev_set_drvdata(dev, drvdata);
3099
3100 retval = device_register(dev);
3101 if (retval)
3102 goto error;
3103
3104 return dev;
3105
3106error:
3107 put_device(dev);
3108 if (cdev)
3109 cdev_del(&driver->cdevs[index]);
3110 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111}
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003112EXPORT_SYMBOL_GPL(tty_register_device_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113
3114/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003115 * tty_unregister_device - unregister a tty device
3116 * @driver: the tty driver that describes the tty device
3117 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003119 * If a tty device is registered with a call to tty_register_device() then
3120 * this function must be called when the tty device is gone.
3121 *
3122 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003124
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125void tty_unregister_device(struct tty_driver *driver, unsigned index)
3126{
Alan Cox37bdfb02008-02-08 04:18:47 -08003127 device_destroy(tty_class,
3128 MKDEV(driver->major, driver->minor_start) + index);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003129 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
3130 cdev_del(&driver->cdevs[index]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003132EXPORT_SYMBOL(tty_unregister_device);
3133
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003134/**
3135 * __tty_alloc_driver -- allocate tty driver
3136 * @lines: count of lines this driver can handle at most
3137 * @owner: module which is repsonsible for this driver
3138 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3139 *
3140 * This should not be called directly, some of the provided macros should be
3141 * used instead. Use IS_ERR and friends on @retval.
3142 */
3143struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3144 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145{
3146 struct tty_driver *driver;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003147 unsigned int cdevs = 1;
Jiri Slaby16a02082012-08-08 22:26:42 +02003148 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149
Jiri Slaby0019b402012-08-08 22:26:43 +02003150 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003151 return ERR_PTR(-EINVAL);
3152
Jean Delvare506eb992007-07-15 23:40:14 -07003153 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003154 if (!driver)
3155 return ERR_PTR(-ENOMEM);
3156
3157 kref_init(&driver->kref);
3158 driver->magic = TTY_DRIVER_MAGIC;
3159 driver->num = lines;
3160 driver->owner = owner;
3161 driver->flags = flags;
Jiri Slaby16a02082012-08-08 22:26:42 +02003162
3163 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3164 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3165 GFP_KERNEL);
3166 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3167 GFP_KERNEL);
3168 if (!driver->ttys || !driver->termios) {
3169 err = -ENOMEM;
3170 goto err_free_all;
3171 }
3172 }
3173
3174 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3175 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3176 GFP_KERNEL);
3177 if (!driver->ports) {
3178 err = -ENOMEM;
3179 goto err_free_all;
3180 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003181 cdevs = lines;
3182 }
3183
3184 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3185 if (!driver->cdevs) {
3186 err = -ENOMEM;
3187 goto err_free_all;
Jiri Slaby16a02082012-08-08 22:26:42 +02003188 }
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003189
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190 return driver;
Jiri Slaby16a02082012-08-08 22:26:42 +02003191err_free_all:
3192 kfree(driver->ports);
3193 kfree(driver->ttys);
3194 kfree(driver->termios);
3195 kfree(driver);
3196 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003197}
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003198EXPORT_SYMBOL(__tty_alloc_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199
Alan Cox7d7b93c2008-10-13 10:42:09 +01003200static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003202 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3203 int i;
3204 struct ktermios *tp;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003205
3206 if (driver->flags & TTY_DRIVER_INSTALLED) {
3207 /*
3208 * Free the termios and termios_locked structures because
3209 * we don't want to get memory leaks when modular tty
3210 * drivers are removed from the kernel.
3211 */
3212 for (i = 0; i < driver->num; i++) {
3213 tp = driver->termios[i];
3214 if (tp) {
3215 driver->termios[i] = NULL;
3216 kfree(tp);
3217 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003218 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3219 tty_unregister_device(driver, i);
3220 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003221 proc_tty_unregister_driver(driver);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003222 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3223 cdev_del(&driver->cdevs[0]);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003224 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003225 kfree(driver->cdevs);
Jiri Slaby04831dc2012-06-04 13:35:36 +02003226 kfree(driver->ports);
Jiri Slaby16a02082012-08-08 22:26:42 +02003227 kfree(driver->termios);
3228 kfree(driver->ttys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229 kfree(driver);
3230}
3231
Alan Cox7d7b93c2008-10-13 10:42:09 +01003232void tty_driver_kref_put(struct tty_driver *driver)
3233{
3234 kref_put(&driver->kref, destruct_tty_driver);
3235}
3236EXPORT_SYMBOL(tty_driver_kref_put);
3237
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003238void tty_set_operations(struct tty_driver *driver,
3239 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240{
Alan Coxf34d7a52008-04-30 00:54:13 -07003241 driver->ops = op;
3242};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243EXPORT_SYMBOL(tty_set_operations);
3244
Alan Cox7d7b93c2008-10-13 10:42:09 +01003245void put_tty_driver(struct tty_driver *d)
3246{
3247 tty_driver_kref_put(d);
3248}
3249EXPORT_SYMBOL(put_tty_driver);
3250
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251/*
3252 * Called by a tty driver to register itself.
3253 */
3254int tty_register_driver(struct tty_driver *driver)
3255{
3256 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003257 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258 dev_t dev;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003259 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003262 error = alloc_chrdev_region(&dev, driver->minor_start,
3263 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264 if (!error) {
3265 driver->major = MAJOR(dev);
3266 driver->minor_start = MINOR(dev);
3267 }
3268 } else {
3269 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003270 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271 }
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003272 if (error < 0)
Jiri Slaby16a02082012-08-08 22:26:42 +02003273 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003275 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3276 error = tty_cdev_add(driver, dev, 0, driver->num);
3277 if (error)
3278 goto err_unreg_char;
3279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003281 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003282 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003283 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003284
3285 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003286 for (i = 0; i < driver->num; i++) {
3287 d = tty_register_device(driver, i, NULL);
3288 if (IS_ERR(d)) {
3289 error = PTR_ERR(d);
Jiri Slaby16a02082012-08-08 22:26:42 +02003290 goto err_unreg_devs;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003291 }
3292 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003293 }
3294 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003295 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003297
Jiri Slaby16a02082012-08-08 22:26:42 +02003298err_unreg_devs:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003299 for (i--; i >= 0; i--)
3300 tty_unregister_device(driver, i);
3301
3302 mutex_lock(&tty_mutex);
3303 list_del(&driver->tty_drivers);
3304 mutex_unlock(&tty_mutex);
3305
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003306err_unreg_char:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003307 unregister_chrdev_region(dev, driver->num);
Jiri Slaby16a02082012-08-08 22:26:42 +02003308err:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003309 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311EXPORT_SYMBOL(tty_register_driver);
3312
3313/*
3314 * Called by a tty driver to unregister itself.
3315 */
3316int tty_unregister_driver(struct tty_driver *driver)
3317{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003318#if 0
3319 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 if (driver->refcount)
3321 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003322#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3324 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003325 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003327 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003328 return 0;
3329}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003330
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331EXPORT_SYMBOL(tty_unregister_driver);
3332
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003333dev_t tty_devnum(struct tty_struct *tty)
3334{
3335 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3336}
3337EXPORT_SYMBOL(tty_devnum);
3338
3339void proc_clear_tty(struct task_struct *p)
3340{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003341 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003342 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003343 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003344 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003345 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003346 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003347 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003348}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003349
Alan Cox47f86832008-04-30 00:53:30 -07003350/* Called under the sighand lock */
3351
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003352static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003353{
3354 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003355 unsigned long flags;
3356 /* We should not have a session or pgrp to put here but.... */
3357 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003358 put_pid(tty->session);
3359 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003360 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003361 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3362 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003363 if (tsk->signal->tty) {
3364 printk(KERN_DEBUG "tty not NULL!!\n");
3365 tty_kref_put(tsk->signal->tty);
3366 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003367 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003368 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003369 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003370 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003371}
3372
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003373static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003374{
3375 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003376 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003377 spin_unlock_irq(&tsk->sighand->siglock);
3378}
3379
3380struct tty_struct *get_current_tty(void)
3381{
3382 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003383 unsigned long flags;
3384
3385 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003386 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003387 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003388 return tty;
3389}
Heiko Carstensa311f742006-12-13 00:33:41 -08003390EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391
Alan Coxd81ed102008-10-13 10:41:42 +01003392void tty_default_fops(struct file_operations *fops)
3393{
3394 *fops = tty_fops;
3395}
3396
Linus Torvalds1da177e2005-04-16 15:20:36 -07003397/*
3398 * Initialize the console device. This is called *early*, so
3399 * we can't necessarily depend on lots of kernel help here.
3400 * Just do some early initializations, and do the complex setup
3401 * later.
3402 */
3403void __init console_init(void)
3404{
3405 initcall_t *call;
3406
3407 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003408 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409
3410 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003411 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003412 * inform about problems etc..
3413 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003414 call = __con_initcall_start;
3415 while (call < __con_initcall_end) {
3416 (*call)();
3417 call++;
3418 }
3419}
3420
Al Viro2c9ede52011-07-23 20:24:48 -04003421static char *tty_devnode(struct device *dev, umode_t *mode)
Kay Sieverse454cea2009-09-18 23:01:12 +02003422{
3423 if (!mode)
3424 return NULL;
3425 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3426 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3427 *mode = 0666;
3428 return NULL;
3429}
3430
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431static int __init tty_class_init(void)
3432{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003433 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434 if (IS_ERR(tty_class))
3435 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003436 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437 return 0;
3438}
3439
3440postcore_initcall(tty_class_init);
3441
3442/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444
Kay Sieversfbc92a32010-12-01 18:51:05 +01003445static ssize_t show_cons_active(struct device *dev,
3446 struct device_attribute *attr, char *buf)
3447{
3448 struct console *cs[16];
3449 int i = 0;
3450 struct console *c;
3451 ssize_t count = 0;
3452
Torben Hohnac751ef2011-01-25 15:07:35 -08003453 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003454 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003455 if (!c->device)
3456 continue;
3457 if (!c->write)
3458 continue;
3459 if ((c->flags & CON_ENABLED) == 0)
3460 continue;
3461 cs[i++] = c;
3462 if (i >= ARRAY_SIZE(cs))
3463 break;
3464 }
3465 while (i--)
3466 count += sprintf(buf + count, "%s%d%c",
3467 cs[i]->name, cs[i]->index, i ? ' ':'\n');
Torben Hohnac751ef2011-01-25 15:07:35 -08003468 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003469
3470 return count;
3471}
3472static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3473
3474static struct device *consdev;
3475
3476void console_sysfs_notify(void)
3477{
3478 if (consdev)
3479 sysfs_notify(&consdev->kobj, NULL, "active");
3480}
3481
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482/*
3483 * Ok, now we can initialize the rest of the tty devices and can count
3484 * on memory allocations, interrupts etc..
3485 */
David Howells31d1d482010-08-06 16:34:43 +01003486int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487{
3488 cdev_init(&tty_cdev, &tty_fops);
3489 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3490 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3491 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003492 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493
3494 cdev_init(&console_cdev, &console_fops);
3495 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3496 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3497 panic("Couldn't register /dev/console driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003498 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003499 "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003500 if (IS_ERR(consdev))
3501 consdev = NULL;
3502 else
Kay Sieversa2a6a822011-01-09 16:39:14 +01003503 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003506 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507#endif
3508 return 0;
3509}
David Howells31d1d482010-08-06 16:34:43 +01003510