blob: 4f35b43e24759c5ab2ae5bcfd7a0fd49672ed3d8 [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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Alan Coxaf9b8972006-08-27 01:24:01 -0700157/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700158 * free_tty_struct - free a disused tty
159 * @tty: tty struct to free
160 *
161 * Free the write buffers, tty queue and tty memory itself.
162 *
163 * Locking: none. Must be called after tty is definitely unused
164 */
165
Alan Coxbf970ee2008-10-13 10:42:39 +0100166void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Dan Carpenterdc6802a2012-07-24 12:52:04 +0100168 if (!tty)
169 return;
Markus Elfringa211b1a2014-11-21 13:42:29 +0100170 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 kfree(tty->write_buf);
Alan Cox89c8d912012-08-08 16:30:13 +0100172 tty->magic = 0xDEADDEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 kfree(tty);
174}
175
Nick Piggind996b622010-08-18 04:37:36 +1000176static inline struct tty_struct *file_tty(struct file *file)
177{
178 return ((struct tty_file_private *)file->private_data)->tty;
179}
180
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200181int tty_alloc_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000182{
183 struct tty_file_private *priv;
184
Pekka Enbergf573bd12010-08-24 07:48:34 +0300185 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
186 if (!priv)
187 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000188
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200189 file->private_data = priv;
190
191 return 0;
192}
193
194/* Associate a new file with the tty structure */
195void tty_add_file(struct tty_struct *tty, struct file *file)
196{
197 struct tty_file_private *priv = file->private_data;
198
Nick Piggind996b622010-08-18 04:37:36 +1000199 priv->tty = tty;
200 priv->file = file;
Nick Piggind996b622010-08-18 04:37:36 +1000201
202 spin_lock(&tty_files_lock);
203 list_add(&priv->list, &tty->tty_files);
204 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200205}
Pekka Enbergf573bd12010-08-24 07:48:34 +0300206
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200207/**
208 * tty_free_file - free file->private_data
209 *
210 * This shall be used only for fail path handling when tty_add_file was not
211 * called yet.
212 */
213void tty_free_file(struct file *file)
214{
215 struct tty_file_private *priv = file->private_data;
216
217 file->private_data = NULL;
218 kfree(priv);
Nick Piggind996b622010-08-18 04:37:36 +1000219}
220
221/* Delete file from its tty */
Josh Triplett2520e272012-11-18 21:27:47 -0800222static void tty_del_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000223{
224 struct tty_file_private *priv = file->private_data;
225
226 spin_lock(&tty_files_lock);
227 list_del(&priv->list);
228 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200229 tty_free_file(file);
Nick Piggind996b622010-08-18 04:37:36 +1000230}
231
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
234
Alan Coxaf9b8972006-08-27 01:24:01 -0700235/**
236 * tty_name - return tty naming
237 * @tty: tty structure
238 * @buf: buffer for output
239 *
240 * Convert a tty structure into a name. The name reflects the kernel
241 * naming policy and if udev is in use may not reflect user space
242 *
243 * Locking: none
244 */
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246char *tty_name(struct tty_struct *tty, char *buf)
247{
248 if (!tty) /* Hmm. NULL pointer. That's fun. */
249 strcpy(buf, "NULL tty");
250 else
251 strcpy(buf, tty->name);
252 return buf;
253}
254
255EXPORT_SYMBOL(tty_name);
256
Andrew Mortond769a662005-05-05 16:15:50 -0700257int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 const char *routine)
259{
260#ifdef TTY_PARANOIA_CHECK
261 if (!tty) {
262 printk(KERN_WARNING
263 "null TTY for (%d:%d) in %s\n",
264 imajor(inode), iminor(inode), routine);
265 return 1;
266 }
267 if (tty->magic != TTY_MAGIC) {
268 printk(KERN_WARNING
269 "bad magic number for tty struct (%d:%d) in %s\n",
270 imajor(inode), iminor(inode), routine);
271 return 1;
272 }
273#endif
274 return 0;
275}
276
Peter Hurleydeb287e2014-11-05 12:12:55 -0500277/* Caller must hold tty_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278static int check_tty_count(struct tty_struct *tty, const char *routine)
279{
280#ifdef CHECK_TTY_COUNT
281 struct list_head *p;
282 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800283
Nick Pigginee2ffa02010-08-18 04:37:35 +1000284 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 list_for_each(p, &tty->tty_files) {
286 count++;
287 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000288 spin_unlock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
290 tty->driver->subtype == PTY_TYPE_SLAVE &&
291 tty->link && tty->link->count)
292 count++;
293 if (tty->count != count) {
294 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
295 "!= #fd's(%d) in %s\n",
296 tty->name, tty->count, count, routine);
297 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299#endif
300 return 0;
301}
302
Alan Coxaf9b8972006-08-27 01:24:01 -0700303/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700304 * get_tty_driver - find device of a tty
305 * @dev_t: device identifier
306 * @index: returns the index of the tty
307 *
308 * This routine returns a tty driver structure, given a device number
309 * and also passes back the index number.
310 *
311 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314static struct tty_driver *get_tty_driver(dev_t device, int *index)
315{
316 struct tty_driver *p;
317
318 list_for_each_entry(p, &tty_drivers, tty_drivers) {
319 dev_t base = MKDEV(p->major, p->minor_start);
320 if (device < base || device >= base + p->num)
321 continue;
322 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100323 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 }
325 return NULL;
326}
327
Jason Wesself2d937f2008-04-17 20:05:37 +0200328#ifdef CONFIG_CONSOLE_POLL
329
330/**
331 * tty_find_polling_driver - find device of a polled tty
332 * @name: name string to match
333 * @line: pointer to resulting tty line nr
334 *
335 * This routine returns a tty driver structure, given a name
336 * and the condition that the tty driver is capable of polled
337 * operation.
338 */
339struct tty_driver *tty_find_polling_driver(char *name, int *line)
340{
341 struct tty_driver *p, *res = NULL;
342 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500343 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100344 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200345
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500346 for (str = name; *str; str++)
347 if ((*str >= '0' && *str <= '9') || *str == ',')
348 break;
349 if (!*str)
350 return NULL;
351
352 len = str - name;
353 tty_line = simple_strtoul(str, &str, 10);
354
Jason Wesself2d937f2008-04-17 20:05:37 +0200355 mutex_lock(&tty_mutex);
356 /* Search through the tty devices to look for a match */
357 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500358 if (strncmp(name, p->name, len) != 0)
359 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100360 stp = str;
361 if (*stp == ',')
362 stp++;
363 if (*stp == '\0')
364 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200365
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200366 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100367 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100368 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200369 *line = tty_line;
370 break;
371 }
372 }
373 mutex_unlock(&tty_mutex);
374
375 return res;
376}
377EXPORT_SYMBOL_GPL(tty_find_polling_driver);
378#endif
379
Alan Coxaf9b8972006-08-27 01:24:01 -0700380/**
381 * tty_check_change - check for POSIX terminal changes
382 * @tty: tty to check
383 *
384 * If we try to write to, or set the state of, a terminal and we're
385 * not in the foreground, send a SIGTTOU. If the signal is blocked or
386 * ignored, go ahead and perform the operation. (POSIX 7.2)
387 *
Alan Cox978e5952008-04-30 00:53:59 -0700388 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700390
Alan Cox37bdfb02008-02-08 04:18:47 -0800391int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Alan Cox47f86832008-04-30 00:53:30 -0700393 unsigned long flags;
394 int ret = 0;
395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 if (current->signal->tty != tty)
397 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700398
399 spin_lock_irqsave(&tty->ctrl_lock, flags);
400
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800401 if (!tty->pgrp) {
402 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700403 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800405 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700406 goto out_unlock;
407 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700409 goto out;
410 if (is_current_pgrp_orphaned()) {
411 ret = -EIO;
412 goto out;
413 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700414 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
415 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700416 ret = -ERESTARTSYS;
417out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700418 return ret;
419out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700420 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
421 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422}
423
424EXPORT_SYMBOL(tty_check_change);
425
Alan Cox37bdfb02008-02-08 04:18:47 -0800426static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 size_t count, loff_t *ppos)
428{
429 return 0;
430}
431
Alan Cox37bdfb02008-02-08 04:18:47 -0800432static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 size_t count, loff_t *ppos)
434{
435 return -EIO;
436}
437
438/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800439static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440{
441 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
442}
443
Alan Cox04f378b2008-04-30 00:53:29 -0700444static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
445 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700446{
447 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
448}
449
Alan Cox37bdfb02008-02-08 04:18:47 -0800450static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700451 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
453 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
454}
455
Arjan van de Ven62322d22006-07-03 00:24:21 -0700456static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 .llseek = no_llseek,
458 .read = tty_read,
459 .write = tty_write,
460 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700461 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700462 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 .open = tty_open,
464 .release = tty_release,
465 .fasync = tty_fasync,
466};
467
Arjan van de Ven62322d22006-07-03 00:24:21 -0700468static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 .llseek = no_llseek,
470 .read = tty_read,
471 .write = redirected_tty_write,
472 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700473 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700474 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 .open = tty_open,
476 .release = tty_release,
477 .fasync = tty_fasync,
478};
479
Arjan van de Ven62322d22006-07-03 00:24:21 -0700480static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 .llseek = no_llseek,
482 .read = hung_up_tty_read,
483 .write = hung_up_tty_write,
484 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700485 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700486 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 .release = tty_release,
488};
489
490static DEFINE_SPINLOCK(redirect_lock);
491static struct file *redirect;
492
Peter Hurley11d9bef2014-10-16 14:59:42 -0400493
494void proc_clear_tty(struct task_struct *p)
495{
496 unsigned long flags;
497 struct tty_struct *tty;
498 spin_lock_irqsave(&p->sighand->siglock, flags);
499 tty = p->signal->tty;
500 p->signal->tty = NULL;
501 spin_unlock_irqrestore(&p->sighand->siglock, flags);
502 tty_kref_put(tty);
503}
504
Peter Hurley2c411c12014-10-16 14:59:47 -0400505/**
506 * proc_set_tty - set the controlling terminal
507 *
508 * Only callable by the session leader and only if it does not already have
509 * a controlling terminal.
510 *
Peter Hurleye218eb32014-10-16 14:59:49 -0400511 * Caller must hold: tty_lock()
512 * a readlock on tasklist_lock
Peter Hurley2c411c12014-10-16 14:59:47 -0400513 * sighand lock
514 */
Peter Hurleybce65f12014-10-16 14:59:43 -0400515static void __proc_set_tty(struct tty_struct *tty)
Peter Hurley11d9bef2014-10-16 14:59:42 -0400516{
Peter Hurleyae28fa72014-10-16 14:59:46 -0400517 unsigned long flags;
518
Peter Hurleyae28fa72014-10-16 14:59:46 -0400519 spin_lock_irqsave(&tty->ctrl_lock, flags);
Peter Hurleya3618582014-10-16 14:59:50 -0400520 /*
521 * The session and fg pgrp references will be non-NULL if
522 * tiocsctty() is stealing the controlling tty
523 */
Peter Hurleyae28fa72014-10-16 14:59:46 -0400524 put_pid(tty->session);
525 put_pid(tty->pgrp);
526 tty->pgrp = get_pid(task_pgrp(current));
527 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
528 tty->session = get_pid(task_session(current));
529 if (current->signal->tty) {
530 printk(KERN_DEBUG "tty not NULL!!\n");
531 tty_kref_put(current->signal->tty);
Peter Hurley11d9bef2014-10-16 14:59:42 -0400532 }
Peter Hurleybce65f12014-10-16 14:59:43 -0400533 put_pid(current->signal->tty_old_pgrp);
534 current->signal->tty = tty_kref_get(tty);
535 current->signal->tty_old_pgrp = NULL;
Peter Hurley11d9bef2014-10-16 14:59:42 -0400536}
537
Peter Hurleybce65f12014-10-16 14:59:43 -0400538static void proc_set_tty(struct tty_struct *tty)
Peter Hurley11d9bef2014-10-16 14:59:42 -0400539{
Peter Hurleybce65f12014-10-16 14:59:43 -0400540 spin_lock_irq(&current->sighand->siglock);
541 __proc_set_tty(tty);
542 spin_unlock_irq(&current->sighand->siglock);
Peter Hurley11d9bef2014-10-16 14:59:42 -0400543}
544
545struct tty_struct *get_current_tty(void)
546{
547 struct tty_struct *tty;
548 unsigned long flags;
549
550 spin_lock_irqsave(&current->sighand->siglock, flags);
551 tty = tty_kref_get(current->signal->tty);
552 spin_unlock_irqrestore(&current->sighand->siglock, flags);
553 return tty;
554}
555EXPORT_SYMBOL_GPL(get_current_tty);
556
557static void session_clear_tty(struct pid *session)
558{
559 struct task_struct *p;
560 do_each_pid_task(session, PIDTYPE_SID, p) {
561 proc_clear_tty(p);
562 } while_each_pid_task(session, PIDTYPE_SID, p);
563}
564
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565/**
566 * tty_wakeup - request more data
567 * @tty: terminal
568 *
569 * Internal and external helper for wakeups of tty. This function
570 * informs the line discipline if present that the driver is ready
571 * to receive more output data.
572 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574void tty_wakeup(struct tty_struct *tty)
575{
576 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800577
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
579 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800580 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100581 if (ld->ops->write_wakeup)
582 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 tty_ldisc_deref(ld);
584 }
585 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700586 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
588
589EXPORT_SYMBOL_GPL(tty_wakeup);
590
591/**
Peter Hurleyea648a42013-03-06 07:20:53 -0500592 * tty_signal_session_leader - sends SIGHUP to session leader
Peter Hurleyf91e2592013-03-06 07:20:56 -0500593 * @tty controlling tty
594 * @exit_session if non-zero, signal all foreground group processes
Peter Hurleyea648a42013-03-06 07:20:53 -0500595 *
Peter Hurleyf91e2592013-03-06 07:20:56 -0500596 * Send SIGHUP and SIGCONT to the session leader and its process group.
597 * Optionally, signal all processes in the foreground process group.
Peter Hurleyea648a42013-03-06 07:20:53 -0500598 *
599 * Returns the number of processes in the session with this tty
600 * as their controlling terminal. This value is used to drop
601 * tty references for those processes.
602 */
Peter Hurleyf91e2592013-03-06 07:20:56 -0500603static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)
Peter Hurleyea648a42013-03-06 07:20:53 -0500604{
605 struct task_struct *p;
Peter Hurleyea648a42013-03-06 07:20:53 -0500606 int refs = 0;
Peter Hurleyf91e2592013-03-06 07:20:56 -0500607 struct pid *tty_pgrp = NULL;
Peter Hurleyea648a42013-03-06 07:20:53 -0500608
609 read_lock(&tasklist_lock);
610 if (tty->session) {
611 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
612 spin_lock_irq(&p->sighand->siglock);
613 if (p->signal->tty == tty) {
614 p->signal->tty = NULL;
615 /* We defer the dereferences outside fo
616 the tasklist lock */
617 refs++;
618 }
619 if (!p->signal->leader) {
620 spin_unlock_irq(&p->sighand->siglock);
621 continue;
622 }
623 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
624 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
625 put_pid(p->signal->tty_old_pgrp); /* A noop */
Peter Hurleybc30c3b2013-03-06 07:20:55 -0500626 spin_lock(&tty->ctrl_lock);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500627 tty_pgrp = get_pid(tty->pgrp);
Peter Hurleyea648a42013-03-06 07:20:53 -0500628 if (tty->pgrp)
629 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Peter Hurleybc30c3b2013-03-06 07:20:55 -0500630 spin_unlock(&tty->ctrl_lock);
Peter Hurleyea648a42013-03-06 07:20:53 -0500631 spin_unlock_irq(&p->sighand->siglock);
632 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
633 }
634 read_unlock(&tasklist_lock);
635
Peter Hurleyf91e2592013-03-06 07:20:56 -0500636 if (tty_pgrp) {
637 if (exit_session)
638 kill_pgrp(tty_pgrp, SIGHUP, exit_session);
639 put_pid(tty_pgrp);
640 }
641
Peter Hurleyea648a42013-03-06 07:20:53 -0500642 return refs;
643}
644
645/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200646 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000647 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700648 *
Kevin Cernekeeef4f5272012-12-26 20:43:41 -0800649 * This can be called by a "kworker" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700650 * synchronous but doesn't hold any locks, so we need to make sure we
651 * have the appropriate locks for what we're doing.
652 *
653 * The hangup event clears any pending redirections onto the hung up
654 * device. It ensures future writes will error and it does the needed
655 * line discipline hangup and signal delivery. The tty object itself
656 * remains intact.
657 *
658 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200659 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800660 * redirect lock for undoing redirection
661 * file list lock for manipulating list of ttys
Peter Hurley137084b2013-06-15 07:04:46 -0400662 * tty_ldiscs_lock from called functions
Peter Hurley6a1c0682013-06-15 09:14:23 -0400663 * termios_rwsem resetting termios data
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800664 * tasklist_lock to walk task list for hangup event
665 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 */
Peter Hurleyf91e2592013-03-06 07:20:56 -0500667static void __tty_hangup(struct tty_struct *tty, int exit_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668{
Alan Cox37bdfb02008-02-08 04:18:47 -0800669 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 struct file *filp, *f = NULL;
Nick Piggind996b622010-08-18 04:37:36 +1000671 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 int closecount = 0, n;
Peter Hurleyea648a42013-03-06 07:20:53 -0500673 int refs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
675 if (!tty)
676 return;
677
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
679 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000680 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 f = redirect;
682 redirect = NULL;
683 }
684 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800685
Alan Cox89c8d912012-08-08 16:30:13 +0100686 tty_lock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200687
Peter Hurleycb50e522013-07-31 14:05:45 -0400688 if (test_bit(TTY_HUPPED, &tty->flags)) {
689 tty_unlock(tty);
690 return;
691 }
692
Arnd Bergmannec79d602010-06-01 22:53:01 +0200693 /* inuse_filps is protected by the single tty lock,
694 this really needs to change if we want to flush the
695 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200696 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000697
Nick Pigginee2ffa02010-08-18 04:37:35 +1000698 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000700 list_for_each_entry(priv, &tty->tty_files, list) {
701 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 if (filp->f_op->write == redirected_tty_write)
703 cons_filp = filp;
704 if (filp->f_op->write != tty_write)
705 continue;
706 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200707 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 filp->f_op = &hung_up_tty_fops;
709 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000710 spin_unlock(&tty_files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800711
Peter Hurley25fdf242013-03-06 07:20:57 -0500712 refs = tty_signal_session_leader(tty, exit_session);
713 /* Account for the p->signal references we killed */
714 while (refs--)
715 tty_kref_put(tty);
716
Alan Coxc65c9bc2009-06-11 12:50:12 +0100717 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800718
Peter Hurley20cc2252013-03-06 07:20:54 -0500719 spin_lock_irq(&tty->ctrl_lock);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100720 clear_bit(TTY_THROTTLED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100721 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600722 put_pid(tty->session);
723 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800724 tty->session = NULL;
725 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 tty->ctrl_status = 0;
Peter Hurley20cc2252013-03-06 07:20:54 -0500727 spin_unlock_irq(&tty->ctrl_lock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100728
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800730 * If one of the devices matches a console pointer, we
731 * cannot just call hangup() because that will cause
732 * tty->count and state->count to go out of sync.
733 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 */
735 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700736 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700738 tty->ops->close(tty, cons_filp);
739 } else if (tty->ops->hangup)
Peter Hurley7c6d3402014-06-16 09:17:08 -0400740 tty->ops->hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800741 /*
742 * We don't want to have driver/ldisc interactions beyond
743 * the ones we did here. The driver layer expects no
744 * calls after ->hangup() from the ldisc side. However we
745 * can't yet guarantee all that.
746 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 set_bit(TTY_HUPPED, &tty->flags);
Alan Cox89c8d912012-08-08 16:30:13 +0100748 tty_unlock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 if (f)
751 fput(f);
752}
753
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200754static void do_tty_hangup(struct work_struct *work)
755{
756 struct tty_struct *tty =
757 container_of(work, struct tty_struct, hangup_work);
758
Peter Hurleyf91e2592013-03-06 07:20:56 -0500759 __tty_hangup(tty, 0);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200760}
761
Alan Coxaf9b8972006-08-27 01:24:01 -0700762/**
763 * tty_hangup - trigger a hangup event
764 * @tty: tty to hangup
765 *
766 * A carrier loss (virtual or otherwise) has occurred on this like
767 * schedule a hangup sequence to run after this event.
768 */
769
Alan Cox37bdfb02008-02-08 04:18:47 -0800770void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771{
772#ifdef TTY_DEBUG_HANGUP
773 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
775#endif
776 schedule_work(&tty->hangup_work);
777}
778
779EXPORT_SYMBOL(tty_hangup);
780
Alan Coxaf9b8972006-08-27 01:24:01 -0700781/**
782 * tty_vhangup - process vhangup
783 * @tty: tty to hangup
784 *
785 * The user has asked via system call for the terminal to be hung up.
786 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200787 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700788 */
789
Alan Cox37bdfb02008-02-08 04:18:47 -0800790void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791{
792#ifdef TTY_DEBUG_HANGUP
793 char buf[64];
794
795 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
796#endif
Peter Hurleyf91e2592013-03-06 07:20:56 -0500797 __tty_hangup(tty, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798}
Alan Cox37bdfb02008-02-08 04:18:47 -0800799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800EXPORT_SYMBOL(tty_vhangup);
801
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200802
Alan Coxaf9b8972006-08-27 01:24:01 -0700803/**
Alan Cox2cb59982008-10-13 10:40:30 +0100804 * tty_vhangup_self - process vhangup for own ctty
805 *
806 * Perform a vhangup on the current controlling tty
807 */
808
809void tty_vhangup_self(void)
810{
811 struct tty_struct *tty;
812
Alan Cox2cb59982008-10-13 10:40:30 +0100813 tty = get_current_tty();
814 if (tty) {
815 tty_vhangup(tty);
816 tty_kref_put(tty);
817 }
Alan Cox2cb59982008-10-13 10:40:30 +0100818}
819
820/**
Peter Hurleyf91e2592013-03-06 07:20:56 -0500821 * tty_vhangup_session - hangup session leader exit
822 * @tty: tty to hangup
823 *
824 * The session leader is exiting and hanging up its controlling terminal.
825 * Every process in the foreground process group is signalled SIGHUP.
826 *
827 * We do this synchronously so that when the syscall returns the process
828 * is complete. That guarantee is necessary for security reasons.
829 */
830
Changlong Xie44a459f2013-03-20 08:42:04 +0800831static void tty_vhangup_session(struct tty_struct *tty)
Peter Hurleyf91e2592013-03-06 07:20:56 -0500832{
833#ifdef TTY_DEBUG_HANGUP
834 char buf[64];
835
836 printk(KERN_DEBUG "%s vhangup session...\n", tty_name(tty, buf));
837#endif
838 __tty_hangup(tty, 1);
839}
840
841/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700842 * tty_hung_up_p - was tty hung up
843 * @filp: file pointer of tty
844 *
845 * Return true if the tty has been subject to a vhangup or a carrier
846 * loss
847 */
848
Alan Cox37bdfb02008-02-08 04:18:47 -0800849int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850{
851 return (filp->f_op == &hung_up_tty_fops);
852}
853
854EXPORT_SYMBOL(tty_hung_up_p);
855
Alan Coxaf9b8972006-08-27 01:24:01 -0700856/**
857 * disassociate_ctty - disconnect controlling tty
858 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700860 * This function is typically called only by the session leader, when
861 * it wants to disassociate itself from its controlling tty.
862 *
863 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
865 * (2) Clears the tty from being controlling the session
866 * (3) Clears the controlling tty for all processes in the
867 * session group.
868 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700869 * The argument on_exit is set to 1 if called when a process is
870 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
871 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800872 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200873 * BTM is taken for hysterical raisins, and held when
874 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800875 * tty_mutex is taken to protect tty
876 * ->siglock is taken to protect ->signal/->sighand
877 * tasklist_lock is taken to walk process list for sessions
878 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700880
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881void disassociate_ctty(int on_exit)
882{
883 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
Alan Cox5ec93d12009-11-30 13:18:45 +0000885 if (!current->signal->leader)
886 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800888 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 if (tty) {
Peter Hurleyf91e2592013-03-06 07:20:56 -0500890 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {
891 tty_vhangup_session(tty);
892 } else {
893 struct pid *tty_pgrp = tty_get_pgrp(tty);
894 if (tty_pgrp) {
895 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Oleg Nesterov03e12612013-09-15 17:50:26 +0200896 if (!on_exit)
897 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500898 put_pid(tty_pgrp);
899 }
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200900 }
Alan Cox452a00d2008-10-13 10:39:13 +0100901 tty_kref_put(tty);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500902
Eric W. Biederman680a9672007-02-12 00:52:52 -0800903 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800904 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800905 spin_lock_irq(&current->sighand->siglock);
906 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800907 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800908 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800909 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800910 kill_pgrp(old_pgrp, SIGHUP, on_exit);
911 kill_pgrp(old_pgrp, SIGCONT, on_exit);
912 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 return;
915 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800917 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700918 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800919 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800920
Chen Tingjiec70dbb12014-04-15 11:52:51 +0800921 tty = tty_kref_get(current->signal->tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800922 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700923 unsigned long flags;
924 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800925 put_pid(tty->session);
926 put_pid(tty->pgrp);
927 tty->session = NULL;
928 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700929 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100930 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800931 } else {
932#ifdef TTY_DEBUG_HANGUP
933 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
934 " = NULL", tty);
935#endif
936 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Chen Tingjiec70dbb12014-04-15 11:52:51 +0800938 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 /* Now clear signal->tty under the lock */
940 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800941 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943}
944
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700945/**
946 *
947 * no_tty - Ensure the current process does not have a controlling tty
948 */
949void no_tty(void)
950{
Alan Cox3af502b2012-05-03 22:21:53 +0100951 /* FIXME: Review locking here. The tty_lock never covered any race
952 between a new association and proc_clear_tty but possible we need
953 to protect against this anyway */
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700954 struct task_struct *tsk = current;
Alan Cox5ec93d12009-11-30 13:18:45 +0000955 disassociate_ctty(0);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700956 proc_clear_tty(tsk);
957}
958
Alan Coxaf9b8972006-08-27 01:24:01 -0700959
960/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200961 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700962 * @tty: tty to stop
963 *
Peter Hurley01adc802014-09-10 15:06:32 -0400964 * Perform flow control to the driver. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700965 * on an already stopped device and will not re-call the driver
966 * method.
967 *
968 * This functionality is used by both the line disciplines for
969 * halting incoming flow and by the driver. It may therefore be
970 * called from any context, may be under the tty atomic_write_lock
971 * but not always.
972 *
973 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400974 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700975 */
976
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400977void __stop_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978{
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400979 if (tty->stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 return;
981 tty->stopped = 1;
Alan Coxf34d7a52008-04-30 00:54:13 -0700982 if (tty->ops->stop)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500983 tty->ops->stop(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984}
985
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400986void stop_tty(struct tty_struct *tty)
987{
988 unsigned long flags;
989
990 spin_lock_irqsave(&tty->flow_lock, flags);
991 __stop_tty(tty);
992 spin_unlock_irqrestore(&tty->flow_lock, flags);
993}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994EXPORT_SYMBOL(stop_tty);
995
Alan Coxaf9b8972006-08-27 01:24:01 -0700996/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200997 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700998 * @tty: tty to start
999 *
Peter Hurley01adc802014-09-10 15:06:32 -04001000 * Start a tty that has been stopped if at all possible. If this
1001 * tty was previous stopped and is now being started, the driver
1002 * start method is invoked and the line discipline woken.
Alan Coxaf9b8972006-08-27 01:24:01 -07001003 *
1004 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001005 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -07001006 */
1007
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001008void __start_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009{
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001010 if (!tty->stopped || tty->flow_stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 return;
1012 tty->stopped = 0;
Alan Coxf34d7a52008-04-30 00:54:13 -07001013 if (tty->ops->start)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05001014 tty->ops->start(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016}
1017
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001018void start_tty(struct tty_struct *tty)
1019{
1020 unsigned long flags;
1021
1022 spin_lock_irqsave(&tty->flow_lock, flags);
1023 __start_tty(tty);
1024 spin_unlock_irqrestore(&tty->flow_lock, flags);
1025}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026EXPORT_SYMBOL(start_tty);
1027
Linus Torvaldsb0b88562013-05-01 07:32:21 -07001028/* We limit tty time update visibility to every 8 seconds or so. */
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001029static void tty_update_time(struct timespec *time)
1030{
Linus Torvaldsb0b88562013-05-01 07:32:21 -07001031 unsigned long sec = get_seconds() & ~7;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001032 if ((long)(sec - time->tv_sec) > 0)
1033 time->tv_sec = sec;
1034}
1035
Alan Coxaf9b8972006-08-27 01:24:01 -07001036/**
1037 * tty_read - read method for tty device files
1038 * @file: pointer to tty file
1039 * @buf: user buffer
1040 * @count: size of user buffer
1041 * @ppos: unused
1042 *
1043 * Perform the read system call function on this terminal device. Checks
1044 * for hung up devices before calling the line discipline method.
1045 *
1046 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -07001047 * Locks the line discipline internally while needed. Multiple
1048 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -07001049 */
1050
Alan Cox37bdfb02008-02-08 04:18:47 -08001051static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 loff_t *ppos)
1053{
1054 int i;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001055 struct inode *inode = file_inode(file);
Nick Piggind996b622010-08-18 04:37:36 +10001056 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 struct tty_ldisc *ld;
1058
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001059 if (tty_paranoia_check(tty, inode, "tty_read"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 return -EIO;
1061 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1062 return -EIO;
1063
1064 /* We want to wait for the line discipline to sort out in this
1065 situation */
1066 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001067 if (ld->ops->read)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05001068 i = ld->ops->read(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 else
1070 i = -EIO;
1071 tty_ldisc_deref(ld);
Jiri Slabyb0de59b2013-02-15 15:25:05 +01001072
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001073 if (i > 0)
1074 tty_update_time(&inode->i_atime);
1075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 return i;
1077}
1078
Peter Hurley136d5252014-09-10 15:06:34 -04001079static void tty_write_unlock(struct tty_struct *tty)
Alan Cox9c1729d2007-07-15 23:39:43 -07001080{
1081 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -07001082 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -07001083}
1084
Peter Hurley136d5252014-09-10 15:06:34 -04001085static int tty_write_lock(struct tty_struct *tty, int ndelay)
Alan Cox9c1729d2007-07-15 23:39:43 -07001086{
1087 if (!mutex_trylock(&tty->atomic_write_lock)) {
1088 if (ndelay)
1089 return -EAGAIN;
1090 if (mutex_lock_interruptible(&tty->atomic_write_lock))
1091 return -ERESTARTSYS;
1092 }
1093 return 0;
1094}
1095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096/*
1097 * Split writes up in sane blocksizes to avoid
1098 * denial-of-service type attacks
1099 */
1100static inline ssize_t do_tty_write(
1101 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1102 struct tty_struct *tty,
1103 struct file *file,
1104 const char __user *buf,
1105 size_t count)
1106{
Alan Cox9c1729d2007-07-15 23:39:43 -07001107 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -08001109
Alan Cox9c1729d2007-07-15 23:39:43 -07001110 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1111 if (ret < 0)
1112 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
1114 /*
1115 * We chunk up writes into a temporary buffer. This
1116 * simplifies low-level drivers immensely, since they
1117 * don't have locking issues and user mode accesses.
1118 *
1119 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1120 * big chunk-size..
1121 *
1122 * The default chunk-size is 2kB, because the NTTY
1123 * layer has problems with bigger chunks. It will
1124 * claim to be able to handle more characters than
1125 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001126 *
1127 * FIXME: This can probably go away now except that 64K chunks
1128 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 */
1130 chunk = 2048;
1131 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1132 chunk = 65536;
1133 if (count < chunk)
1134 chunk = count;
1135
Ingo Molnar70522e12006-03-23 03:00:31 -08001136 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001138 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
1140 if (chunk < 1024)
1141 chunk = 1024;
1142
Jason Wessel402fda92008-10-13 10:45:36 +01001143 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1144 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001145 ret = -ENOMEM;
1146 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 }
1148 kfree(tty->write_buf);
1149 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001150 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 }
1152
1153 /* Do the write .. */
1154 for (;;) {
1155 size_t size = count;
1156 if (size > chunk)
1157 size = chunk;
1158 ret = -EFAULT;
1159 if (copy_from_user(tty->write_buf, buf, size))
1160 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 if (ret <= 0)
1163 break;
1164 written += ret;
1165 buf += ret;
1166 count -= ret;
1167 if (!count)
1168 break;
1169 ret = -ERESTARTSYS;
1170 if (signal_pending(current))
1171 break;
1172 cond_resched();
1173 }
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001174 if (written) {
1175 tty_update_time(&file_inode(file)->i_mtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 ret = written;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001177 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001178out:
1179 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 return ret;
1181}
1182
Alan Cox95f9bfc2008-10-13 10:39:23 +01001183/**
1184 * tty_write_message - write a message to a certain tty, not just the console.
1185 * @tty: the destination tty_struct
1186 * @msg: the message to write
1187 *
1188 * This is used for messages that need to be redirected to a specific tty.
1189 * We don't put it into the syslog queue right now maybe in the future if
1190 * really needed.
1191 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001192 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001193 */
1194
1195void tty_write_message(struct tty_struct *tty, char *msg)
1196{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001197 if (tty) {
1198 mutex_lock(&tty->atomic_write_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01001199 tty_lock(tty);
Peter Hurley04980702014-11-05 12:12:52 -05001200 if (tty->ops->write && tty->count > 0) {
Alan Cox89c8d912012-08-08 16:30:13 +01001201 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001202 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001203 } else
Alan Cox89c8d912012-08-08 16:30:13 +01001204 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001205 tty_write_unlock(tty);
1206 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001207 return;
1208}
1209
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210
Alan Coxaf9b8972006-08-27 01:24:01 -07001211/**
1212 * tty_write - write method for tty device file
1213 * @file: tty file pointer
1214 * @buf: user data to write
1215 * @count: bytes to write
1216 * @ppos: unused
1217 *
1218 * Write data to a tty device via the line discipline.
1219 *
1220 * Locking:
1221 * Locks the line discipline as required
1222 * Writes to the tty driver are serialized by the atomic_write_lock
1223 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001224 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001225 */
1226
Alan Cox37bdfb02008-02-08 04:18:47 -08001227static ssize_t tty_write(struct file *file, const char __user *buf,
1228 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229{
Nick Piggind996b622010-08-18 04:37:36 +10001230 struct tty_struct *tty = file_tty(file);
1231 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001233
Al Viro6131ffa2013-02-27 16:59:05 -05001234 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001236 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001237 (test_bit(TTY_IO_ERROR, &tty->flags)))
1238 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001239 /* Short term debug to catch buggy drivers */
1240 if (tty->ops->write_room == NULL)
1241 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1242 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001243 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001244 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 ret = -EIO;
1246 else
Alan Coxa352def2008-07-16 21:53:12 +01001247 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 tty_ldisc_deref(ld);
1249 return ret;
1250}
1251
Alan Cox37bdfb02008-02-08 04:18:47 -08001252ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1253 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254{
1255 struct file *p = NULL;
1256
1257 spin_lock(&redirect_lock);
Al Virocb0942b2012-08-27 14:48:26 -04001258 if (redirect)
1259 p = get_file(redirect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 spin_unlock(&redirect_lock);
1261
1262 if (p) {
1263 ssize_t res;
1264 res = vfs_write(p, buf, count, &p->f_pos);
1265 fput(p);
1266 return res;
1267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 return tty_write(file, buf, count, ppos);
1269}
1270
Peter Hurley136d5252014-09-10 15:06:34 -04001271/**
1272 * tty_send_xchar - send priority character
1273 *
1274 * Send a high priority character to the tty even if stopped
1275 *
1276 * Locking: none for xchar method, write ordering for write method.
1277 */
1278
1279int tty_send_xchar(struct tty_struct *tty, char ch)
1280{
1281 int was_stopped = tty->stopped;
1282
1283 if (tty->ops->send_xchar) {
1284 tty->ops->send_xchar(tty, ch);
1285 return 0;
1286 }
1287
1288 if (tty_write_lock(tty, 0) < 0)
1289 return -ERESTARTSYS;
1290
1291 if (was_stopped)
1292 start_tty(tty);
1293 tty->ops->write(tty, &ch, 1);
1294 if (was_stopped)
1295 stop_tty(tty);
1296 tty_write_unlock(tty);
1297 return 0;
1298}
1299
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300static char ptychar[] = "pqrstuvwxyzabcde";
1301
Alan Coxaf9b8972006-08-27 01:24:01 -07001302/**
1303 * pty_line_name - generate name for a pty
1304 * @driver: the tty driver in use
1305 * @index: the minor number
1306 * @p: output buffer of at least 6 bytes
1307 *
1308 * Generate a name from a driver reference and write it to the output
1309 * buffer.
1310 *
1311 * Locking: None
1312 */
1313static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314{
1315 int i = index + driver->name_base;
1316 /* ->name is initialized to "ttyp", but "tty" is expected */
1317 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001318 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1319 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320}
1321
Alan Coxaf9b8972006-08-27 01:24:01 -07001322/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001323 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001324 * @driver: the tty driver in use
1325 * @index: the minor number
1326 * @p: output buffer of at least 7 bytes
1327 *
1328 * Generate a name from a driver reference and write it to the output
Greg Kroah-Hartman5c0a2452014-02-22 14:31:04 -08001329 * buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07001330 *
1331 * Locking: None
1332 */
Hannes Reinecke723abd82014-02-27 12:30:51 +01001333static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334{
Jiri Slaby0019b402012-08-08 22:26:43 +02001335 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
Hannes Reinecke723abd82014-02-27 12:30:51 +01001336 return sprintf(p, "%s", driver->name);
Jiri Slaby0019b402012-08-08 22:26:43 +02001337 else
Hannes Reinecke723abd82014-02-27 12:30:51 +01001338 return sprintf(p, "%s%d", driver->name,
1339 index + driver->name_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340}
1341
Alan Cox99f1fe12008-10-13 10:42:00 +01001342/**
1343 * tty_driver_lookup_tty() - find an existing tty, if any
1344 * @driver: the driver for the tty
1345 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001346 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001347 * Return the tty, if found. If not found, return NULL or ERR_PTR() if the
1348 * driver lookup() method returns an error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001349 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001350 * Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001351 */
Jason Wessela47d5452009-01-02 13:43:04 +00001352static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001353 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001354{
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001355 struct tty_struct *tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001356
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001357 if (driver->ops->lookup)
1358 tty = driver->ops->lookup(driver, inode, idx);
1359 else
1360 tty = driver->ttys[idx];
1361
1362 if (!IS_ERR(tty))
1363 tty_kref_get(tty);
1364 return tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001365}
1366
Alan Cox99f1fe12008-10-13 10:42:00 +01001367/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001368 * tty_init_termios - helper for termios setup
1369 * @tty: the tty to set up
1370 *
1371 * Initialise the termios structures for this tty. Thus runs under
1372 * the tty_mutex currently so we can be relaxed about ordering.
1373 */
1374
1375int tty_init_termios(struct tty_struct *tty)
1376{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001377 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001378 int idx = tty->index;
1379
Alan Cox36b3c072012-07-17 17:06:57 +01001380 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1381 tty->termios = tty->driver->init_termios;
1382 else {
1383 /* Check for lazy saved data */
1384 tp = tty->driver->termios[idx];
1385 if (tp != NULL)
1386 tty->termios = *tp;
1387 else
1388 tty->termios = tty->driver->init_termios;
Alan Coxbf970ee2008-10-13 10:42:39 +01001389 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001390 /* Compatibility until drivers always set this */
Alan Coxadc8d742012-07-14 15:31:47 +01001391 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1392 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001393 return 0;
1394}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001395EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001396
Jiri Slaby66d450e2012-01-30 21:14:28 +01001397int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1398{
1399 int ret = tty_init_termios(tty);
1400 if (ret)
1401 return ret;
1402
1403 tty_driver_kref_get(driver);
1404 tty->count++;
1405 driver->ttys[tty->index] = tty;
1406 return 0;
1407}
1408EXPORT_SYMBOL_GPL(tty_standard_install);
1409
Alan Coxbf970ee2008-10-13 10:42:39 +01001410/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001411 * tty_driver_install_tty() - install a tty entry in the driver
1412 * @driver: the driver for the tty
1413 * @tty: the tty
1414 *
1415 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001416 * will be set by the time this is called. This method is responsible
1417 * for ensuring any need additional structures are allocated and
1418 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001419 *
1420 * Locking: tty_mutex for now
1421 */
1422static int tty_driver_install_tty(struct tty_driver *driver,
1423 struct tty_struct *tty)
1424{
Jiri Slaby66d450e2012-01-30 21:14:28 +01001425 return driver->ops->install ? driver->ops->install(driver, tty) :
1426 tty_standard_install(driver, tty);
Alan Cox8b0a88d2008-10-13 10:42:19 +01001427}
1428
1429/**
1430 * tty_driver_remove_tty() - remove a tty from the driver tables
1431 * @driver: the driver for the tty
1432 * @idx: the minor number
1433 *
1434 * Remvoe a tty object from the driver tables. The tty->index field
1435 * will be set by the time this is called.
1436 *
1437 * Locking: tty_mutex for now
1438 */
Jiri Slaby24d406a2011-08-10 14:59:28 +02001439void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +01001440{
1441 if (driver->ops->remove)
1442 driver->ops->remove(driver, tty);
1443 else
1444 driver->ttys[tty->index] = NULL;
1445}
1446
1447/*
1448 * tty_reopen() - fast re-open of an open tty
1449 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001450 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001451 * Return 0 on success, -errno on error.
Peter Hurley5d93e742014-11-05 12:12:47 -05001452 * Re-opens on master ptys are not allowed and return -EIO.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001453 *
Peter Hurley5d93e742014-11-05 12:12:47 -05001454 * Locking: Caller must hold tty_lock
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001455 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001456static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001457{
1458 struct tty_driver *driver = tty->driver;
1459
Peter Hurley216030e2014-11-05 12:12:48 -05001460 if (!tty->count)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001461 return -EIO;
1462
1463 if (driver->type == TTY_DRIVER_TYPE_PTY &&
Peter Hurley5d93e742014-11-05 12:12:47 -05001464 driver->subtype == PTY_TYPE_MASTER)
1465 return -EIO;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001466
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001467 tty->count++;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001468
Peter Hurley36697522013-06-15 07:04:48 -04001469 WARN_ON(!tty->ldisc);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001470
1471 return 0;
1472}
1473
Alan Coxaf9b8972006-08-27 01:24:01 -07001474/**
Alan Coxd81ed102008-10-13 10:41:42 +01001475 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001476 * @driver: tty driver we are opening a device on
1477 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001478 * @ret_tty: returned tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -07001479 *
1480 * Prepare a tty device. This may not be a "new" clean device but
1481 * could also be an active device. The pty drivers require special
1482 * handling because of this.
1483 *
1484 * Locking:
1485 * The function is called under the tty_mutex, which
1486 * protects us from the tty struct or driver itself going away.
1487 *
1488 * On exit the tty device has the line discipline attached and
1489 * a reference count of 1. If a pair was created for pty/tty use
1490 * and the other was a pty master then it too has a reference count of 1.
1491 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001493 * failed open. The new code protects the open with a mutex, so it's
1494 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 * relaxed for the (most common) case of reopening a tty.
1496 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001497
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001498struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499{
Alan Coxbf970ee2008-10-13 10:42:39 +01001500 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001501 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 /*
1504 * First time open is complex, especially for PTY devices.
1505 * This code guarantees that either everything succeeds and the
1506 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001507 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 * and locked termios may be retained.)
1509 */
1510
Alan Cox73ec06f2008-10-13 10:42:29 +01001511 if (!try_module_get(driver->owner))
1512 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02001514 tty = alloc_tty_struct(driver, idx);
Jiri Slabyd5543502011-03-23 10:48:32 +01001515 if (!tty) {
1516 retval = -ENOMEM;
1517 goto err_module_put;
1518 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Alan Cox89c8d912012-08-08 16:30:13 +01001520 tty_lock(tty);
Alan Cox73ec06f2008-10-13 10:42:29 +01001521 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001522 if (retval < 0)
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001523 goto err_deinit_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001524
Jiri Slaby04831dc2012-06-04 13:35:36 +02001525 if (!tty->port)
1526 tty->port = driver->ports[idx];
1527
Jiri Slaby5d4121c2012-08-17 14:27:52 +02001528 WARN_RATELIMIT(!tty->port,
1529 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1530 __func__, tty->driver->name);
1531
Jiri Slaby967fab62012-10-18 22:26:46 +02001532 tty->port->itty = tty;
1533
Alan Cox37bdfb02008-02-08 04:18:47 -08001534 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001536 * If we fail here just call release_tty to clean up. No need
1537 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001539 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001540 if (retval)
Jiri Slabyd5543502011-03-23 10:48:32 +01001541 goto err_release_tty;
Alan Cox89c8d912012-08-08 16:30:13 +01001542 /* Return the tty locked so that it cannot vanish under the caller */
Alan Cox73ec06f2008-10-13 10:42:29 +01001543 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001545err_deinit_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001546 tty_unlock(tty);
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001547 deinitialize_tty_struct(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001548 free_tty_struct(tty);
1549err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001551 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001553 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001554err_release_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001555 tty_unlock(tty);
Manuel Zerpies5a3c6b22011-06-16 14:07:22 +02001556 printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001557 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001558 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001559 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560}
1561
Alan Coxfeebed62008-10-13 10:41:30 +01001562void tty_free_termios(struct tty_struct *tty)
1563{
1564 struct ktermios *tp;
1565 int idx = tty->index;
Alan Cox36b3c072012-07-17 17:06:57 +01001566
1567 /* If the port is going to reset then it has no termios to save */
1568 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1569 return;
1570
1571 /* Stash the termios data */
1572 tp = tty->driver->termios[idx];
1573 if (tp == NULL) {
1574 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1575 if (tp == NULL) {
1576 pr_warn("tty: no memory to save termios state.\n");
1577 return;
1578 }
Dan Carpenter4ac5d702012-07-24 12:51:52 +01001579 tty->driver->termios[idx] = tp;
Alan Coxfeebed62008-10-13 10:41:30 +01001580 }
Alan Cox36b3c072012-07-17 17:06:57 +01001581 *tp = tty->termios;
Alan Coxfeebed62008-10-13 10:41:30 +01001582}
1583EXPORT_SYMBOL(tty_free_termios);
1584
Peter Hurleya2965b72013-03-11 16:44:35 -04001585/**
Peter Hurley949aa642014-11-05 12:12:57 -05001586 * tty_flush_works - flush all works of a tty/pty pair
1587 * @tty: tty device to flush works for (or either end of a pty pair)
Peter Hurleya2965b72013-03-11 16:44:35 -04001588 *
Peter Hurley949aa642014-11-05 12:12:57 -05001589 * Sync flush all works belonging to @tty (and the 'other' tty).
Peter Hurleya2965b72013-03-11 16:44:35 -04001590 */
1591static void tty_flush_works(struct tty_struct *tty)
1592{
1593 flush_work(&tty->SAK_work);
1594 flush_work(&tty->hangup_work);
Peter Hurley949aa642014-11-05 12:12:57 -05001595 if (tty->link) {
1596 flush_work(&tty->link->SAK_work);
1597 flush_work(&tty->link->hangup_work);
1598 }
Peter Hurleya2965b72013-03-11 16:44:35 -04001599}
Alan Coxfeebed62008-10-13 10:41:30 +01001600
Alan Coxaf9b8972006-08-27 01:24:01 -07001601/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001602 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001603 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001604 *
1605 * Releases memory associated with a tty structure, and clears out the
1606 * driver table slots. This function is called when a device is no longer
1607 * in use. It also gets called when setup of a device fails.
1608 *
1609 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -07001610 * takes the file list lock internally when working on the list
1611 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001612 *
1613 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001614 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 */
Alan Coxb50989d2009-09-19 13:13:22 -07001616static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617{
Alan Coxb50989d2009-09-19 13:13:22 -07001618 struct tty_struct *tty =
1619 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001620 struct tty_driver *driver = tty->driver;
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001621 struct module *owner = driver->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
Dave Youngf278a2f2009-09-27 16:00:42 +00001623 if (tty->ops->cleanup)
1624 tty->ops->cleanup(tty);
1625
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001627 tty_driver_kref_put(driver);
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001628 module_put(owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001629
Nick Pigginee2ffa02010-08-18 04:37:35 +10001630 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 list_del_init(&tty->tty_files);
Nick Pigginee2ffa02010-08-18 04:37:35 +10001632 spin_unlock(&tty_files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001633
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001634 put_pid(tty->pgrp);
1635 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 free_tty_struct(tty);
1637}
1638
Alan Coxb50989d2009-09-19 13:13:22 -07001639static void queue_release_one_tty(struct kref *kref)
1640{
1641 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001642
Alan Coxb50989d2009-09-19 13:13:22 -07001643 /* The hangup queue is now free so we can reuse it rather than
1644 waste a chunk of memory for each port */
1645 INIT_WORK(&tty->hangup_work, release_one_tty);
1646 schedule_work(&tty->hangup_work);
1647}
1648
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001649/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001650 * tty_kref_put - release a tty kref
1651 * @tty: tty device
1652 *
1653 * Release a reference to a tty device and if need be let the kref
1654 * layer destruct the object for us
1655 */
1656
1657void tty_kref_put(struct tty_struct *tty)
1658{
1659 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001660 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001661}
1662EXPORT_SYMBOL(tty_kref_put);
1663
1664/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001665 * release_tty - release tty structure memory
1666 *
1667 * Release both @tty and a possible linked partner (think pty pair),
1668 * and decrement the refcount of the backing module.
1669 *
1670 * Locking:
Alan Coxd1552552012-07-27 18:02:54 +01001671 * tty_mutex
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001672 * takes the file list lock internally when working on the list
1673 * of ttys that the driver keeps.
Alan Cox9c9f4de2008-10-13 10:37:26 +01001674 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001675 */
1676static void release_tty(struct tty_struct *tty, int idx)
1677{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001678 /* This should always be true but check for the moment */
1679 WARN_ON(tty->index != idx);
Alan Coxd1552552012-07-27 18:02:54 +01001680 WARN_ON(!mutex_is_locked(&tty_mutex));
Alan Cox36b3c072012-07-17 17:06:57 +01001681 if (tty->ops->shutdown)
1682 tty->ops->shutdown(tty);
1683 tty_free_termios(tty);
1684 tty_driver_remove_tty(tty->driver, tty);
Jiri Slaby967fab62012-10-18 22:26:46 +02001685 tty->port->itty = NULL;
Peter Hurley64e377d2013-06-15 09:01:00 -04001686 if (tty->link)
1687 tty->link->port->itty = NULL;
Peter Hurley4f98d462013-03-11 16:44:34 -04001688 cancel_work_sync(&tty->port->buf.work);
Alan Cox36b3c072012-07-17 17:06:57 +01001689
Markus Elfringa211b1a2014-11-21 13:42:29 +01001690 tty_kref_put(tty->link);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001691 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001692}
1693
Alan Coxeeb89d92009-11-30 13:18:29 +00001694/**
Jiri Slaby955787ca2011-11-11 10:47:23 +01001695 * tty_release_checks - check a tty before real release
1696 * @tty: tty to check
1697 * @o_tty: link of @tty (if any)
1698 * @idx: index of the tty
1699 *
1700 * Performs some paranoid checking before true release of the @tty.
1701 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1702 */
Peter Hurley359b9fb2014-11-05 12:12:59 -05001703static int tty_release_checks(struct tty_struct *tty, int idx)
Jiri Slaby955787ca2011-11-11 10:47:23 +01001704{
1705#ifdef TTY_PARANOIA_CHECK
1706 if (idx < 0 || idx >= tty->driver->num) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001707 printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1708 __func__, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001709 return -1;
1710 }
1711
1712 /* not much to check for devpts */
1713 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1714 return 0;
1715
1716 if (tty != tty->driver->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001717 printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1718 __func__, idx, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001719 return -1;
1720 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001721 if (tty->driver->other) {
Peter Hurley359b9fb2014-11-05 12:12:59 -05001722 struct tty_struct *o_tty = tty->link;
1723
Jiri Slaby955787ca2011-11-11 10:47:23 +01001724 if (o_tty != tty->driver->other->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001725 printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1726 __func__, idx, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001727 return -1;
1728 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001729 if (o_tty->link != tty) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001730 printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001731 return -1;
1732 }
1733 }
1734#endif
1735 return 0;
1736}
1737
1738/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001739 * tty_release - vfs callback for close
1740 * @inode: inode of tty
1741 * @filp: file pointer for handle to tty
1742 *
1743 * Called the last time each file handle is closed that references
1744 * this tty. There may however be several such references.
1745 *
1746 * Locking:
1747 * Takes bkl. See tty_release_dev
1748 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 * Even releasing the tty structures is a tricky business.. We have
1750 * to be very careful that the structures are all released at the
1751 * same time, as interrupts might otherwise get the wrong pointers.
1752 *
1753 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1754 * lead to double frees or releasing memory still in use.
1755 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001756
1757int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758{
Nick Piggind996b622010-08-18 04:37:36 +10001759 struct tty_struct *tty = file_tty(filp);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001760 struct tty_struct *o_tty = NULL;
1761 int do_sleep, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 int idx;
1763 char buf[64];
Peter Hurley37b16452014-10-16 13:51:30 -04001764 long timeout = 0;
Peter Hurley494c1ea2014-10-16 13:54:36 -04001765 int once = 1;
Alan Cox37bdfb02008-02-08 04:18:47 -08001766
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001767 if (tty_paranoia_check(tty, inode, __func__))
Alan Coxeeb89d92009-11-30 13:18:29 +00001768 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769
Alan Cox89c8d912012-08-08 16:30:13 +01001770 tty_lock(tty);
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001771 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
Arnd Bergmannec79d602010-06-01 22:53:01 +02001773 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774
1775 idx = tty->index;
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001776 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1777 tty->driver->subtype == PTY_TYPE_MASTER)
1778 o_tty = tty->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
Peter Hurley359b9fb2014-11-05 12:12:59 -05001780 if (tty_release_checks(tty, idx)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001781 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001782 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
1785#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001786 printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1787 tty_name(tty, buf), tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788#endif
1789
Alan Coxf34d7a52008-04-30 00:54:13 -07001790 if (tty->ops->close)
1791 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
Peter Hurley2aff5e22014-11-05 12:13:01 -05001793 /* If tty is pty master, lock the slave pty (stable lock order) */
1794 tty_lock_slave(o_tty);
1795
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 /*
1797 * Sanity check: if tty->count is going to zero, there shouldn't be
1798 * any waiters on tty->read_wait or tty->write_wait. We test the
1799 * wait queues and kick everyone out _before_ actually starting to
1800 * close. This ensures that we won't block while releasing the tty
1801 * structure.
1802 *
1803 * The test for the o_tty closing is necessary, since the master and
1804 * slave sides may close in any order. If the slave side closes out
1805 * first, its count will be one, since the master side holds an open.
Peter Hurley324c1652014-11-05 12:12:56 -05001806 * Thus this test wouldn't be triggered at the time the slave closed,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 * so we do it now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 */
1809 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 do_sleep = 0;
1811
Peter Hurley324c1652014-11-05 12:12:56 -05001812 if (tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001814 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 do_sleep++;
1816 }
1817 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001818 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 do_sleep++;
1820 }
1821 }
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001822 if (o_tty && o_tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001824 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 do_sleep++;
1826 }
1827 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001828 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 do_sleep++;
1830 }
1831 }
1832 if (!do_sleep)
1833 break;
1834
Peter Hurley494c1ea2014-10-16 13:54:36 -04001835 if (once) {
1836 once = 0;
1837 printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1838 __func__, tty_name(tty, buf));
1839 }
Peter Hurley37b16452014-10-16 13:51:30 -04001840 schedule_timeout_killable(timeout);
1841 if (timeout < 120 * HZ)
1842 timeout = 2 * timeout + 1;
1843 else
1844 timeout = MAX_SCHEDULE_TIMEOUT;
Alan Cox37bdfb02008-02-08 04:18:47 -08001845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001847 if (o_tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 if (--o_tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001849 printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1850 __func__, o_tty->count, tty_name(o_tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 o_tty->count = 0;
1852 }
1853 }
1854 if (--tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001855 printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1856 __func__, tty->count, tty_name(tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 tty->count = 0;
1858 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001859
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 /*
1861 * We've decremented tty->count, so we need to remove this file
1862 * descriptor off the tty->tty_files list; this serves two
1863 * purposes:
1864 * - check_tty_count sees the correct number of file descriptors
1865 * associated with this tty.
1866 * - do_tty_hangup no longer sees this file descriptor as
1867 * something that needs to be handled for hangups.
1868 */
Nick Piggind996b622010-08-18 04:37:36 +10001869 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870
1871 /*
1872 * Perform some housekeeping before deciding whether to return.
1873 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 * If _either_ side is closing, make sure there aren't any
1875 * processes that still think tty or o_tty is their controlling
1876 * tty.
1877 */
Peter Hurley324c1652014-11-05 12:12:56 -05001878 if (!tty->count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001880 session_clear_tty(tty->session);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001881 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001882 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 read_unlock(&tasklist_lock);
1884 }
1885
Peter Hurley324c1652014-11-05 12:12:56 -05001886 /* check whether both sides are closing ... */
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001887 final = !tty->count && !(o_tty && o_tty->count);
Peter Hurley324c1652014-11-05 12:12:56 -05001888
Peter Hurley2aff5e22014-11-05 12:13:01 -05001889 tty_unlock_slave(o_tty);
1890 tty_unlock(tty);
1891
Peter Hurley04980702014-11-05 12:12:52 -05001892 /* At this point, the tty->count == 0 should ensure a dead tty
Alan Coxd1552552012-07-27 18:02:54 +01001893 cannot be re-opened by a racing opener */
Paul Fulghumda965822006-02-14 13:53:00 -08001894
Peter Hurley324c1652014-11-05 12:12:56 -05001895 if (!final)
Alan Coxeeb89d92009-11-30 13:18:29 +00001896 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001897
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898#ifdef TTY_DEBUG_HANGUP
Peter Hurley96433d12013-03-11 16:44:37 -04001899 printk(KERN_DEBUG "%s: %s: final close\n", __func__, tty_name(tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900#endif
1901 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001902 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 */
Peter Hurley62462ae2014-11-05 12:12:58 -05001904 tty_ldisc_release(tty);
Peter Hurleya2965b72013-03-11 16:44:35 -04001905
1906 /* Wait for pending work before tty destruction commmences */
1907 tty_flush_works(tty);
Peter Hurleya2965b72013-03-11 16:44:35 -04001908
Peter Hurley96433d12013-03-11 16:44:37 -04001909#ifdef TTY_DEBUG_HANGUP
1910 printk(KERN_DEBUG "%s: %s: freeing structure...\n", __func__, tty_name(tty, buf));
1911#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001913 * The release_tty function takes care of the details of clearing
Alan Cox89c8d912012-08-08 16:30:13 +01001914 * the slots and preserving the termios structure. The tty_unlock_pair
1915 * should be safe as we keep a kref while the tty is locked (so the
1916 * unlock never unlocks a freed tty).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 */
Alan Coxd1552552012-07-27 18:02:54 +01001918 mutex_lock(&tty_mutex);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001919 release_tty(tty, idx);
Alan Coxd1552552012-07-27 18:02:54 +01001920 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
Alan Coxeeb89d92009-11-30 13:18:29 +00001922 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923}
1924
Alan Coxaf9b8972006-08-27 01:24:01 -07001925/**
Peter Hurley52494ee2014-11-05 12:12:50 -05001926 * tty_open_current_tty - get locked tty of current task
Jiri Slabyb82154a2011-11-09 21:33:19 +01001927 * @device: device number
1928 * @filp: file pointer to tty
Peter Hurley52494ee2014-11-05 12:12:50 -05001929 * @return: locked tty of the current task iff @device is /dev/tty
1930 *
1931 * Performs a re-open of the current task's controlling tty.
Jiri Slabyb82154a2011-11-09 21:33:19 +01001932 *
1933 * We cannot return driver and index like for the other nodes because
1934 * devpts will not work then. It expects inodes to be from devpts FS.
1935 */
1936static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1937{
1938 struct tty_struct *tty;
Peter Hurley52494ee2014-11-05 12:12:50 -05001939 int retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01001940
1941 if (device != MKDEV(TTYAUX_MAJOR, 0))
1942 return NULL;
1943
1944 tty = get_current_tty();
1945 if (!tty)
1946 return ERR_PTR(-ENXIO);
1947
1948 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1949 /* noctty = 1; */
Peter Hurley52494ee2014-11-05 12:12:50 -05001950 tty_lock(tty);
1951 tty_kref_put(tty); /* safe to drop the kref now */
1952
1953 retval = tty_reopen(tty);
1954 if (retval < 0) {
1955 tty_unlock(tty);
1956 tty = ERR_PTR(retval);
1957 }
Jiri Slabyb82154a2011-11-09 21:33:19 +01001958 return tty;
1959}
1960
1961/**
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001962 * tty_lookup_driver - lookup a tty driver for a given device file
1963 * @device: device number
1964 * @filp: file pointer to tty
1965 * @noctty: set if the device should not become a controlling tty
1966 * @index: index for the device in the @return driver
1967 * @return: driver for this inode (with increased refcount)
1968 *
1969 * If @return is not erroneous, the caller is responsible to decrement the
1970 * refcount by tty_driver_kref_put.
1971 *
1972 * Locking: tty_mutex protects get_tty_driver
1973 */
1974static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1975 int *noctty, int *index)
1976{
1977 struct tty_driver *driver;
1978
Jiri Slaby2cd00502011-11-09 21:33:22 +01001979 switch (device) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001980#ifdef CONFIG_VT
Jiri Slaby2cd00502011-11-09 21:33:22 +01001981 case MKDEV(TTY_MAJOR, 0): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001982 extern struct tty_driver *console_driver;
1983 driver = tty_driver_kref_get(console_driver);
1984 *index = fg_console;
1985 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001986 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001987 }
1988#endif
Jiri Slaby2cd00502011-11-09 21:33:22 +01001989 case MKDEV(TTYAUX_MAJOR, 1): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001990 struct tty_driver *console_driver = console_device(index);
1991 if (console_driver) {
1992 driver = tty_driver_kref_get(console_driver);
1993 if (driver) {
1994 /* Don't let /dev/console block */
1995 filp->f_flags |= O_NONBLOCK;
1996 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001997 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001998 }
1999 }
2000 return ERR_PTR(-ENODEV);
2001 }
Jiri Slaby2cd00502011-11-09 21:33:22 +01002002 default:
2003 driver = get_tty_driver(device, index);
2004 if (!driver)
2005 return ERR_PTR(-ENODEV);
2006 break;
2007 }
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002008 return driver;
2009}
2010
2011/**
Alan Coxeeb89d92009-11-30 13:18:29 +00002012 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002013 * @inode: inode of device file
2014 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002016 * tty_open and tty_release keep up the tty count that contains the
2017 * number of opens done on a tty. We cannot use the inode-count, as
2018 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002020 * Open-counting is needed for pty masters, as well as for keeping
2021 * track of serial lines: DTR is dropped when the last close happens.
2022 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2023 *
2024 * The termios state of a pty is reset on first open so that
2025 * settings don't persist across reuse.
2026 *
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002027 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002028 * tty->count should protect the rest.
2029 * ->siglock protects ->signal/->sighand
Alan Cox89c8d912012-08-08 16:30:13 +01002030 *
2031 * Note: the tty_unlock/lock cases without a ref are only safe due to
2032 * tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002034
Alan Coxeeb89d92009-11-30 13:18:29 +00002035static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036{
Jiri Slabyb82154a2011-11-09 21:33:19 +01002037 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 int noctty, retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01002039 struct tty_driver *driver = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 int index;
2041 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07002042 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043
2044 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08002045
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046retry_open:
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002047 retval = tty_alloc_file(filp);
2048 if (retval)
2049 return -ENOMEM;
2050
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 noctty = filp->f_flags & O_NOCTTY;
2052 index = -1;
2053 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002054
Jiri Slabyb82154a2011-11-09 21:33:19 +01002055 tty = tty_open_current_tty(device, filp);
Peter Hurley52494ee2014-11-05 12:12:50 -05002056 if (!tty) {
2057 mutex_lock(&tty_mutex);
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002058 driver = tty_lookup_driver(device, filp, &noctty, &index);
2059 if (IS_ERR(driver)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01002060 retval = PTR_ERR(driver);
2061 goto err_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01002064 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01002065 tty = tty_driver_lookup_tty(driver, inode, index);
Eric Paris808ffa32009-01-27 11:50:37 +00002066 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01002067 retval = PTR_ERR(tty);
2068 goto err_unlock;
Eric Paris808ffa32009-01-27 11:50:37 +00002069 }
Peter Hurley52494ee2014-11-05 12:12:50 -05002070
2071 if (tty) {
Peter Hurleyaa3cb812014-11-05 12:12:51 -05002072 mutex_unlock(&tty_mutex);
Peter Hurley52494ee2014-11-05 12:12:50 -05002073 tty_lock(tty);
Peter Hurleyaa3cb812014-11-05 12:12:51 -05002074 /* safe to drop the kref from tty_driver_lookup_tty() */
2075 tty_kref_put(tty);
Peter Hurley52494ee2014-11-05 12:12:50 -05002076 retval = tty_reopen(tty);
2077 if (retval < 0) {
2078 tty_unlock(tty);
2079 tty = ERR_PTR(retval);
2080 }
Peter Hurleyaa3cb812014-11-05 12:12:51 -05002081 } else { /* Returns with the tty_lock held for now */
Peter Hurley52494ee2014-11-05 12:12:50 -05002082 tty = tty_init_dev(driver, index);
Peter Hurleyaa3cb812014-11-05 12:12:51 -05002083 mutex_unlock(&tty_mutex);
2084 }
Peter Hurley52494ee2014-11-05 12:12:50 -05002085
Peter Hurley52494ee2014-11-05 12:12:50 -05002086 tty_driver_kref_put(driver);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01002087 }
2088
Alan Coxeeb89d92009-11-30 13:18:29 +00002089 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01002090 retval = PTR_ERR(tty);
2091 goto err_file;
Alan Coxeeb89d92009-11-30 13:18:29 +00002092 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002094 tty_add_file(tty, filp);
Nick Piggind996b622010-08-18 04:37:36 +10002095
Jiri Slaby9de44bd2011-11-09 21:33:24 +01002096 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2098 tty->driver->subtype == PTY_TYPE_MASTER)
2099 noctty = 1;
2100#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01002101 printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102#endif
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03002103 if (tty->ops->open)
2104 retval = tty->ops->open(tty, filp);
2105 else
2106 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 filp->f_flags = saved_flags;
2108
Alan Cox37bdfb02008-02-08 04:18:47 -08002109 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
2110 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 retval = -EBUSY;
2112
2113 if (retval) {
2114#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01002115 printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
2116 retval, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117#endif
Alan Cox89c8d912012-08-08 16:30:13 +01002118 tty_unlock(tty); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00002119 tty_release(inode, filp);
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002120 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 return retval;
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002122
2123 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124 return retval;
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002125
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 schedule();
2127 /*
2128 * Need to reset f_op in case a hangup happened.
2129 */
Peter Hurley12569372014-11-05 12:26:24 -05002130 if (tty_hung_up_p(filp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 filp->f_op = &tty_fops;
2132 goto retry_open;
2133 }
Peter Hurleyd4855e12013-11-19 08:46:27 -05002134 clear_bit(TTY_HUPPED, &tty->flags);
Alan Coxeeb89d92009-11-30 13:18:29 +00002135
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002136
Peter Hurley2c411c12014-10-16 14:59:47 -04002137 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002138 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 if (!noctty &&
2140 current->signal->leader &&
2141 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002142 tty->session == NULL)
Peter Hurleybce65f12014-10-16 14:59:43 -04002143 __proc_set_tty(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002144 spin_unlock_irq(&current->sighand->siglock);
Peter Hurley2c411c12014-10-16 14:59:47 -04002145 read_unlock(&tasklist_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01002146 tty_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 return 0;
Jiri Slabyba5db442011-11-09 21:33:21 +01002148err_unlock:
Jiri Slabyba5db442011-11-09 21:33:21 +01002149 mutex_unlock(&tty_mutex);
2150 /* after locks to avoid deadlock */
2151 if (!IS_ERR_OR_NULL(driver))
2152 tty_driver_kref_put(driver);
2153err_file:
2154 tty_free_file(filp);
2155 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156}
2157
Jonathan Corbet39d95b92008-05-16 09:10:50 -06002158
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
Alan Coxaf9b8972006-08-27 01:24:01 -07002160/**
2161 * tty_poll - check tty status
2162 * @filp: file being polled
2163 * @wait: poll wait structures to update
2164 *
2165 * Call the line discipline polling method to obtain the poll
2166 * status of the device.
2167 *
2168 * Locking: locks called line discipline but ldisc poll method
2169 * may be re-entered freely by other callers.
2170 */
2171
Alan Cox37bdfb02008-02-08 04:18:47 -08002172static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173{
Nick Piggind996b622010-08-18 04:37:36 +10002174 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 struct tty_ldisc *ld;
2176 int ret = 0;
2177
Al Viro6131ffa2013-02-27 16:59:05 -05002178 if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002180
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002182 if (ld->ops->poll)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002183 ret = ld->ops->poll(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 tty_ldisc_deref(ld);
2185 return ret;
2186}
2187
Arnd Bergmannec79d602010-06-01 22:53:01 +02002188static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189{
Nick Piggind996b622010-08-18 04:37:36 +10002190 struct tty_struct *tty = file_tty(filp);
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002191 struct tty_ldisc *ldisc;
Alan Cox47f86832008-04-30 00:53:30 -07002192 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002193 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194
Al Viro6131ffa2013-02-27 16:59:05 -05002195 if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002196 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08002197
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 retval = fasync_helper(fd, filp, on, &tty->fasync);
2199 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002200 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002202 ldisc = tty_ldisc_ref(tty);
2203 if (ldisc) {
2204 if (ldisc->ops->fasync)
2205 ldisc->ops->fasync(tty, on);
2206 tty_ldisc_deref(ldisc);
2207 }
2208
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002210 enum pid_type type;
2211 struct pid *pid;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002212
Alan Cox47f86832008-04-30 00:53:30 -07002213 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002214 if (tty->pgrp) {
2215 pid = tty->pgrp;
2216 type = PIDTYPE_PGID;
2217 } else {
2218 pid = task_pid(current);
2219 type = PIDTYPE_PID;
2220 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002221 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002222 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002223 __f_setown(filp, pid, type, 0);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002224 put_pid(pid);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002225 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002227out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002228 return retval;
2229}
2230
2231static int tty_fasync(int fd, struct file *filp, int on)
2232{
Alan Cox89c8d912012-08-08 16:30:13 +01002233 struct tty_struct *tty = file_tty(filp);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002234 int retval;
Alan Cox89c8d912012-08-08 16:30:13 +01002235
2236 tty_lock(tty);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002237 retval = __tty_fasync(fd, filp, on);
Alan Cox89c8d912012-08-08 16:30:13 +01002238 tty_unlock(tty);
2239
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002240 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241}
2242
Alan Coxaf9b8972006-08-27 01:24:01 -07002243/**
2244 * tiocsti - fake input character
2245 * @tty: tty to fake input into
2246 * @p: pointer to character
2247 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002248 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002249 * input management.
2250 *
2251 * FIXME: does not honour flow control ??
2252 *
2253 * Locking:
Peter Hurley137084b2013-06-15 07:04:46 -04002254 * Called functions take tty_ldiscs_lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002255 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002256 *
2257 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002258 */
2259
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260static int tiocsti(struct tty_struct *tty, char __user *p)
2261{
2262 char ch, mbz = 0;
2263 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002264
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2266 return -EPERM;
2267 if (get_user(ch, p))
2268 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002269 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002271 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 tty_ldisc_deref(ld);
2273 return 0;
2274}
2275
Alan Coxaf9b8972006-08-27 01:24:01 -07002276/**
2277 * tiocgwinsz - implement window query ioctl
2278 * @tty; tty
2279 * @arg: user buffer for result
2280 *
Alan Cox808a0d32006-09-29 02:00:40 -07002281 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002282 *
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002283 * Locking: tty->winsize_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002284 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002285 */
2286
Alan Cox37bdfb02008-02-08 04:18:47 -08002287static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288{
Alan Cox808a0d32006-09-29 02:00:40 -07002289 int err;
2290
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002291 mutex_lock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002292 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002293 mutex_unlock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002294
2295 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296}
2297
Alan Coxaf9b8972006-08-27 01:24:01 -07002298/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002299 * tty_do_resize - resize event
2300 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002301 * @rows: rows (character)
2302 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002303 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002304 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002305 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002306 */
2307
Alan Coxfc6f6232009-01-02 13:43:17 +00002308int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309{
Alan Coxfc6f6232009-01-02 13:43:17 +00002310 struct pid *pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311
Alan Coxfc6f6232009-01-02 13:43:17 +00002312 /* Lock the tty */
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002313 mutex_lock(&tty->winsize_mutex);
Alan Coxfc6f6232009-01-02 13:43:17 +00002314 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002315 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002316
Peter Hurley5b239542014-10-16 14:59:45 -04002317 /* Signal the foreground process group */
2318 pgrp = tty_get_pgrp(tty);
Alan Cox47f86832008-04-30 00:53:30 -07002319 if (pgrp)
2320 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002321 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002322
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002323 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002324done:
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002325 mutex_unlock(&tty->winsize_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 return 0;
2327}
Martin Schwidefsky4d334fd2013-01-04 14:55:13 +01002328EXPORT_SYMBOL(tty_do_resize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
Alan Coxaf9b8972006-08-27 01:24:01 -07002330/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002331 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002332 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002333 * @arg: user buffer for result
2334 *
2335 * Copies the user idea of the window size to the kernel. Traditionally
2336 * this is just advisory information but for the Linux console it
2337 * actually has driver level meaning and triggers a VC resize.
2338 *
2339 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002340 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002341 * tty termios mutex and ctrl_lock. The console takes its own lock
2342 * then calls into the default method.
2343 */
2344
Alan Coxfc6f6232009-01-02 13:43:17 +00002345static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002346{
2347 struct winsize tmp_ws;
2348 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2349 return -EFAULT;
2350
2351 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002352 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002353 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002354 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002355}
2356
2357/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002358 * tioccons - allow admin to move logical console
2359 * @file: the file to become console
2360 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002361 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002362 *
2363 * Locking: uses redirect_lock to guard the redirect information
2364 */
2365
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366static int tioccons(struct file *file)
2367{
2368 if (!capable(CAP_SYS_ADMIN))
2369 return -EPERM;
2370 if (file->f_op->write == redirected_tty_write) {
2371 struct file *f;
2372 spin_lock(&redirect_lock);
2373 f = redirect;
2374 redirect = NULL;
2375 spin_unlock(&redirect_lock);
2376 if (f)
2377 fput(f);
2378 return 0;
2379 }
2380 spin_lock(&redirect_lock);
2381 if (redirect) {
2382 spin_unlock(&redirect_lock);
2383 return -EBUSY;
2384 }
Al Virocb0942b2012-08-27 14:48:26 -04002385 redirect = get_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 spin_unlock(&redirect_lock);
2387 return 0;
2388}
2389
Alan Coxaf9b8972006-08-27 01:24:01 -07002390/**
2391 * fionbio - non blocking ioctl
2392 * @file: file to set blocking value
2393 * @p: user parameter
2394 *
2395 * Historical tty interfaces had a blocking control ioctl before
2396 * the generic functionality existed. This piece of history is preserved
2397 * in the expected tty API of posix OS's.
2398 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002399 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002400 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401
2402static int fionbio(struct file *file, int __user *p)
2403{
2404 int nonblock;
2405
2406 if (get_user(nonblock, p))
2407 return -EFAULT;
2408
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002409 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 if (nonblock)
2411 file->f_flags |= O_NONBLOCK;
2412 else
2413 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002414 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 return 0;
2416}
2417
Alan Coxaf9b8972006-08-27 01:24:01 -07002418/**
2419 * tiocsctty - set controlling tty
2420 * @tty: tty structure
2421 * @arg: user argument
2422 *
2423 * This ioctl is used to manage job control. It permits a session
2424 * leader to set this tty as the controlling tty for the session.
2425 *
2426 * Locking:
Peter Hurleye218eb32014-10-16 14:59:49 -04002427 * Takes tty_lock() to serialize proc_set_tty() for this tty
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002428 * Takes tasklist_lock internally to walk sessions
2429 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002430 */
2431
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432static int tiocsctty(struct tty_struct *tty, int arg)
2433{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002434 int ret = 0;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002435
Peter Hurleye218eb32014-10-16 14:59:49 -04002436 tty_lock(tty);
Peter Hurley2c411c12014-10-16 14:59:47 -04002437 read_lock(&tasklist_lock);
2438
2439 if (current->signal->leader && (task_session(current) == tty->session))
2440 goto unlock;
2441
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 /*
2443 * The process must be a session leader and
2444 * not have a controlling tty already.
2445 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002446 if (!current->signal->leader || current->signal->tty) {
2447 ret = -EPERM;
2448 goto unlock;
2449 }
2450
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002451 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 /*
2453 * This tty is already the controlling
2454 * tty for another session group!
2455 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002456 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 /*
2458 * Steal it away
2459 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002460 session_clear_tty(tty->session);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002461 } else {
2462 ret = -EPERM;
2463 goto unlock;
2464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 }
Peter Hurleybce65f12014-10-16 14:59:43 -04002466 proc_set_tty(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002467unlock:
Peter Hurley2c411c12014-10-16 14:59:47 -04002468 read_unlock(&tasklist_lock);
Peter Hurleye218eb32014-10-16 14:59:49 -04002469 tty_unlock(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002470 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471}
2472
Alan Coxaf9b8972006-08-27 01:24:01 -07002473/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002474 * tty_get_pgrp - return a ref counted pgrp pid
2475 * @tty: tty to read
2476 *
2477 * Returns a refcounted instance of the pid struct for the process
2478 * group controlling the tty.
2479 */
2480
2481struct pid *tty_get_pgrp(struct tty_struct *tty)
2482{
2483 unsigned long flags;
2484 struct pid *pgrp;
2485
2486 spin_lock_irqsave(&tty->ctrl_lock, flags);
2487 pgrp = get_pid(tty->pgrp);
2488 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2489
2490 return pgrp;
2491}
2492EXPORT_SYMBOL_GPL(tty_get_pgrp);
2493
Peter Hurleye1c22962014-10-16 14:59:48 -04002494/*
2495 * This checks not only the pgrp, but falls back on the pid if no
2496 * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
2497 * without this...
2498 *
2499 * The caller must hold rcu lock or the tasklist lock.
2500 */
2501static struct pid *session_of_pgrp(struct pid *pgrp)
2502{
2503 struct task_struct *p;
2504 struct pid *sid = NULL;
2505
2506 p = pid_task(pgrp, PIDTYPE_PGID);
2507 if (p == NULL)
2508 p = pid_task(pgrp, PIDTYPE_PID);
2509 if (p != NULL)
2510 sid = task_session(p);
2511
2512 return sid;
2513}
2514
Alan Cox5d0fdf12008-04-30 00:53:31 -07002515/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002516 * tiocgpgrp - get process group
2517 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002518 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002519 * @p: returned pid
2520 *
2521 * Obtain the process group of the tty. If there is no process group
2522 * return an error.
2523 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002524 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002525 */
2526
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2528{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002529 struct pid *pid;
2530 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 /*
2532 * (tty == real_tty) is a cheap way of
2533 * testing if the tty is NOT a master pty.
2534 */
2535 if (tty == real_tty && current->signal->tty != real_tty)
2536 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002537 pid = tty_get_pgrp(real_tty);
2538 ret = put_user(pid_vnr(pid), p);
2539 put_pid(pid);
2540 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541}
2542
Alan Coxaf9b8972006-08-27 01:24:01 -07002543/**
2544 * tiocspgrp - attempt to set process group
2545 * @tty: tty passed by user
2546 * @real_tty: tty side device matching tty passed by user
2547 * @p: pid pointer
2548 *
2549 * Set the process group of the tty to the session passed. Only
2550 * permitted where the tty session is our session.
2551 *
Alan Cox47f86832008-04-30 00:53:30 -07002552 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002553 */
2554
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2556{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002557 struct pid *pgrp;
2558 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002560 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561
2562 if (retval == -EIO)
2563 return -ENOTTY;
2564 if (retval)
2565 return retval;
2566 if (!current->signal->tty ||
2567 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002568 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002570 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002572 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002574 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002575 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002576 retval = -ESRCH;
2577 if (!pgrp)
2578 goto out_unlock;
2579 retval = -EPERM;
2580 if (session_of_pgrp(pgrp) != task_session(current))
2581 goto out_unlock;
2582 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002583 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002584 put_pid(real_tty->pgrp);
2585 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002586 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002587out_unlock:
2588 rcu_read_unlock();
2589 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590}
2591
Alan Coxaf9b8972006-08-27 01:24:01 -07002592/**
2593 * tiocgsid - get session id
2594 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002595 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002596 * @p: pointer to returned session id
2597 *
2598 * Obtain the session id of the tty. If there is no session
2599 * return an error.
2600 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002601 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002602 */
2603
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2605{
2606 /*
2607 * (tty == real_tty) is a cheap way of
2608 * testing if the tty is NOT a master pty.
2609 */
2610 if (tty == real_tty && current->signal->tty != real_tty)
2611 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002612 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002614 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615}
2616
Alan Coxaf9b8972006-08-27 01:24:01 -07002617/**
2618 * tiocsetd - set line discipline
2619 * @tty: tty device
2620 * @p: pointer to user data
2621 *
2622 * Set the line discipline according to user request.
2623 *
2624 * Locking: see tty_set_ldisc, this function is just a helper
2625 */
2626
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627static int tiocsetd(struct tty_struct *tty, int __user *p)
2628{
2629 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002630 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631
2632 if (get_user(ldisc, p))
2633 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002634
Alan Cox04f378b2008-04-30 00:53:29 -07002635 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002636
2637 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638}
2639
Alan Coxaf9b8972006-08-27 01:24:01 -07002640/**
2641 * send_break - performed time break
2642 * @tty: device to break on
2643 * @duration: timeout in mS
2644 *
2645 * Perform a timed break on hardware that lacks its own driver level
2646 * timed break functionality.
2647 *
2648 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002649 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002650 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002651 */
2652
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002653static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654{
Alan Cox9e989662008-07-22 11:18:03 +01002655 int retval;
2656
2657 if (tty->ops->break_ctl == NULL)
2658 return 0;
2659
2660 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2661 retval = tty->ops->break_ctl(tty, duration);
2662 else {
2663 /* Do the work ourselves */
2664 if (tty_write_lock(tty, 0) < 0)
2665 return -EINTR;
2666 retval = tty->ops->break_ctl(tty, -1);
2667 if (retval)
2668 goto out;
2669 if (!signal_pending(current))
2670 msleep_interruptible(duration);
2671 retval = tty->ops->break_ctl(tty, 0);
2672out:
2673 tty_write_unlock(tty);
2674 if (signal_pending(current))
2675 retval = -EINTR;
2676 }
2677 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678}
2679
Alan Coxaf9b8972006-08-27 01:24:01 -07002680/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002681 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002682 * @tty: tty device
2683 * @file: user file pointer
2684 * @p: pointer to result
2685 *
2686 * Obtain the modem status bits from the tty driver if the feature
2687 * is supported. Return -EINVAL if it is not available.
2688 *
2689 * Locking: none (up to the driver)
2690 */
2691
Alan Cox60b33c12011-02-14 16:26:14 +00002692static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693{
2694 int retval = -EINVAL;
2695
Alan Coxf34d7a52008-04-30 00:54:13 -07002696 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002697 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698
2699 if (retval >= 0)
2700 retval = put_user(retval, p);
2701 }
2702 return retval;
2703}
2704
Alan Coxaf9b8972006-08-27 01:24:01 -07002705/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002706 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002707 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002708 * @cmd: command - clear bits, set bits or set all
2709 * @p: pointer to desired bits
2710 *
2711 * Set the modem status bits from the tty driver if the feature
2712 * is supported. Return -EINVAL if it is not available.
2713 *
2714 * Locking: none (up to the driver)
2715 */
2716
Alan Cox20b9d172011-02-14 16:26:50 +00002717static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 unsigned __user *p)
2719{
Alan Coxae677512008-07-16 21:56:54 +01002720 int retval;
2721 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002722
Alan Coxae677512008-07-16 21:56:54 +01002723 if (tty->ops->tiocmset == NULL)
2724 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725
Alan Coxae677512008-07-16 21:56:54 +01002726 retval = get_user(val, p);
2727 if (retval)
2728 return retval;
2729 set = clear = 0;
2730 switch (cmd) {
2731 case TIOCMBIS:
2732 set = val;
2733 break;
2734 case TIOCMBIC:
2735 clear = val;
2736 break;
2737 case TIOCMSET:
2738 set = val;
2739 clear = ~val;
2740 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741 }
Alan Coxae677512008-07-16 21:56:54 +01002742 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2743 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002744 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745}
2746
Alan Coxd281da72010-09-16 18:21:24 +01002747static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2748{
2749 int retval = -EINVAL;
2750 struct serial_icounter_struct icount;
2751 memset(&icount, 0, sizeof(icount));
2752 if (tty->ops->get_icount)
2753 retval = tty->ops->get_icount(tty, &icount);
2754 if (retval != 0)
2755 return retval;
2756 if (copy_to_user(arg, &icount, sizeof(icount)))
2757 return -EFAULT;
2758 return 0;
2759}
2760
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002761static void tty_warn_deprecated_flags(struct serial_struct __user *ss)
2762{
2763 static DEFINE_RATELIMIT_STATE(depr_flags,
2764 DEFAULT_RATELIMIT_INTERVAL,
2765 DEFAULT_RATELIMIT_BURST);
2766 char comm[TASK_COMM_LEN];
2767 int flags;
2768
2769 if (get_user(flags, &ss->flags))
2770 return;
2771
2772 flags &= ASYNC_DEPRECATED;
2773
2774 if (flags && __ratelimit(&depr_flags))
2775 pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2776 __func__, get_task_comm(comm, current), flags);
2777}
2778
Peter Hurley8f166e02014-10-16 14:59:41 -04002779/*
2780 * if pty, return the slave side (real_tty)
2781 * otherwise, return self
2782 */
2783static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
Alan Coxe8b70e72009-06-11 12:48:02 +01002784{
2785 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2786 tty->driver->subtype == PTY_TYPE_MASTER)
2787 tty = tty->link;
2788 return tty;
2789}
Alan Coxe8b70e72009-06-11 12:48:02 +01002790
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791/*
2792 * Split this up, as gcc can choke on it otherwise..
2793 */
Alan Cox04f378b2008-04-30 00:53:29 -07002794long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795{
Nick Piggind996b622010-08-18 04:37:36 +10002796 struct tty_struct *tty = file_tty(file);
2797 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 void __user *p = (void __user *)arg;
2799 int retval;
2800 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002801
Al Viro6131ffa2013-02-27 16:59:05 -05002802 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803 return -EINVAL;
2804
Alan Coxe8b70e72009-06-11 12:48:02 +01002805 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806
2807 /*
2808 * Factor out some common prep work
2809 */
2810 switch (cmd) {
2811 case TIOCSETD:
2812 case TIOCSBRK:
2813 case TIOCCBRK:
2814 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002815 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816 retval = tty_check_change(tty);
2817 if (retval)
2818 return retval;
2819 if (cmd != TIOCCBRK) {
2820 tty_wait_until_sent(tty, 0);
2821 if (signal_pending(current))
2822 return -EINTR;
2823 }
2824 break;
2825 }
2826
Alan Cox9e989662008-07-22 11:18:03 +01002827 /*
2828 * Now do the stuff.
2829 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002831 case TIOCSTI:
2832 return tiocsti(tty, p);
2833 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002834 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002835 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002836 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002837 case TIOCCONS:
2838 return real_tty != tty ? -EINVAL : tioccons(file);
2839 case FIONBIO:
2840 return fionbio(file, p);
2841 case TIOCEXCL:
2842 set_bit(TTY_EXCLUSIVE, &tty->flags);
2843 return 0;
2844 case TIOCNXCL:
2845 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2846 return 0;
Cyrill Gorcunov84fd7bd2012-10-24 23:43:22 +04002847 case TIOCGEXCL:
2848 {
2849 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2850 return put_user(excl, (int __user *)p);
2851 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002852 case TIOCNOTTY:
2853 if (current->signal->tty != tty)
2854 return -ENOTTY;
2855 no_tty();
2856 return 0;
2857 case TIOCSCTTY:
2858 return tiocsctty(tty, arg);
2859 case TIOCGPGRP:
2860 return tiocgpgrp(tty, real_tty, p);
2861 case TIOCSPGRP:
2862 return tiocspgrp(tty, real_tty, p);
2863 case TIOCGSID:
2864 return tiocgsid(tty, real_tty, p);
2865 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002866 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002867 case TIOCSETD:
2868 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002869 case TIOCVHANGUP:
2870 if (!capable(CAP_SYS_ADMIN))
2871 return -EPERM;
2872 tty_vhangup(tty);
2873 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002874 case TIOCGDEV:
2875 {
2876 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2877 return put_user(ret, (unsigned int __user *)p);
2878 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002879 /*
2880 * Break handling
2881 */
2882 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002883 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002884 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002885 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002886 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002887 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002888 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002889 return 0;
2890 case TCSBRK: /* SVID version: non-zero arg --> no break */
2891 /* non-zero arg means wait for all output data
2892 * to be sent (performed above) but don't send break.
2893 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002895 if (!arg)
2896 return send_break(tty, 250);
2897 return 0;
2898 case TCSBRKP: /* support for POSIX tcsendbreak() */
2899 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900
Alan Cox37bdfb02008-02-08 04:18:47 -08002901 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002902 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002903 case TIOCMSET:
2904 case TIOCMBIC:
2905 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002906 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002907 case TIOCGICOUNT:
2908 retval = tty_tiocgicount(tty, p);
2909 /* For the moment allow fall through to the old method */
2910 if (retval != -EINVAL)
2911 return retval;
2912 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002913 case TCFLSH:
2914 switch (arg) {
2915 case TCIFLUSH:
2916 case TCIOFLUSH:
2917 /* flush tty buffer and allow ldisc to process ioctl */
Peter Hurley86c80a82014-11-05 12:13:09 -05002918 tty_buffer_flush(tty, NULL);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002919 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002920 }
2921 break;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002922 case TIOCSSERIAL:
2923 tty_warn_deprecated_flags(p);
2924 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002926 if (tty->ops->ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002927 retval = tty->ops->ioctl(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928 if (retval != -ENOIOCTLCMD)
2929 return retval;
2930 }
2931 ld = tty_ldisc_ref_wait(tty);
2932 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002933 if (ld->ops->ioctl) {
2934 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935 if (retval == -ENOIOCTLCMD)
Wanlong Gaobbb63c52012-08-27 15:23:12 +08002936 retval = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 }
2938 tty_ldisc_deref(ld);
2939 return retval;
2940}
2941
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002942#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002943static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002944 unsigned long arg)
2945{
Nick Piggind996b622010-08-18 04:37:36 +10002946 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002947 struct tty_ldisc *ld;
2948 int retval = -ENOIOCTLCMD;
2949
Al Viro6131ffa2013-02-27 16:59:05 -05002950 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002951 return -EINVAL;
2952
Alan Coxf34d7a52008-04-30 00:54:13 -07002953 if (tty->ops->compat_ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002954 retval = tty->ops->compat_ioctl(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002955 if (retval != -ENOIOCTLCMD)
2956 return retval;
2957 }
2958
2959 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002960 if (ld->ops->compat_ioctl)
2961 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Thomas Meyer8193c422011-10-05 23:13:13 +02002962 else
2963 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002964 tty_ldisc_deref(ld);
2965
2966 return retval;
2967}
2968#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969
Al Viroc3c073f2012-08-21 22:32:06 -04002970static int this_tty(const void *t, struct file *file, unsigned fd)
2971{
2972 if (likely(file->f_op->read != tty_read))
2973 return 0;
2974 return file_tty(file) != t ? 0 : fd + 1;
2975}
2976
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977/*
2978 * This implements the "Secure Attention Key" --- the idea is to
2979 * prevent trojan horses by killing all processes associated with this
2980 * tty when the user hits the "Secure Attention Key". Required for
2981 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002982 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 * This code could be nicer; ideally it should send a HUP, wait a few
2984 * seconds, then send a INT, and then a KILL signal. But you then
2985 * have to coordinate with the init process, since all processes associated
2986 * with the current tty must be dead before the new getty is allowed
2987 * to spawn.
2988 *
2989 * Now, if it would be correct ;-/ The current code has a nasty hole -
2990 * it doesn't catch files in flight. We may send the descriptor to ourselves
2991 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2992 *
2993 * Nasty bug: do_SAK is being called in interrupt context. This can
2994 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2995 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002996void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997{
2998#ifdef TTY_SOFT_SAK
2999 tty_hangup(tty);
3000#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08003001 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003002 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -08003004
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 if (!tty)
3006 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003007 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08003008
Dan Carpenterb3f13de2006-12-13 00:35:09 -08003009 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010
Alan Coxf34d7a52008-04-30 00:54:13 -07003011 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08003012
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003014 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003015 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08003016 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07003017 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07003018 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003019 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003020 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003021 /* Now kill any processes that happen to have the
3022 * tty open.
3023 */
3024 do_each_thread(g, p) {
3025 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07003027 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07003028 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029 send_sig(SIGKILL, p, 1);
3030 continue;
3031 }
3032 task_lock(p);
Al Viroc3c073f2012-08-21 22:32:06 -04003033 i = iterate_fd(p->files, 0, this_tty, tty);
3034 if (i != 0) {
3035 printk(KERN_NOTICE "SAK: killed process %d"
3036 " (%s): fd#%d opened to the tty\n",
3037 task_pid_nr(p), p->comm, i - 1);
3038 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 }
3040 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003041 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042 read_unlock(&tasklist_lock);
3043#endif
3044}
3045
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08003046static void do_SAK_work(struct work_struct *work)
3047{
3048 struct tty_struct *tty =
3049 container_of(work, struct tty_struct, SAK_work);
3050 __do_SAK(tty);
3051}
3052
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053/*
3054 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3055 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3056 * the values which we write to it will be identical to the values which it
3057 * already has. --akpm
3058 */
3059void do_SAK(struct tty_struct *tty)
3060{
3061 if (!tty)
3062 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 schedule_work(&tty->SAK_work);
3064}
3065
3066EXPORT_SYMBOL(do_SAK);
3067
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08003068static int dev_match_devt(struct device *dev, const void *data)
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003069{
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08003070 const dev_t *devt = data;
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003071 return dev->devt == *devt;
3072}
3073
3074/* Must put_device() after it's unused! */
3075static struct device *tty_get_device(struct tty_struct *tty)
3076{
3077 dev_t devt = tty_devnum(tty);
3078 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
3079}
3080
3081
Alan Coxaf9b8972006-08-27 01:24:01 -07003082/**
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003083 * alloc_tty_struct
Alan Coxaf9b8972006-08-27 01:24:01 -07003084 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003085 * This subroutine allocates and initializes a tty structure.
Alan Coxaf9b8972006-08-27 01:24:01 -07003086 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003087 * Locking: none - tty in question is not exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07003088 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003089
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003090struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003091{
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003092 struct tty_struct *tty;
3093
3094 tty = kzalloc(sizeof(*tty), GFP_KERNEL);
3095 if (!tty)
3096 return NULL;
3097
Alan Cox9c9f4de2008-10-13 10:37:26 +01003098 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01003100 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003101 tty->session = NULL;
3102 tty->pgrp = NULL;
Alan Cox89c8d912012-08-08 16:30:13 +01003103 mutex_init(&tty->legacy_mutex);
Peter Hurleyd8c1f922013-06-15 09:14:31 -04003104 mutex_init(&tty->throttle_mutex);
Peter Hurley6a1c0682013-06-15 09:14:23 -04003105 init_rwsem(&tty->termios_rwsem);
Peter Hurleydee4a0b2013-07-24 16:43:51 -04003106 mutex_init(&tty->winsize_mutex);
Peter Hurley36697522013-06-15 07:04:48 -04003107 init_ldsem(&tty->ldisc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 init_waitqueue_head(&tty->write_wait);
3109 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00003110 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08003111 mutex_init(&tty->atomic_write_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07003112 spin_lock_init(&tty->ctrl_lock);
Peter Hurleyf9e053d2014-09-10 15:06:31 -04003113 spin_lock_init(&tty->flow_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07003115 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01003116
3117 tty->driver = driver;
3118 tty->ops = driver->ops;
3119 tty->index = idx;
3120 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003121 tty->dev = tty_get_device(tty);
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003122
3123 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124}
3125
Alan Coxf34d7a52008-04-30 00:54:13 -07003126/**
Jiri Slaby67166712011-03-23 10:48:35 +01003127 * deinitialize_tty_struct
3128 * @tty: tty to deinitialize
3129 *
3130 * This subroutine deinitializes a tty structure that has been newly
3131 * allocated but tty_release cannot be called on that yet.
3132 *
3133 * Locking: none - tty in question must not be exposed at this point
3134 */
3135void deinitialize_tty_struct(struct tty_struct *tty)
3136{
3137 tty_ldisc_deinit(tty);
3138}
3139
3140/**
Alan Coxf34d7a52008-04-30 00:54:13 -07003141 * tty_put_char - write one character to a tty
3142 * @tty: tty
3143 * @ch: character
3144 *
3145 * Write one byte to the tty using the provided put_char method
3146 * if present. Returns the number of characters successfully output.
3147 *
3148 * Note: the specific put_char operation in the driver layer may go
3149 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003151
Alan Coxf34d7a52008-04-30 00:54:13 -07003152int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153{
Alan Coxf34d7a52008-04-30 00:54:13 -07003154 if (tty->ops->put_char)
3155 return tty->ops->put_char(tty, ch);
3156 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157}
Alan Coxf34d7a52008-04-30 00:54:13 -07003158EXPORT_SYMBOL_GPL(tty_put_char);
3159
Alan Coxd81ed102008-10-13 10:41:42 +01003160struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003162static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3163 unsigned int index, unsigned int count)
3164{
3165 /* init here, since reused cdevs cause crashes */
3166 cdev_init(&driver->cdevs[index], &tty_fops);
3167 driver->cdevs[index].owner = driver->owner;
3168 return cdev_add(&driver->cdevs[index], dev, count);
3169}
3170
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003172 * tty_register_device - register a tty device
3173 * @driver: the tty driver that describes the tty device
3174 * @index: the index in the tty driver for this tty device
3175 * @device: a struct device that is associated with this tty device.
3176 * This field is optional, if there is no known struct device
3177 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003179 * Returns a pointer to the struct device for this tty device
3180 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003181 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003182 * This call is required to be made to register an individual tty device
3183 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3184 * that bit is not set, this function should not be called by a tty
3185 * driver.
3186 *
3187 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003188 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003189
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003190struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3191 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003192{
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003193 return tty_register_device_attr(driver, index, device, NULL, NULL);
3194}
3195EXPORT_SYMBOL(tty_register_device);
3196
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003197static void tty_device_create_release(struct device *dev)
3198{
3199 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3200 kfree(dev);
3201}
3202
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003203/**
3204 * tty_register_device_attr - register a tty device
3205 * @driver: the tty driver that describes the tty device
3206 * @index: the index in the tty driver for this tty device
3207 * @device: a struct device that is associated with this tty device.
3208 * This field is optional, if there is no known struct device
3209 * for this tty device it can be set to NULL safely.
3210 * @drvdata: Driver data to be set to device.
3211 * @attr_grp: Attribute group to be set on device.
3212 *
3213 * Returns a pointer to the struct device for this tty device
3214 * (or ERR_PTR(-EFOO) on error).
3215 *
3216 * This call is required to be made to register an individual tty device
3217 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3218 * that bit is not set, this function should not be called by a tty
3219 * driver.
3220 *
3221 * Locking: ??
3222 */
3223struct device *tty_register_device_attr(struct tty_driver *driver,
3224 unsigned index, struct device *device,
3225 void *drvdata,
3226 const struct attribute_group **attr_grp)
3227{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228 char name[64];
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003229 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3230 struct device *dev = NULL;
3231 int retval = -ENODEV;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003232 bool cdev = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233
3234 if (index >= driver->num) {
3235 printk(KERN_ERR "Attempt to register invalid tty line number "
3236 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003237 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238 }
3239
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 if (driver->type == TTY_DRIVER_TYPE_PTY)
3241 pty_line_name(driver, index, name);
3242 else
3243 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003244
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003245 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003246 retval = tty_cdev_add(driver, devt, index, 1);
3247 if (retval)
3248 goto error;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003249 cdev = true;
3250 }
3251
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003252 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3253 if (!dev) {
3254 retval = -ENOMEM;
3255 goto error;
3256 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003257
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003258 dev->devt = devt;
3259 dev->class = tty_class;
3260 dev->parent = device;
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003261 dev->release = tty_device_create_release;
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003262 dev_set_name(dev, "%s", name);
3263 dev->groups = attr_grp;
3264 dev_set_drvdata(dev, drvdata);
3265
3266 retval = device_register(dev);
3267 if (retval)
3268 goto error;
3269
3270 return dev;
3271
3272error:
3273 put_device(dev);
3274 if (cdev)
3275 cdev_del(&driver->cdevs[index]);
3276 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003277}
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003278EXPORT_SYMBOL_GPL(tty_register_device_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279
3280/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003281 * tty_unregister_device - unregister a tty device
3282 * @driver: the tty driver that describes the tty device
3283 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003285 * If a tty device is registered with a call to tty_register_device() then
3286 * this function must be called when the tty device is gone.
3287 *
3288 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003290
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291void tty_unregister_device(struct tty_driver *driver, unsigned index)
3292{
Alan Cox37bdfb02008-02-08 04:18:47 -08003293 device_destroy(tty_class,
3294 MKDEV(driver->major, driver->minor_start) + index);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003295 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
3296 cdev_del(&driver->cdevs[index]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003297}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298EXPORT_SYMBOL(tty_unregister_device);
3299
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003300/**
3301 * __tty_alloc_driver -- allocate tty driver
3302 * @lines: count of lines this driver can handle at most
3303 * @owner: module which is repsonsible for this driver
3304 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3305 *
3306 * This should not be called directly, some of the provided macros should be
3307 * used instead. Use IS_ERR and friends on @retval.
3308 */
3309struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3310 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311{
3312 struct tty_driver *driver;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003313 unsigned int cdevs = 1;
Jiri Slaby16a02082012-08-08 22:26:42 +02003314 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315
Jiri Slaby0019b402012-08-08 22:26:43 +02003316 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003317 return ERR_PTR(-EINVAL);
3318
Jean Delvare506eb992007-07-15 23:40:14 -07003319 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003320 if (!driver)
3321 return ERR_PTR(-ENOMEM);
3322
3323 kref_init(&driver->kref);
3324 driver->magic = TTY_DRIVER_MAGIC;
3325 driver->num = lines;
3326 driver->owner = owner;
3327 driver->flags = flags;
Jiri Slaby16a02082012-08-08 22:26:42 +02003328
3329 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3330 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3331 GFP_KERNEL);
3332 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3333 GFP_KERNEL);
3334 if (!driver->ttys || !driver->termios) {
3335 err = -ENOMEM;
3336 goto err_free_all;
3337 }
3338 }
3339
3340 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3341 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3342 GFP_KERNEL);
3343 if (!driver->ports) {
3344 err = -ENOMEM;
3345 goto err_free_all;
3346 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003347 cdevs = lines;
3348 }
3349
3350 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3351 if (!driver->cdevs) {
3352 err = -ENOMEM;
3353 goto err_free_all;
Jiri Slaby16a02082012-08-08 22:26:42 +02003354 }
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003355
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356 return driver;
Jiri Slaby16a02082012-08-08 22:26:42 +02003357err_free_all:
3358 kfree(driver->ports);
3359 kfree(driver->ttys);
3360 kfree(driver->termios);
3361 kfree(driver);
3362 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003363}
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003364EXPORT_SYMBOL(__tty_alloc_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003365
Alan Cox7d7b93c2008-10-13 10:42:09 +01003366static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003367{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003368 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3369 int i;
3370 struct ktermios *tp;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003371
3372 if (driver->flags & TTY_DRIVER_INSTALLED) {
3373 /*
3374 * Free the termios and termios_locked structures because
3375 * we don't want to get memory leaks when modular tty
3376 * drivers are removed from the kernel.
3377 */
3378 for (i = 0; i < driver->num; i++) {
3379 tp = driver->termios[i];
3380 if (tp) {
3381 driver->termios[i] = NULL;
3382 kfree(tp);
3383 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003384 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3385 tty_unregister_device(driver, i);
3386 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003387 proc_tty_unregister_driver(driver);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003388 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3389 cdev_del(&driver->cdevs[0]);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003390 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003391 kfree(driver->cdevs);
Jiri Slaby04831dc2012-06-04 13:35:36 +02003392 kfree(driver->ports);
Jiri Slaby16a02082012-08-08 22:26:42 +02003393 kfree(driver->termios);
3394 kfree(driver->ttys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 kfree(driver);
3396}
3397
Alan Cox7d7b93c2008-10-13 10:42:09 +01003398void tty_driver_kref_put(struct tty_driver *driver)
3399{
3400 kref_put(&driver->kref, destruct_tty_driver);
3401}
3402EXPORT_SYMBOL(tty_driver_kref_put);
3403
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003404void tty_set_operations(struct tty_driver *driver,
3405 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406{
Alan Coxf34d7a52008-04-30 00:54:13 -07003407 driver->ops = op;
3408};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409EXPORT_SYMBOL(tty_set_operations);
3410
Alan Cox7d7b93c2008-10-13 10:42:09 +01003411void put_tty_driver(struct tty_driver *d)
3412{
3413 tty_driver_kref_put(d);
3414}
3415EXPORT_SYMBOL(put_tty_driver);
3416
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417/*
3418 * Called by a tty driver to register itself.
3419 */
3420int tty_register_driver(struct tty_driver *driver)
3421{
3422 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003423 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424 dev_t dev;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003425 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003428 error = alloc_chrdev_region(&dev, driver->minor_start,
3429 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430 if (!error) {
3431 driver->major = MAJOR(dev);
3432 driver->minor_start = MINOR(dev);
3433 }
3434 } else {
3435 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003436 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437 }
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003438 if (error < 0)
Jiri Slaby16a02082012-08-08 22:26:42 +02003439 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003441 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3442 error = tty_cdev_add(driver, dev, 0, driver->num);
3443 if (error)
3444 goto err_unreg_char;
3445 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003447 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003449 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003450
3451 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003452 for (i = 0; i < driver->num; i++) {
3453 d = tty_register_device(driver, i, NULL);
3454 if (IS_ERR(d)) {
3455 error = PTR_ERR(d);
Jiri Slaby16a02082012-08-08 22:26:42 +02003456 goto err_unreg_devs;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003457 }
3458 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 }
3460 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003461 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003463
Jiri Slaby16a02082012-08-08 22:26:42 +02003464err_unreg_devs:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003465 for (i--; i >= 0; i--)
3466 tty_unregister_device(driver, i);
3467
3468 mutex_lock(&tty_mutex);
3469 list_del(&driver->tty_drivers);
3470 mutex_unlock(&tty_mutex);
3471
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003472err_unreg_char:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003473 unregister_chrdev_region(dev, driver->num);
Jiri Slaby16a02082012-08-08 22:26:42 +02003474err:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003475 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003476}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477EXPORT_SYMBOL(tty_register_driver);
3478
3479/*
3480 * Called by a tty driver to unregister itself.
3481 */
3482int tty_unregister_driver(struct tty_driver *driver)
3483{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003484#if 0
3485 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003486 if (driver->refcount)
3487 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003488#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3490 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003491 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003492 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003493 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494 return 0;
3495}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003496
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497EXPORT_SYMBOL(tty_unregister_driver);
3498
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003499dev_t tty_devnum(struct tty_struct *tty)
3500{
3501 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3502}
3503EXPORT_SYMBOL(tty_devnum);
3504
Alan Coxd81ed102008-10-13 10:41:42 +01003505void tty_default_fops(struct file_operations *fops)
3506{
3507 *fops = tty_fops;
3508}
3509
Linus Torvalds1da177e2005-04-16 15:20:36 -07003510/*
3511 * Initialize the console device. This is called *early*, so
3512 * we can't necessarily depend on lots of kernel help here.
3513 * Just do some early initializations, and do the complex setup
3514 * later.
3515 */
3516void __init console_init(void)
3517{
3518 initcall_t *call;
3519
3520 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003521 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522
3523 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003524 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525 * inform about problems etc..
3526 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 call = __con_initcall_start;
3528 while (call < __con_initcall_end) {
3529 (*call)();
3530 call++;
3531 }
3532}
3533
Al Viro2c9ede52011-07-23 20:24:48 -04003534static char *tty_devnode(struct device *dev, umode_t *mode)
Kay Sieverse454cea2009-09-18 23:01:12 +02003535{
3536 if (!mode)
3537 return NULL;
3538 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3539 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3540 *mode = 0666;
3541 return NULL;
3542}
3543
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544static int __init tty_class_init(void)
3545{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003546 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003547 if (IS_ERR(tty_class))
3548 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003549 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003550 return 0;
3551}
3552
3553postcore_initcall(tty_class_init);
3554
3555/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003556static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003557
Kay Sieversfbc92a32010-12-01 18:51:05 +01003558static ssize_t show_cons_active(struct device *dev,
3559 struct device_attribute *attr, char *buf)
3560{
3561 struct console *cs[16];
3562 int i = 0;
3563 struct console *c;
3564 ssize_t count = 0;
3565
Torben Hohnac751ef2011-01-25 15:07:35 -08003566 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003567 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003568 if (!c->device)
3569 continue;
3570 if (!c->write)
3571 continue;
3572 if ((c->flags & CON_ENABLED) == 0)
3573 continue;
3574 cs[i++] = c;
3575 if (i >= ARRAY_SIZE(cs))
3576 break;
3577 }
Hannes Reinecke723abd82014-02-27 12:30:51 +01003578 while (i--) {
3579 int index = cs[i]->index;
3580 struct tty_driver *drv = cs[i]->device(cs[i], &index);
3581
3582 /* don't resolve tty0 as some programs depend on it */
3583 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
3584 count += tty_line_name(drv, index, buf + count);
3585 else
3586 count += sprintf(buf + count, "%s%d",
3587 cs[i]->name, cs[i]->index);
3588
3589 count += sprintf(buf + count, "%c", i ? ' ':'\n');
3590 }
Torben Hohnac751ef2011-01-25 15:07:35 -08003591 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003592
3593 return count;
3594}
3595static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3596
3597static struct device *consdev;
3598
3599void console_sysfs_notify(void)
3600{
3601 if (consdev)
3602 sysfs_notify(&consdev->kobj, NULL, "active");
3603}
3604
Linus Torvalds1da177e2005-04-16 15:20:36 -07003605/*
3606 * Ok, now we can initialize the rest of the tty devices and can count
3607 * on memory allocations, interrupts etc..
3608 */
David Howells31d1d482010-08-06 16:34:43 +01003609int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610{
3611 cdev_init(&tty_cdev, &tty_fops);
3612 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3613 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3614 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003615 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003616
3617 cdev_init(&console_cdev, &console_fops);
3618 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3619 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3620 panic("Couldn't register /dev/console driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003621 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003622 "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003623 if (IS_ERR(consdev))
3624 consdev = NULL;
3625 else
Kay Sieversa2a6a822011-01-09 16:39:14 +01003626 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003629 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630#endif
3631 return 0;
3632}
David Howells31d1d482010-08-06 16:34:43 +01003633