blob: 734a635e73632910d3d418a1eb980b3430a0b8b5 [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
Peter Hurleyaccff792015-07-12 22:49:09 -0400109#ifdef TTY_DEBUG_HANGUP
110# define tty_debug_hangup(tty, f, args...) tty_debug(tty, f, ##args)
111#else
112# define tty_debug_hangup(tty, f, args...) do { } while (0)
113#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
115#define TTY_PARANOIA_CHECK 1
116#define CHECK_TTY_COUNT 1
117
Alan Coxedc6afc2006-12-08 02:38:44 -0800118struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 .c_iflag = ICRNL | IXON,
120 .c_oflag = OPOST | ONLCR,
121 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
122 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
123 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800124 .c_cc = INIT_C_CC,
125 .c_ispeed = 38400,
Peter Hurley133b1302016-01-10 22:41:07 -0800126 .c_ospeed = 38400,
127 /* .c_line = N_TTY, */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128};
129
130EXPORT_SYMBOL(tty_std_termios);
131
132/* This list gets poked at by procfs and various bits of boot up code. This
133 could do with some rationalisation such as pulling the tty proc function
134 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136LIST_HEAD(tty_drivers); /* linked list of tty drivers */
137
Peter Hurleyd1d027e2016-01-09 21:35:18 -0800138/* Mutex to protect creating and releasing a tty */
Ingo Molnar70522e12006-03-23 03:00:31 -0800139DEFINE_MUTEX(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
142static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800143ssize_t redirected_tty_write(struct file *, const char __user *,
144 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145static unsigned int tty_poll(struct file *, poll_table *);
146static int tty_open(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700147long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700148#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800149static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700150 unsigned long arg);
151#else
152#define tty_compat_ioctl NULL
153#endif
Arnd Bergmannec79d602010-06-01 22:53:01 +0200154static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800155static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800156static void release_tty(struct tty_struct *tty, int idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Alan Coxaf9b8972006-08-27 01:24:01 -0700158/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700159 * free_tty_struct - free a disused tty
160 * @tty: tty struct to free
161 *
162 * Free the write buffers, tty queue and tty memory itself.
163 *
164 * Locking: none. Must be called after tty is definitely unused
165 */
166
Peter Hurleya3123fd2016-01-09 21:13:48 -0800167static void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Peter Hurleyc8b710b2016-01-09 21:13:46 -0800169 tty_ldisc_deinit(tty);
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
Peter Hurley4a510962016-01-09 21:35:23 -0800202 spin_lock(&tty->files_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000203 list_add(&priv->list, &tty->tty_files);
Peter Hurley4a510962016-01-09 21:35:23 -0800204 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;
Peter Hurley4a510962016-01-09 21:35:23 -0800225 struct tty_struct *tty = priv->tty;
Nick Piggind996b622010-08-18 04:37:36 +1000226
Peter Hurley4a510962016-01-09 21:35:23 -0800227 spin_lock(&tty->files_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000228 list_del(&priv->list);
Peter Hurley4a510962016-01-09 21:35:23 -0800229 spin_unlock(&tty->files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200230 tty_free_file(file);
Nick Piggind996b622010-08-18 04:37:36 +1000231}
232
Alan Coxaf9b8972006-08-27 01:24:01 -0700233/**
234 * tty_name - return tty naming
235 * @tty: tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -0700236 *
237 * Convert a tty structure into a name. The name reflects the kernel
238 * naming policy and if udev is in use may not reflect user space
239 *
240 * Locking: none
241 */
242
Rasmus Villemoes429b4742015-03-31 15:55:59 +0200243const char *tty_name(const struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
245 if (!tty) /* Hmm. NULL pointer. That's fun. */
Rasmus Villemoes917162c2015-03-31 15:55:58 +0200246 return "NULL tty";
247 return tty->name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248}
249
250EXPORT_SYMBOL(tty_name);
251
Peter Hurley0a083ed2015-11-08 13:01:12 -0500252const char *tty_driver_name(const struct tty_struct *tty)
253{
254 if (!tty || !tty->driver)
255 return "";
256 return tty->driver->name;
257}
258
Peter Hurley82b8f882015-11-08 13:01:09 -0500259static int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 const char *routine)
261{
262#ifdef TTY_PARANOIA_CHECK
263 if (!tty) {
Peter Hurley89222e62015-11-08 13:01:18 -0500264 pr_warn("(%d:%d): %s: NULL tty\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 imajor(inode), iminor(inode), routine);
266 return 1;
267 }
268 if (tty->magic != TTY_MAGIC) {
Peter Hurley89222e62015-11-08 13:01:18 -0500269 pr_warn("(%d:%d): %s: bad magic number\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 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
Peter Hurley4a510962016-01-09 21:35:23 -0800284 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 list_for_each(p, &tty->tty_files) {
286 count++;
287 }
Peter Hurley4a510962016-01-09 21:35:23 -0800288 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) {
Peter Hurley339f36b2015-11-08 13:01:13 -0500294 tty_warn(tty, "%s: tty->count(%d) != #fd's(%d)\n",
295 routine, tty->count, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800297 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298#endif
299 return 0;
300}
301
Alan Coxaf9b8972006-08-27 01:24:01 -0700302/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700303 * get_tty_driver - find device of a tty
304 * @dev_t: device identifier
305 * @index: returns the index of the tty
306 *
307 * This routine returns a tty driver structure, given a device number
308 * and also passes back the index number.
309 *
310 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313static struct tty_driver *get_tty_driver(dev_t device, int *index)
314{
315 struct tty_driver *p;
316
317 list_for_each_entry(p, &tty_drivers, tty_drivers) {
318 dev_t base = MKDEV(p->major, p->minor_start);
319 if (device < base || device >= base + p->num)
320 continue;
321 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100322 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 }
324 return NULL;
325}
326
Jason Wesself2d937f2008-04-17 20:05:37 +0200327#ifdef CONFIG_CONSOLE_POLL
328
329/**
330 * tty_find_polling_driver - find device of a polled tty
331 * @name: name string to match
332 * @line: pointer to resulting tty line nr
333 *
334 * This routine returns a tty driver structure, given a name
335 * and the condition that the tty driver is capable of polled
336 * operation.
337 */
338struct tty_driver *tty_find_polling_driver(char *name, int *line)
339{
340 struct tty_driver *p, *res = NULL;
341 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500342 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100343 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200344
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500345 for (str = name; *str; str++)
346 if ((*str >= '0' && *str <= '9') || *str == ',')
347 break;
348 if (!*str)
349 return NULL;
350
351 len = str - name;
352 tty_line = simple_strtoul(str, &str, 10);
353
Jason Wesself2d937f2008-04-17 20:05:37 +0200354 mutex_lock(&tty_mutex);
355 /* Search through the tty devices to look for a match */
356 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500357 if (strncmp(name, p->name, len) != 0)
358 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100359 stp = str;
360 if (*stp == ',')
361 stp++;
362 if (*stp == '\0')
363 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200364
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200365 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100366 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100367 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200368 *line = tty_line;
369 break;
370 }
371 }
372 mutex_unlock(&tty_mutex);
373
374 return res;
375}
376EXPORT_SYMBOL_GPL(tty_find_polling_driver);
377#endif
378
Peter Hurleye802ca02016-01-09 21:35:21 -0800379static int is_ignored(int sig)
380{
381 return (sigismember(&current->blocked, sig) ||
382 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
383}
384
Alan Coxaf9b8972006-08-27 01:24:01 -0700385/**
386 * tty_check_change - check for POSIX terminal changes
387 * @tty: tty to check
388 *
389 * If we try to write to, or set the state of, a terminal and we're
390 * not in the foreground, send a SIGTTOU. If the signal is blocked or
391 * ignored, go ahead and perform the operation. (POSIX 7.2)
392 *
Alan Cox978e5952008-04-30 00:53:59 -0700393 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700395
Peter Hurley2812d9e2015-10-10 20:28:42 -0400396int __tty_check_change(struct tty_struct *tty, int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397{
Alan Cox47f86832008-04-30 00:53:30 -0700398 unsigned long flags;
Peter Hurley2812d9e2015-10-10 20:28:42 -0400399 struct pid *pgrp, *tty_pgrp;
Alan Cox47f86832008-04-30 00:53:30 -0700400 int ret = 0;
401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 if (current->signal->tty != tty)
403 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700404
Patrick Donnelly67196932015-07-12 18:51:52 -0400405 rcu_read_lock();
406 pgrp = task_pgrp(current);
407
Alan Cox47f86832008-04-30 00:53:30 -0700408 spin_lock_irqsave(&tty->ctrl_lock, flags);
Peter Hurley2812d9e2015-10-10 20:28:42 -0400409 tty_pgrp = tty->pgrp;
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700410 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Patrick Donnelly67196932015-07-12 18:51:52 -0400411
Peter Hurley2812d9e2015-10-10 20:28:42 -0400412 if (tty_pgrp && pgrp != tty->pgrp) {
413 if (is_ignored(sig)) {
414 if (sig == SIGTTIN)
415 ret = -EIO;
416 } else if (is_current_pgrp_orphaned())
417 ret = -EIO;
418 else {
419 kill_pgrp(pgrp, sig, 1);
420 set_thread_flag(TIF_SIGPENDING);
421 ret = -ERESTARTSYS;
422 }
Alan Cox47f86832008-04-30 00:53:30 -0700423 }
Patrick Donnelly67196932015-07-12 18:51:52 -0400424 rcu_read_unlock();
Peter Hurley2812d9e2015-10-10 20:28:42 -0400425
Peter Hurley339f36b2015-11-08 13:01:13 -0500426 if (!tty_pgrp)
427 tty_warn(tty, "sig=%d, tty->pgrp == NULL!\n", sig);
Peter Hurley2812d9e2015-10-10 20:28:42 -0400428
Alan Cox47f86832008-04-30 00:53:30 -0700429 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430}
431
Peter Hurley2812d9e2015-10-10 20:28:42 -0400432int tty_check_change(struct tty_struct *tty)
433{
434 return __tty_check_change(tty, SIGTTOU);
435}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436EXPORT_SYMBOL(tty_check_change);
437
Alan Cox37bdfb02008-02-08 04:18:47 -0800438static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 size_t count, loff_t *ppos)
440{
441 return 0;
442}
443
Alan Cox37bdfb02008-02-08 04:18:47 -0800444static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 size_t count, loff_t *ppos)
446{
447 return -EIO;
448}
449
450/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800451static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
453 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
454}
455
Alan Cox04f378b2008-04-30 00:53:29 -0700456static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
457 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700458{
459 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
460}
461
Alan Cox37bdfb02008-02-08 04:18:47 -0800462static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700463 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464{
465 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
466}
467
Peter Hurleyf5574742016-01-09 21:45:10 -0800468static int hung_up_tty_fasync(int fd, struct file *file, int on)
469{
470 return -ENOTTY;
471}
472
Arjan van de Ven62322d22006-07-03 00:24:21 -0700473static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 .llseek = no_llseek,
475 .read = tty_read,
476 .write = tty_write,
477 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700478 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700479 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 .open = tty_open,
481 .release = tty_release,
482 .fasync = tty_fasync,
483};
484
Arjan van de Ven62322d22006-07-03 00:24:21 -0700485static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 .llseek = no_llseek,
487 .read = tty_read,
488 .write = redirected_tty_write,
489 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700490 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700491 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 .open = tty_open,
493 .release = tty_release,
494 .fasync = tty_fasync,
495};
496
Arjan van de Ven62322d22006-07-03 00:24:21 -0700497static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 .llseek = no_llseek,
499 .read = hung_up_tty_read,
500 .write = hung_up_tty_write,
501 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700502 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700503 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 .release = tty_release,
Peter Hurleyf5574742016-01-09 21:45:10 -0800505 .fasync = hung_up_tty_fasync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506};
507
508static DEFINE_SPINLOCK(redirect_lock);
509static struct file *redirect;
510
Peter Hurley11d9bef2014-10-16 14:59:42 -0400511
512void proc_clear_tty(struct task_struct *p)
513{
514 unsigned long flags;
515 struct tty_struct *tty;
516 spin_lock_irqsave(&p->sighand->siglock, flags);
517 tty = p->signal->tty;
518 p->signal->tty = NULL;
519 spin_unlock_irqrestore(&p->sighand->siglock, flags);
520 tty_kref_put(tty);
521}
522
Peter Hurley2c411c12014-10-16 14:59:47 -0400523/**
524 * proc_set_tty - set the controlling terminal
525 *
526 * Only callable by the session leader and only if it does not already have
527 * a controlling terminal.
528 *
Peter Hurleye218eb32014-10-16 14:59:49 -0400529 * Caller must hold: tty_lock()
530 * a readlock on tasklist_lock
Peter Hurley2c411c12014-10-16 14:59:47 -0400531 * sighand lock
532 */
Peter Hurleybce65f12014-10-16 14:59:43 -0400533static void __proc_set_tty(struct tty_struct *tty)
Peter Hurley11d9bef2014-10-16 14:59:42 -0400534{
Peter Hurleyae28fa72014-10-16 14:59:46 -0400535 unsigned long flags;
536
Peter Hurleyae28fa72014-10-16 14:59:46 -0400537 spin_lock_irqsave(&tty->ctrl_lock, flags);
Peter Hurleya3618582014-10-16 14:59:50 -0400538 /*
539 * The session and fg pgrp references will be non-NULL if
540 * tiocsctty() is stealing the controlling tty
541 */
Peter Hurleyae28fa72014-10-16 14:59:46 -0400542 put_pid(tty->session);
543 put_pid(tty->pgrp);
544 tty->pgrp = get_pid(task_pgrp(current));
545 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
546 tty->session = get_pid(task_session(current));
547 if (current->signal->tty) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -0400548 tty_debug(tty, "current tty %s not NULL!!\n",
549 current->signal->tty->name);
Peter Hurleyae28fa72014-10-16 14:59:46 -0400550 tty_kref_put(current->signal->tty);
Peter Hurley11d9bef2014-10-16 14:59:42 -0400551 }
Peter Hurleybce65f12014-10-16 14:59:43 -0400552 put_pid(current->signal->tty_old_pgrp);
553 current->signal->tty = tty_kref_get(tty);
554 current->signal->tty_old_pgrp = NULL;
Peter Hurley11d9bef2014-10-16 14:59:42 -0400555}
556
Peter Hurleybce65f12014-10-16 14:59:43 -0400557static void proc_set_tty(struct tty_struct *tty)
Peter Hurley11d9bef2014-10-16 14:59:42 -0400558{
Peter Hurleybce65f12014-10-16 14:59:43 -0400559 spin_lock_irq(&current->sighand->siglock);
560 __proc_set_tty(tty);
561 spin_unlock_irq(&current->sighand->siglock);
Peter Hurley11d9bef2014-10-16 14:59:42 -0400562}
563
564struct tty_struct *get_current_tty(void)
565{
566 struct tty_struct *tty;
567 unsigned long flags;
568
569 spin_lock_irqsave(&current->sighand->siglock, flags);
570 tty = tty_kref_get(current->signal->tty);
571 spin_unlock_irqrestore(&current->sighand->siglock, flags);
572 return tty;
573}
574EXPORT_SYMBOL_GPL(get_current_tty);
575
576static void session_clear_tty(struct pid *session)
577{
578 struct task_struct *p;
579 do_each_pid_task(session, PIDTYPE_SID, p) {
580 proc_clear_tty(p);
581 } while_each_pid_task(session, PIDTYPE_SID, p);
582}
583
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584/**
585 * tty_wakeup - request more data
586 * @tty: terminal
587 *
588 * Internal and external helper for wakeups of tty. This function
589 * informs the line discipline if present that the driver is ready
590 * to receive more output data.
591 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593void tty_wakeup(struct tty_struct *tty)
594{
595 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
598 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800599 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100600 if (ld->ops->write_wakeup)
601 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 tty_ldisc_deref(ld);
603 }
604 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700605 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606}
607
608EXPORT_SYMBOL_GPL(tty_wakeup);
609
610/**
Peter Hurleyea648a42013-03-06 07:20:53 -0500611 * tty_signal_session_leader - sends SIGHUP to session leader
Peter Hurleyf91e2592013-03-06 07:20:56 -0500612 * @tty controlling tty
613 * @exit_session if non-zero, signal all foreground group processes
Peter Hurleyea648a42013-03-06 07:20:53 -0500614 *
Peter Hurleyf91e2592013-03-06 07:20:56 -0500615 * Send SIGHUP and SIGCONT to the session leader and its process group.
616 * Optionally, signal all processes in the foreground process group.
Peter Hurleyea648a42013-03-06 07:20:53 -0500617 *
618 * Returns the number of processes in the session with this tty
619 * as their controlling terminal. This value is used to drop
620 * tty references for those processes.
621 */
Peter Hurleyf91e2592013-03-06 07:20:56 -0500622static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)
Peter Hurleyea648a42013-03-06 07:20:53 -0500623{
624 struct task_struct *p;
Peter Hurleyea648a42013-03-06 07:20:53 -0500625 int refs = 0;
Peter Hurleyf91e2592013-03-06 07:20:56 -0500626 struct pid *tty_pgrp = NULL;
Peter Hurleyea648a42013-03-06 07:20:53 -0500627
628 read_lock(&tasklist_lock);
629 if (tty->session) {
630 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
631 spin_lock_irq(&p->sighand->siglock);
632 if (p->signal->tty == tty) {
633 p->signal->tty = NULL;
634 /* We defer the dereferences outside fo
635 the tasklist lock */
636 refs++;
637 }
638 if (!p->signal->leader) {
639 spin_unlock_irq(&p->sighand->siglock);
640 continue;
641 }
642 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
643 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
644 put_pid(p->signal->tty_old_pgrp); /* A noop */
Peter Hurleybc30c3b2013-03-06 07:20:55 -0500645 spin_lock(&tty->ctrl_lock);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500646 tty_pgrp = get_pid(tty->pgrp);
Peter Hurleyea648a42013-03-06 07:20:53 -0500647 if (tty->pgrp)
648 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Peter Hurleybc30c3b2013-03-06 07:20:55 -0500649 spin_unlock(&tty->ctrl_lock);
Peter Hurleyea648a42013-03-06 07:20:53 -0500650 spin_unlock_irq(&p->sighand->siglock);
651 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
652 }
653 read_unlock(&tasklist_lock);
654
Peter Hurleyf91e2592013-03-06 07:20:56 -0500655 if (tty_pgrp) {
656 if (exit_session)
657 kill_pgrp(tty_pgrp, SIGHUP, exit_session);
658 put_pid(tty_pgrp);
659 }
660
Peter Hurleyea648a42013-03-06 07:20:53 -0500661 return refs;
662}
663
664/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200665 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000666 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700667 *
Kevin Cernekeeef4f5272012-12-26 20:43:41 -0800668 * This can be called by a "kworker" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700669 * synchronous but doesn't hold any locks, so we need to make sure we
670 * have the appropriate locks for what we're doing.
671 *
672 * The hangup event clears any pending redirections onto the hung up
673 * device. It ensures future writes will error and it does the needed
674 * line discipline hangup and signal delivery. The tty object itself
675 * remains intact.
676 *
677 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200678 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800679 * redirect lock for undoing redirection
680 * file list lock for manipulating list of ttys
Peter Hurley137084b2013-06-15 07:04:46 -0400681 * tty_ldiscs_lock from called functions
Peter Hurley6a1c0682013-06-15 09:14:23 -0400682 * termios_rwsem resetting termios data
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800683 * tasklist_lock to walk task list for hangup event
684 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 */
Peter Hurleyf91e2592013-03-06 07:20:56 -0500686static void __tty_hangup(struct tty_struct *tty, int exit_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687{
Alan Cox37bdfb02008-02-08 04:18:47 -0800688 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 struct file *filp, *f = NULL;
Nick Piggind996b622010-08-18 04:37:36 +1000690 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 int closecount = 0, n;
Peter Hurleyea648a42013-03-06 07:20:53 -0500692 int refs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
694 if (!tty)
695 return;
696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000699 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 f = redirect;
701 redirect = NULL;
702 }
703 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800704
Alan Cox89c8d912012-08-08 16:30:13 +0100705 tty_lock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200706
Peter Hurleycb50e522013-07-31 14:05:45 -0400707 if (test_bit(TTY_HUPPED, &tty->flags)) {
708 tty_unlock(tty);
709 return;
710 }
711
Arnd Bergmannec79d602010-06-01 22:53:01 +0200712 /* inuse_filps is protected by the single tty lock,
713 this really needs to change if we want to flush the
714 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200715 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000716
Peter Hurley4a510962016-01-09 21:35:23 -0800717 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000719 list_for_each_entry(priv, &tty->tty_files, list) {
720 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 if (filp->f_op->write == redirected_tty_write)
722 cons_filp = filp;
723 if (filp->f_op->write != tty_write)
724 continue;
725 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200726 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 filp->f_op = &hung_up_tty_fops;
728 }
Peter Hurley4a510962016-01-09 21:35:23 -0800729 spin_unlock(&tty->files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800730
Peter Hurley25fdf242013-03-06 07:20:57 -0500731 refs = tty_signal_session_leader(tty, exit_session);
732 /* Account for the p->signal references we killed */
733 while (refs--)
734 tty_kref_put(tty);
735
Peter Hurley892d1fa2016-01-10 22:41:06 -0800736 tty_ldisc_hangup(tty, cons_filp != NULL);
Alan Cox37bdfb02008-02-08 04:18:47 -0800737
Peter Hurley20cc2252013-03-06 07:20:54 -0500738 spin_lock_irq(&tty->ctrl_lock);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100739 clear_bit(TTY_THROTTLED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100740 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600741 put_pid(tty->session);
742 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800743 tty->session = NULL;
744 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 tty->ctrl_status = 0;
Peter Hurley20cc2252013-03-06 07:20:54 -0500746 spin_unlock_irq(&tty->ctrl_lock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800749 * If one of the devices matches a console pointer, we
750 * cannot just call hangup() because that will cause
751 * tty->count and state->count to go out of sync.
752 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 */
754 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700755 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700757 tty->ops->close(tty, cons_filp);
758 } else if (tty->ops->hangup)
Peter Hurley7c6d3402014-06-16 09:17:08 -0400759 tty->ops->hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800760 /*
Peter Hurley892d1fa2016-01-10 22:41:06 -0800761 * We don't want to have driver/ldisc interactions beyond the ones
762 * we did here. The driver layer expects no calls after ->hangup()
763 * from the ldisc side, which is now guaranteed.
Alan Cox37bdfb02008-02-08 04:18:47 -0800764 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 set_bit(TTY_HUPPED, &tty->flags);
Alan Cox89c8d912012-08-08 16:30:13 +0100766 tty_unlock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 if (f)
769 fput(f);
770}
771
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200772static void do_tty_hangup(struct work_struct *work)
773{
774 struct tty_struct *tty =
775 container_of(work, struct tty_struct, hangup_work);
776
Peter Hurleyf91e2592013-03-06 07:20:56 -0500777 __tty_hangup(tty, 0);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200778}
779
Alan Coxaf9b8972006-08-27 01:24:01 -0700780/**
781 * tty_hangup - trigger a hangup event
782 * @tty: tty to hangup
783 *
784 * A carrier loss (virtual or otherwise) has occurred on this like
785 * schedule a hangup sequence to run after this event.
786 */
787
Alan Cox37bdfb02008-02-08 04:18:47 -0800788void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500790 tty_debug_hangup(tty, "hangup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 schedule_work(&tty->hangup_work);
792}
793
794EXPORT_SYMBOL(tty_hangup);
795
Alan Coxaf9b8972006-08-27 01:24:01 -0700796/**
797 * tty_vhangup - process vhangup
798 * @tty: tty to hangup
799 *
800 * The user has asked via system call for the terminal to be hung up.
801 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200802 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700803 */
804
Alan Cox37bdfb02008-02-08 04:18:47 -0800805void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500807 tty_debug_hangup(tty, "vhangup\n");
Peter Hurleyf91e2592013-03-06 07:20:56 -0500808 __tty_hangup(tty, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809}
Alan Cox37bdfb02008-02-08 04:18:47 -0800810
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811EXPORT_SYMBOL(tty_vhangup);
812
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200813
Alan Coxaf9b8972006-08-27 01:24:01 -0700814/**
Alan Cox2cb59982008-10-13 10:40:30 +0100815 * tty_vhangup_self - process vhangup for own ctty
816 *
817 * Perform a vhangup on the current controlling tty
818 */
819
820void tty_vhangup_self(void)
821{
822 struct tty_struct *tty;
823
Alan Cox2cb59982008-10-13 10:40:30 +0100824 tty = get_current_tty();
825 if (tty) {
826 tty_vhangup(tty);
827 tty_kref_put(tty);
828 }
Alan Cox2cb59982008-10-13 10:40:30 +0100829}
830
831/**
Peter Hurleyf91e2592013-03-06 07:20:56 -0500832 * tty_vhangup_session - hangup session leader exit
833 * @tty: tty to hangup
834 *
835 * The session leader is exiting and hanging up its controlling terminal.
836 * Every process in the foreground process group is signalled SIGHUP.
837 *
838 * We do this synchronously so that when the syscall returns the process
839 * is complete. That guarantee is necessary for security reasons.
840 */
841
Changlong Xie44a459f2013-03-20 08:42:04 +0800842static void tty_vhangup_session(struct tty_struct *tty)
Peter Hurleyf91e2592013-03-06 07:20:56 -0500843{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500844 tty_debug_hangup(tty, "session hangup\n");
Peter Hurleyf91e2592013-03-06 07:20:56 -0500845 __tty_hangup(tty, 1);
846}
847
848/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700849 * tty_hung_up_p - was tty hung up
850 * @filp: file pointer of tty
851 *
852 * Return true if the tty has been subject to a vhangup or a carrier
853 * loss
854 */
855
Alan Cox37bdfb02008-02-08 04:18:47 -0800856int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857{
858 return (filp->f_op == &hung_up_tty_fops);
859}
860
861EXPORT_SYMBOL(tty_hung_up_p);
862
Alan Coxaf9b8972006-08-27 01:24:01 -0700863/**
864 * disassociate_ctty - disconnect controlling tty
865 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700867 * This function is typically called only by the session leader, when
868 * it wants to disassociate itself from its controlling tty.
869 *
870 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
872 * (2) Clears the tty from being controlling the session
873 * (3) Clears the controlling tty for all processes in the
874 * session group.
875 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700876 * The argument on_exit is set to 1 if called when a process is
877 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
878 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800879 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200880 * BTM is taken for hysterical raisins, and held when
881 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800882 * tty_mutex is taken to protect tty
883 * ->siglock is taken to protect ->signal/->sighand
884 * tasklist_lock is taken to walk process list for sessions
885 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888void disassociate_ctty(int on_exit)
889{
890 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
Alan Cox5ec93d12009-11-30 13:18:45 +0000892 if (!current->signal->leader)
893 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800895 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 if (tty) {
Peter Hurleyf91e2592013-03-06 07:20:56 -0500897 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {
898 tty_vhangup_session(tty);
899 } else {
900 struct pid *tty_pgrp = tty_get_pgrp(tty);
901 if (tty_pgrp) {
902 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Oleg Nesterov03e12612013-09-15 17:50:26 +0200903 if (!on_exit)
904 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500905 put_pid(tty_pgrp);
906 }
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200907 }
Alan Cox452a00d2008-10-13 10:39:13 +0100908 tty_kref_put(tty);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500909
Eric W. Biederman680a9672007-02-12 00:52:52 -0800910 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800911 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800912 spin_lock_irq(&current->sighand->siglock);
913 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800914 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800915 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800916 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800917 kill_pgrp(old_pgrp, SIGHUP, on_exit);
918 kill_pgrp(old_pgrp, SIGCONT, on_exit);
919 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 return;
922 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800924 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700925 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800926 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800927
Chen Tingjiec70dbb12014-04-15 11:52:51 +0800928 tty = tty_kref_get(current->signal->tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800929 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700930 unsigned long flags;
931 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800932 put_pid(tty->session);
933 put_pid(tty->pgrp);
934 tty->session = NULL;
935 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700936 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100937 tty_kref_put(tty);
Peter Hurleyaccff792015-07-12 22:49:09 -0400938 } else
939 tty_debug_hangup(tty, "no current tty\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
Chen Tingjiec70dbb12014-04-15 11:52:51 +0800941 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 /* Now clear signal->tty under the lock */
943 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800944 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946}
947
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700948/**
949 *
950 * no_tty - Ensure the current process does not have a controlling tty
951 */
952void no_tty(void)
953{
Alan Cox3af502b2012-05-03 22:21:53 +0100954 /* FIXME: Review locking here. The tty_lock never covered any race
955 between a new association and proc_clear_tty but possible we need
956 to protect against this anyway */
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700957 struct task_struct *tsk = current;
Alan Cox5ec93d12009-11-30 13:18:45 +0000958 disassociate_ctty(0);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700959 proc_clear_tty(tsk);
960}
961
Alan Coxaf9b8972006-08-27 01:24:01 -0700962
963/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200964 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700965 * @tty: tty to stop
966 *
Peter Hurley01adc802014-09-10 15:06:32 -0400967 * Perform flow control to the driver. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700968 * on an already stopped device and will not re-call the driver
969 * method.
970 *
971 * This functionality is used by both the line disciplines for
972 * halting incoming flow and by the driver. It may therefore be
973 * called from any context, may be under the tty atomic_write_lock
974 * but not always.
975 *
976 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400977 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700978 */
979
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400980void __stop_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981{
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400982 if (tty->stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 return;
984 tty->stopped = 1;
Alan Coxf34d7a52008-04-30 00:54:13 -0700985 if (tty->ops->stop)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500986 tty->ops->stop(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987}
988
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400989void stop_tty(struct tty_struct *tty)
990{
991 unsigned long flags;
992
993 spin_lock_irqsave(&tty->flow_lock, flags);
994 __stop_tty(tty);
995 spin_unlock_irqrestore(&tty->flow_lock, flags);
996}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997EXPORT_SYMBOL(stop_tty);
998
Alan Coxaf9b8972006-08-27 01:24:01 -0700999/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +02001000 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -07001001 * @tty: tty to start
1002 *
Peter Hurley01adc802014-09-10 15:06:32 -04001003 * Start a tty that has been stopped if at all possible. If this
1004 * tty was previous stopped and is now being started, the driver
1005 * start method is invoked and the line discipline woken.
Alan Coxaf9b8972006-08-27 01:24:01 -07001006 *
1007 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001008 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -07001009 */
1010
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001011void __start_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012{
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001013 if (!tty->stopped || tty->flow_stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 return;
1015 tty->stopped = 0;
Alan Coxf34d7a52008-04-30 00:54:13 -07001016 if (tty->ops->start)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05001017 tty->ops->start(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019}
1020
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001021void start_tty(struct tty_struct *tty)
1022{
1023 unsigned long flags;
1024
1025 spin_lock_irqsave(&tty->flow_lock, flags);
1026 __start_tty(tty);
1027 spin_unlock_irqrestore(&tty->flow_lock, flags);
1028}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029EXPORT_SYMBOL(start_tty);
1030
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001031static void tty_update_time(struct timespec *time)
1032{
Jiri Slabyf0bf0bd2015-02-27 18:40:31 +01001033 unsigned long sec = get_seconds();
Greg Kroah-Hartmanfbf47632015-03-26 23:10:27 +01001034
1035 /*
1036 * We only care if the two values differ in anything other than the
1037 * lower three bits (i.e every 8 seconds). If so, then we can update
1038 * the time of the tty device, otherwise it could be construded as a
1039 * security leak to let userspace know the exact timing of the tty.
1040 */
1041 if ((sec ^ time->tv_sec) & ~7)
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001042 time->tv_sec = sec;
1043}
1044
Alan Coxaf9b8972006-08-27 01:24:01 -07001045/**
1046 * tty_read - read method for tty device files
1047 * @file: pointer to tty file
1048 * @buf: user buffer
1049 * @count: size of user buffer
1050 * @ppos: unused
1051 *
1052 * Perform the read system call function on this terminal device. Checks
1053 * for hung up devices before calling the line discipline method.
1054 *
1055 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -07001056 * Locks the line discipline internally while needed. Multiple
1057 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -07001058 */
1059
Alan Cox37bdfb02008-02-08 04:18:47 -08001060static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 loff_t *ppos)
1062{
1063 int i;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001064 struct inode *inode = file_inode(file);
Nick Piggind996b622010-08-18 04:37:36 +10001065 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 struct tty_ldisc *ld;
1067
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001068 if (tty_paranoia_check(tty, inode, "tty_read"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 return -EIO;
Peter Hurley18900ca2016-04-09 17:06:48 -07001070 if (!tty || tty_io_error(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 return -EIO;
1072
1073 /* We want to wait for the line discipline to sort out in this
1074 situation */
1075 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08001076 if (!ld)
1077 return hung_up_tty_read(file, buf, count, ppos);
Alan Coxa352def2008-07-16 21:53:12 +01001078 if (ld->ops->read)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05001079 i = ld->ops->read(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 else
1081 i = -EIO;
1082 tty_ldisc_deref(ld);
Jiri Slabyb0de59b2013-02-15 15:25:05 +01001083
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001084 if (i > 0)
1085 tty_update_time(&inode->i_atime);
1086
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 return i;
1088}
1089
Peter Hurley136d5252014-09-10 15:06:34 -04001090static void tty_write_unlock(struct tty_struct *tty)
Alan Cox9c1729d2007-07-15 23:39:43 -07001091{
1092 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -07001093 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -07001094}
1095
Peter Hurley136d5252014-09-10 15:06:34 -04001096static int tty_write_lock(struct tty_struct *tty, int ndelay)
Alan Cox9c1729d2007-07-15 23:39:43 -07001097{
1098 if (!mutex_trylock(&tty->atomic_write_lock)) {
1099 if (ndelay)
1100 return -EAGAIN;
1101 if (mutex_lock_interruptible(&tty->atomic_write_lock))
1102 return -ERESTARTSYS;
1103 }
1104 return 0;
1105}
1106
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107/*
1108 * Split writes up in sane blocksizes to avoid
1109 * denial-of-service type attacks
1110 */
1111static inline ssize_t do_tty_write(
1112 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1113 struct tty_struct *tty,
1114 struct file *file,
1115 const char __user *buf,
1116 size_t count)
1117{
Alan Cox9c1729d2007-07-15 23:39:43 -07001118 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -08001120
Alan Cox9c1729d2007-07-15 23:39:43 -07001121 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1122 if (ret < 0)
1123 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
1125 /*
1126 * We chunk up writes into a temporary buffer. This
1127 * simplifies low-level drivers immensely, since they
1128 * don't have locking issues and user mode accesses.
1129 *
1130 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1131 * big chunk-size..
1132 *
1133 * The default chunk-size is 2kB, because the NTTY
1134 * layer has problems with bigger chunks. It will
1135 * claim to be able to handle more characters than
1136 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001137 *
1138 * FIXME: This can probably go away now except that 64K chunks
1139 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 */
1141 chunk = 2048;
1142 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1143 chunk = 65536;
1144 if (count < chunk)
1145 chunk = count;
1146
Ingo Molnar70522e12006-03-23 03:00:31 -08001147 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001149 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 if (chunk < 1024)
1152 chunk = 1024;
1153
Jason Wessel402fda92008-10-13 10:45:36 +01001154 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1155 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001156 ret = -ENOMEM;
1157 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
1159 kfree(tty->write_buf);
1160 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001161 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 }
1163
1164 /* Do the write .. */
1165 for (;;) {
1166 size_t size = count;
1167 if (size > chunk)
1168 size = chunk;
1169 ret = -EFAULT;
1170 if (copy_from_user(tty->write_buf, buf, size))
1171 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 if (ret <= 0)
1174 break;
1175 written += ret;
1176 buf += ret;
1177 count -= ret;
1178 if (!count)
1179 break;
1180 ret = -ERESTARTSYS;
1181 if (signal_pending(current))
1182 break;
1183 cond_resched();
1184 }
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001185 if (written) {
1186 tty_update_time(&file_inode(file)->i_mtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 ret = written;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001188 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001189out:
1190 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 return ret;
1192}
1193
Alan Cox95f9bfc2008-10-13 10:39:23 +01001194/**
1195 * tty_write_message - write a message to a certain tty, not just the console.
1196 * @tty: the destination tty_struct
1197 * @msg: the message to write
1198 *
1199 * This is used for messages that need to be redirected to a specific tty.
1200 * We don't put it into the syslog queue right now maybe in the future if
1201 * really needed.
1202 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001203 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001204 */
1205
1206void tty_write_message(struct tty_struct *tty, char *msg)
1207{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001208 if (tty) {
1209 mutex_lock(&tty->atomic_write_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01001210 tty_lock(tty);
Peter Hurley4b41b952015-10-10 20:28:44 -04001211 if (tty->ops->write && tty->count > 0)
Alan Cox95f9bfc2008-10-13 10:39:23 +01001212 tty->ops->write(tty, msg, strlen(msg));
Peter Hurley4b41b952015-10-10 20:28:44 -04001213 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001214 tty_write_unlock(tty);
1215 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001216 return;
1217}
1218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
Alan Coxaf9b8972006-08-27 01:24:01 -07001220/**
1221 * tty_write - write method for tty device file
1222 * @file: tty file pointer
1223 * @buf: user data to write
1224 * @count: bytes to write
1225 * @ppos: unused
1226 *
1227 * Write data to a tty device via the line discipline.
1228 *
1229 * Locking:
1230 * Locks the line discipline as required
1231 * Writes to the tty driver are serialized by the atomic_write_lock
1232 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001233 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001234 */
1235
Alan Cox37bdfb02008-02-08 04:18:47 -08001236static ssize_t tty_write(struct file *file, const char __user *buf,
1237 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238{
Nick Piggind996b622010-08-18 04:37:36 +10001239 struct tty_struct *tty = file_tty(file);
1240 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001242
Al Viro6131ffa2013-02-27 16:59:05 -05001243 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 return -EIO;
Peter Hurley18900ca2016-04-09 17:06:48 -07001245 if (!tty || !tty->ops->write || tty_io_error(tty))
Alan Cox37bdfb02008-02-08 04:18:47 -08001246 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001247 /* Short term debug to catch buggy drivers */
1248 if (tty->ops->write_room == NULL)
Peter Hurley339f36b2015-11-08 13:01:13 -05001249 tty_err(tty, "missing write_room method\n");
Alan Cox37bdfb02008-02-08 04:18:47 -08001250 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08001251 if (!ld)
1252 return hung_up_tty_write(file, buf, count, ppos);
Alan Coxa352def2008-07-16 21:53:12 +01001253 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 ret = -EIO;
1255 else
Alan Coxa352def2008-07-16 21:53:12 +01001256 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 tty_ldisc_deref(ld);
1258 return ret;
1259}
1260
Alan Cox37bdfb02008-02-08 04:18:47 -08001261ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1262 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263{
1264 struct file *p = NULL;
1265
1266 spin_lock(&redirect_lock);
Al Virocb0942b2012-08-27 14:48:26 -04001267 if (redirect)
1268 p = get_file(redirect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 spin_unlock(&redirect_lock);
1270
1271 if (p) {
1272 ssize_t res;
1273 res = vfs_write(p, buf, count, &p->f_pos);
1274 fput(p);
1275 return res;
1276 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 return tty_write(file, buf, count, ppos);
1278}
1279
Peter Hurley136d5252014-09-10 15:06:34 -04001280/**
1281 * tty_send_xchar - send priority character
1282 *
1283 * Send a high priority character to the tty even if stopped
1284 *
1285 * Locking: none for xchar method, write ordering for write method.
1286 */
1287
1288int tty_send_xchar(struct tty_struct *tty, char ch)
1289{
1290 int was_stopped = tty->stopped;
1291
1292 if (tty->ops->send_xchar) {
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001293 down_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001294 tty->ops->send_xchar(tty, ch);
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001295 up_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001296 return 0;
1297 }
1298
1299 if (tty_write_lock(tty, 0) < 0)
1300 return -ERESTARTSYS;
1301
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001302 down_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001303 if (was_stopped)
1304 start_tty(tty);
1305 tty->ops->write(tty, &ch, 1);
1306 if (was_stopped)
1307 stop_tty(tty);
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001308 up_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001309 tty_write_unlock(tty);
1310 return 0;
1311}
1312
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313static char ptychar[] = "pqrstuvwxyzabcde";
1314
Alan Coxaf9b8972006-08-27 01:24:01 -07001315/**
1316 * pty_line_name - generate name for a pty
1317 * @driver: the tty driver in use
1318 * @index: the minor number
1319 * @p: output buffer of at least 6 bytes
1320 *
1321 * Generate a name from a driver reference and write it to the output
1322 * buffer.
1323 *
1324 * Locking: None
1325 */
1326static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327{
1328 int i = index + driver->name_base;
1329 /* ->name is initialized to "ttyp", but "tty" is expected */
1330 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001331 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1332 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333}
1334
Alan Coxaf9b8972006-08-27 01:24:01 -07001335/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001336 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001337 * @driver: the tty driver in use
1338 * @index: the minor number
1339 * @p: output buffer of at least 7 bytes
1340 *
1341 * Generate a name from a driver reference and write it to the output
Greg Kroah-Hartman5c0a2452014-02-22 14:31:04 -08001342 * buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07001343 *
1344 * Locking: None
1345 */
Hannes Reinecke723abd82014-02-27 12:30:51 +01001346static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347{
Jiri Slaby0019b402012-08-08 22:26:43 +02001348 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
Hannes Reinecke723abd82014-02-27 12:30:51 +01001349 return sprintf(p, "%s", driver->name);
Jiri Slaby0019b402012-08-08 22:26:43 +02001350 else
Hannes Reinecke723abd82014-02-27 12:30:51 +01001351 return sprintf(p, "%s%d", driver->name,
1352 index + driver->name_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353}
1354
Alan Cox99f1fe12008-10-13 10:42:00 +01001355/**
1356 * tty_driver_lookup_tty() - find an existing tty, if any
1357 * @driver: the driver for the tty
1358 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001359 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001360 * Return the tty, if found. If not found, return NULL or ERR_PTR() if the
1361 * driver lookup() method returns an error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001362 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001363 * Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001364 */
Jason Wessela47d5452009-01-02 13:43:04 +00001365static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07001366 struct file *file, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001367{
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001368 struct tty_struct *tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001369
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001370 if (driver->ops->lookup)
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07001371 tty = driver->ops->lookup(driver, file, idx);
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001372 else
1373 tty = driver->ttys[idx];
1374
1375 if (!IS_ERR(tty))
1376 tty_kref_get(tty);
1377 return tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001378}
1379
Alan Cox99f1fe12008-10-13 10:42:00 +01001380/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001381 * tty_init_termios - helper for termios setup
1382 * @tty: the tty to set up
1383 *
1384 * Initialise the termios structures for this tty. Thus runs under
1385 * the tty_mutex currently so we can be relaxed about ordering.
1386 */
1387
Peter Hurleya3123fd2016-01-09 21:13:48 -08001388void tty_init_termios(struct tty_struct *tty)
Alan Coxbf970ee2008-10-13 10:42:39 +01001389{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001390 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001391 int idx = tty->index;
1392
Alan Cox36b3c072012-07-17 17:06:57 +01001393 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1394 tty->termios = tty->driver->init_termios;
1395 else {
1396 /* Check for lazy saved data */
1397 tp = tty->driver->termios[idx];
Peter Hurleyece53402016-01-10 22:40:57 -08001398 if (tp != NULL) {
Alan Cox36b3c072012-07-17 17:06:57 +01001399 tty->termios = *tp;
Peter Hurleyece53402016-01-10 22:40:57 -08001400 tty->termios.c_line = tty->driver->init_termios.c_line;
1401 } else
Alan Cox36b3c072012-07-17 17:06:57 +01001402 tty->termios = tty->driver->init_termios;
Alan Coxbf970ee2008-10-13 10:42:39 +01001403 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001404 /* Compatibility until drivers always set this */
Alan Coxadc8d742012-07-14 15:31:47 +01001405 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1406 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001407}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001408EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001409
Jiri Slaby66d450e2012-01-30 21:14:28 +01001410int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1411{
Peter Hurleya3123fd2016-01-09 21:13:48 -08001412 tty_init_termios(tty);
Jiri Slaby66d450e2012-01-30 21:14:28 +01001413 tty_driver_kref_get(driver);
1414 tty->count++;
1415 driver->ttys[tty->index] = tty;
1416 return 0;
1417}
1418EXPORT_SYMBOL_GPL(tty_standard_install);
1419
Alan Coxbf970ee2008-10-13 10:42:39 +01001420/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001421 * tty_driver_install_tty() - install a tty entry in the driver
1422 * @driver: the driver for the tty
1423 * @tty: the tty
1424 *
1425 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001426 * will be set by the time this is called. This method is responsible
1427 * for ensuring any need additional structures are allocated and
1428 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001429 *
1430 * Locking: tty_mutex for now
1431 */
1432static int tty_driver_install_tty(struct tty_driver *driver,
1433 struct tty_struct *tty)
1434{
Jiri Slaby66d450e2012-01-30 21:14:28 +01001435 return driver->ops->install ? driver->ops->install(driver, tty) :
1436 tty_standard_install(driver, tty);
Alan Cox8b0a88d2008-10-13 10:42:19 +01001437}
1438
1439/**
1440 * tty_driver_remove_tty() - remove a tty from the driver tables
1441 * @driver: the driver for the tty
1442 * @idx: the minor number
1443 *
1444 * Remvoe a tty object from the driver tables. The tty->index field
1445 * will be set by the time this is called.
1446 *
1447 * Locking: tty_mutex for now
1448 */
Peter Hurley05de87ed2016-01-09 21:13:49 -08001449static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +01001450{
1451 if (driver->ops->remove)
1452 driver->ops->remove(driver, tty);
1453 else
1454 driver->ttys[tty->index] = NULL;
1455}
1456
1457/*
1458 * tty_reopen() - fast re-open of an open tty
1459 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001460 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001461 * Return 0 on success, -errno on error.
Peter Hurley5d93e742014-11-05 12:12:47 -05001462 * Re-opens on master ptys are not allowed and return -EIO.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001463 *
Peter Hurley5d93e742014-11-05 12:12:47 -05001464 * Locking: Caller must hold tty_lock
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001465 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001466static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001467{
1468 struct tty_driver *driver = tty->driver;
1469
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001470 if (driver->type == TTY_DRIVER_TYPE_PTY &&
Peter Hurley5d93e742014-11-05 12:12:47 -05001471 driver->subtype == PTY_TYPE_MASTER)
1472 return -EIO;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001473
Peter Hurley7f22f6c2016-01-09 21:13:45 -08001474 if (!tty->count)
1475 return -EAGAIN;
1476
Peter Hurley86f2c002014-12-30 10:39:25 -05001477 if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1478 return -EBUSY;
1479
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001480 tty->count++;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001481
Peter Hurley892d1fa2016-01-10 22:41:06 -08001482 if (!tty->ldisc)
1483 return tty_ldisc_reinit(tty, tty->termios.c_line);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001484
1485 return 0;
1486}
1487
Alan Coxaf9b8972006-08-27 01:24:01 -07001488/**
Alan Coxd81ed102008-10-13 10:41:42 +01001489 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001490 * @driver: tty driver we are opening a device on
1491 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001492 * @ret_tty: returned tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -07001493 *
1494 * Prepare a tty device. This may not be a "new" clean device but
1495 * could also be an active device. The pty drivers require special
1496 * handling because of this.
1497 *
1498 * Locking:
1499 * The function is called under the tty_mutex, which
1500 * protects us from the tty struct or driver itself going away.
1501 *
1502 * On exit the tty device has the line discipline attached and
1503 * a reference count of 1. If a pair was created for pty/tty use
1504 * and the other was a pty master then it too has a reference count of 1.
1505 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001507 * failed open. The new code protects the open with a mutex, so it's
1508 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 * relaxed for the (most common) case of reopening a tty.
1510 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001511
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001512struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513{
Alan Coxbf970ee2008-10-13 10:42:39 +01001514 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001515 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 /*
1518 * First time open is complex, especially for PTY devices.
1519 * This code guarantees that either everything succeeds and the
1520 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001521 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 * and locked termios may be retained.)
1523 */
1524
Alan Cox73ec06f2008-10-13 10:42:29 +01001525 if (!try_module_get(driver->owner))
1526 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02001528 tty = alloc_tty_struct(driver, idx);
Jiri Slabyd5543502011-03-23 10:48:32 +01001529 if (!tty) {
1530 retval = -ENOMEM;
1531 goto err_module_put;
1532 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
Alan Cox89c8d912012-08-08 16:30:13 +01001534 tty_lock(tty);
Alan Cox73ec06f2008-10-13 10:42:29 +01001535 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001536 if (retval < 0)
Peter Hurleyc8b710b2016-01-09 21:13:46 -08001537 goto err_free_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001538
Jiri Slaby04831dc2012-06-04 13:35:36 +02001539 if (!tty->port)
1540 tty->port = driver->ports[idx];
1541
Jiri Slaby5d4121c2012-08-17 14:27:52 +02001542 WARN_RATELIMIT(!tty->port,
1543 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1544 __func__, tty->driver->name);
1545
Jiri Slaby967fab62012-10-18 22:26:46 +02001546 tty->port->itty = tty;
1547
Alan Cox37bdfb02008-02-08 04:18:47 -08001548 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001550 * If we fail here just call release_tty to clean up. No need
1551 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001553 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001554 if (retval)
Jiri Slabyd5543502011-03-23 10:48:32 +01001555 goto err_release_tty;
Alan Cox89c8d912012-08-08 16:30:13 +01001556 /* Return the tty locked so that it cannot vanish under the caller */
Alan Cox73ec06f2008-10-13 10:42:29 +01001557 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558
Peter Hurleyc8b710b2016-01-09 21:13:46 -08001559err_free_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001560 tty_unlock(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001561 free_tty_struct(tty);
1562err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001564 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001566 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001567err_release_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001568 tty_unlock(tty);
Peter Hurley339f36b2015-11-08 13:01:13 -05001569 tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
1570 retval, idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001571 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001572 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573}
1574
Peter Hurleya3123fd2016-01-09 21:13:48 -08001575static void tty_free_termios(struct tty_struct *tty)
Alan Coxfeebed62008-10-13 10:41:30 +01001576{
1577 struct ktermios *tp;
1578 int idx = tty->index;
Alan Cox36b3c072012-07-17 17:06:57 +01001579
1580 /* If the port is going to reset then it has no termios to save */
1581 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1582 return;
1583
1584 /* Stash the termios data */
1585 tp = tty->driver->termios[idx];
1586 if (tp == NULL) {
1587 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
Peter Hurley25080652015-11-08 13:01:11 -05001588 if (tp == NULL)
Alan Cox36b3c072012-07-17 17:06:57 +01001589 return;
Dan Carpenter4ac5d702012-07-24 12:51:52 +01001590 tty->driver->termios[idx] = tp;
Alan Coxfeebed62008-10-13 10:41:30 +01001591 }
Alan Cox36b3c072012-07-17 17:06:57 +01001592 *tp = tty->termios;
Alan Coxfeebed62008-10-13 10:41:30 +01001593}
Alan Coxfeebed62008-10-13 10:41:30 +01001594
Peter Hurleya2965b72013-03-11 16:44:35 -04001595/**
Peter Hurley949aa642014-11-05 12:12:57 -05001596 * tty_flush_works - flush all works of a tty/pty pair
1597 * @tty: tty device to flush works for (or either end of a pty pair)
Peter Hurleya2965b72013-03-11 16:44:35 -04001598 *
Peter Hurley949aa642014-11-05 12:12:57 -05001599 * Sync flush all works belonging to @tty (and the 'other' tty).
Peter Hurleya2965b72013-03-11 16:44:35 -04001600 */
1601static void tty_flush_works(struct tty_struct *tty)
1602{
1603 flush_work(&tty->SAK_work);
1604 flush_work(&tty->hangup_work);
Peter Hurley949aa642014-11-05 12:12:57 -05001605 if (tty->link) {
1606 flush_work(&tty->link->SAK_work);
1607 flush_work(&tty->link->hangup_work);
1608 }
Peter Hurleya2965b72013-03-11 16:44:35 -04001609}
Alan Coxfeebed62008-10-13 10:41:30 +01001610
Alan Coxaf9b8972006-08-27 01:24:01 -07001611/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001612 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001613 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001614 *
1615 * Releases memory associated with a tty structure, and clears out the
1616 * driver table slots. This function is called when a device is no longer
1617 * in use. It also gets called when setup of a device fails.
1618 *
1619 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -07001620 * takes the file list lock internally when working on the list
1621 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001622 *
1623 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001624 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 */
Alan Coxb50989d2009-09-19 13:13:22 -07001626static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627{
Alan Coxb50989d2009-09-19 13:13:22 -07001628 struct tty_struct *tty =
1629 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001630 struct tty_driver *driver = tty->driver;
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001631 struct module *owner = driver->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632
Dave Youngf278a2f2009-09-27 16:00:42 +00001633 if (tty->ops->cleanup)
1634 tty->ops->cleanup(tty);
1635
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001637 tty_driver_kref_put(driver);
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001638 module_put(owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001639
Peter Hurley4a510962016-01-09 21:35:23 -08001640 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 list_del_init(&tty->tty_files);
Peter Hurley4a510962016-01-09 21:35:23 -08001642 spin_unlock(&tty->files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001643
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001644 put_pid(tty->pgrp);
1645 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 free_tty_struct(tty);
1647}
1648
Alan Coxb50989d2009-09-19 13:13:22 -07001649static void queue_release_one_tty(struct kref *kref)
1650{
1651 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001652
Alan Coxb50989d2009-09-19 13:13:22 -07001653 /* The hangup queue is now free so we can reuse it rather than
1654 waste a chunk of memory for each port */
1655 INIT_WORK(&tty->hangup_work, release_one_tty);
1656 schedule_work(&tty->hangup_work);
1657}
1658
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001659/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001660 * tty_kref_put - release a tty kref
1661 * @tty: tty device
1662 *
1663 * Release a reference to a tty device and if need be let the kref
1664 * layer destruct the object for us
1665 */
1666
1667void tty_kref_put(struct tty_struct *tty)
1668{
1669 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001670 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001671}
1672EXPORT_SYMBOL(tty_kref_put);
1673
1674/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001675 * release_tty - release tty structure memory
1676 *
1677 * Release both @tty and a possible linked partner (think pty pair),
1678 * and decrement the refcount of the backing module.
1679 *
1680 * Locking:
Alan Coxd1552552012-07-27 18:02:54 +01001681 * tty_mutex
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001682 * takes the file list lock internally when working on the list
1683 * of ttys that the driver keeps.
Alan Cox9c9f4de2008-10-13 10:37:26 +01001684 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001685 */
1686static void release_tty(struct tty_struct *tty, int idx)
1687{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001688 /* This should always be true but check for the moment */
1689 WARN_ON(tty->index != idx);
Alan Coxd1552552012-07-27 18:02:54 +01001690 WARN_ON(!mutex_is_locked(&tty_mutex));
Alan Cox36b3c072012-07-17 17:06:57 +01001691 if (tty->ops->shutdown)
1692 tty->ops->shutdown(tty);
1693 tty_free_termios(tty);
1694 tty_driver_remove_tty(tty->driver, tty);
Jiri Slaby967fab62012-10-18 22:26:46 +02001695 tty->port->itty = NULL;
Peter Hurley64e377d2013-06-15 09:01:00 -04001696 if (tty->link)
1697 tty->link->port->itty = NULL;
Peter Hurleye1760582015-10-17 16:36:23 -04001698 tty_buffer_cancel_work(tty->port);
Alan Cox36b3c072012-07-17 17:06:57 +01001699
Markus Elfringa211b1a2014-11-21 13:42:29 +01001700 tty_kref_put(tty->link);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001701 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001702}
1703
Alan Coxeeb89d92009-11-30 13:18:29 +00001704/**
Jiri Slaby955787ca2011-11-11 10:47:23 +01001705 * tty_release_checks - check a tty before real release
1706 * @tty: tty to check
1707 * @o_tty: link of @tty (if any)
1708 * @idx: index of the tty
1709 *
1710 * Performs some paranoid checking before true release of the @tty.
1711 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1712 */
Peter Hurley359b9fb2014-11-05 12:12:59 -05001713static int tty_release_checks(struct tty_struct *tty, int idx)
Jiri Slaby955787ca2011-11-11 10:47:23 +01001714{
1715#ifdef TTY_PARANOIA_CHECK
1716 if (idx < 0 || idx >= tty->driver->num) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001717 tty_debug(tty, "bad idx %d\n", idx);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001718 return -1;
1719 }
1720
1721 /* not much to check for devpts */
1722 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1723 return 0;
1724
1725 if (tty != tty->driver->ttys[idx]) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001726 tty_debug(tty, "bad driver table[%d] = %p\n",
1727 idx, tty->driver->ttys[idx]);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001728 return -1;
1729 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001730 if (tty->driver->other) {
Peter Hurley359b9fb2014-11-05 12:12:59 -05001731 struct tty_struct *o_tty = tty->link;
1732
Jiri Slaby955787ca2011-11-11 10:47:23 +01001733 if (o_tty != tty->driver->other->ttys[idx]) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001734 tty_debug(tty, "bad other table[%d] = %p\n",
1735 idx, tty->driver->other->ttys[idx]);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001736 return -1;
1737 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001738 if (o_tty->link != tty) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001739 tty_debug(tty, "bad link = %p\n", o_tty->link);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001740 return -1;
1741 }
1742 }
1743#endif
1744 return 0;
1745}
1746
1747/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001748 * tty_release - vfs callback for close
1749 * @inode: inode of tty
1750 * @filp: file pointer for handle to tty
1751 *
1752 * Called the last time each file handle is closed that references
1753 * this tty. There may however be several such references.
1754 *
1755 * Locking:
1756 * Takes bkl. See tty_release_dev
1757 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 * Even releasing the tty structures is a tricky business.. We have
1759 * to be very careful that the structures are all released at the
1760 * same time, as interrupts might otherwise get the wrong pointers.
1761 *
1762 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1763 * lead to double frees or releasing memory still in use.
1764 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001765
1766int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767{
Nick Piggind996b622010-08-18 04:37:36 +10001768 struct tty_struct *tty = file_tty(filp);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001769 struct tty_struct *o_tty = NULL;
1770 int do_sleep, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 int idx;
Peter Hurley37b16452014-10-16 13:51:30 -04001772 long timeout = 0;
Peter Hurley494c1ea2014-10-16 13:54:36 -04001773 int once = 1;
Alan Cox37bdfb02008-02-08 04:18:47 -08001774
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001775 if (tty_paranoia_check(tty, inode, __func__))
Alan Coxeeb89d92009-11-30 13:18:29 +00001776 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
Alan Cox89c8d912012-08-08 16:30:13 +01001778 tty_lock(tty);
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001779 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780
Arnd Bergmannec79d602010-06-01 22:53:01 +02001781 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
1783 idx = tty->index;
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001784 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1785 tty->driver->subtype == PTY_TYPE_MASTER)
1786 o_tty = tty->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787
Peter Hurley359b9fb2014-11-05 12:12:59 -05001788 if (tty_release_checks(tty, idx)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001789 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001790 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
Peter Hurleyd435cef2015-11-08 13:01:19 -05001793 tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Alan Coxf34d7a52008-04-30 00:54:13 -07001795 if (tty->ops->close)
1796 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
Peter Hurley2aff5e22014-11-05 12:13:01 -05001798 /* If tty is pty master, lock the slave pty (stable lock order) */
1799 tty_lock_slave(o_tty);
1800
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 /*
1802 * Sanity check: if tty->count is going to zero, there shouldn't be
1803 * any waiters on tty->read_wait or tty->write_wait. We test the
1804 * wait queues and kick everyone out _before_ actually starting to
1805 * close. This ensures that we won't block while releasing the tty
1806 * structure.
1807 *
1808 * The test for the o_tty closing is necessary, since the master and
1809 * slave sides may close in any order. If the slave side closes out
1810 * first, its count will be one, since the master side holds an open.
Peter Hurley324c1652014-11-05 12:12:56 -05001811 * Thus this test wouldn't be triggered at the time the slave closed,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 * so we do it now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 */
1814 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 do_sleep = 0;
1816
Peter Hurley324c1652014-11-05 12:12:56 -05001817 if (tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001819 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 do_sleep++;
1821 }
1822 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001823 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 do_sleep++;
1825 }
1826 }
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001827 if (o_tty && o_tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001829 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 do_sleep++;
1831 }
1832 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001833 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 do_sleep++;
1835 }
1836 }
1837 if (!do_sleep)
1838 break;
1839
Peter Hurley494c1ea2014-10-16 13:54:36 -04001840 if (once) {
1841 once = 0;
Peter Hurley339f36b2015-11-08 13:01:13 -05001842 tty_warn(tty, "read/write wait queue active!\n");
Peter Hurley494c1ea2014-10-16 13:54:36 -04001843 }
Peter Hurley37b16452014-10-16 13:51:30 -04001844 schedule_timeout_killable(timeout);
1845 if (timeout < 120 * HZ)
1846 timeout = 2 * timeout + 1;
1847 else
1848 timeout = MAX_SCHEDULE_TIMEOUT;
Alan Cox37bdfb02008-02-08 04:18:47 -08001849 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001851 if (o_tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 if (--o_tty->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -05001853 tty_warn(tty, "bad slave count (%d)\n", o_tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 o_tty->count = 0;
1855 }
1856 }
1857 if (--tty->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -05001858 tty_warn(tty, "bad tty->count (%d)\n", tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 tty->count = 0;
1860 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001861
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 /*
1863 * We've decremented tty->count, so we need to remove this file
1864 * descriptor off the tty->tty_files list; this serves two
1865 * purposes:
1866 * - check_tty_count sees the correct number of file descriptors
1867 * associated with this tty.
1868 * - do_tty_hangup no longer sees this file descriptor as
1869 * something that needs to be handled for hangups.
1870 */
Nick Piggind996b622010-08-18 04:37:36 +10001871 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872
1873 /*
1874 * Perform some housekeeping before deciding whether to return.
1875 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 * If _either_ side is closing, make sure there aren't any
1877 * processes that still think tty or o_tty is their controlling
1878 * tty.
1879 */
Peter Hurley324c1652014-11-05 12:12:56 -05001880 if (!tty->count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001882 session_clear_tty(tty->session);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001883 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001884 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 read_unlock(&tasklist_lock);
1886 }
1887
Peter Hurley324c1652014-11-05 12:12:56 -05001888 /* check whether both sides are closing ... */
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001889 final = !tty->count && !(o_tty && o_tty->count);
Peter Hurley324c1652014-11-05 12:12:56 -05001890
Peter Hurley2aff5e22014-11-05 12:13:01 -05001891 tty_unlock_slave(o_tty);
1892 tty_unlock(tty);
1893
Peter Hurley04980702014-11-05 12:12:52 -05001894 /* At this point, the tty->count == 0 should ensure a dead tty
Alan Coxd1552552012-07-27 18:02:54 +01001895 cannot be re-opened by a racing opener */
Paul Fulghumda965822006-02-14 13:53:00 -08001896
Peter Hurley324c1652014-11-05 12:12:56 -05001897 if (!final)
Alan Coxeeb89d92009-11-30 13:18:29 +00001898 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001899
Peter Hurleyaccff792015-07-12 22:49:09 -04001900 tty_debug_hangup(tty, "final close\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 /*
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 Hurleyd435cef2015-11-08 13:01:19 -05001909 tty_debug_hangup(tty, "freeing structure\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001911 * The release_tty function takes care of the details of clearing
Alan Cox89c8d912012-08-08 16:30:13 +01001912 * the slots and preserving the termios structure. The tty_unlock_pair
1913 * should be safe as we keep a kref while the tty is locked (so the
1914 * unlock never unlocks a freed tty).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 */
Alan Coxd1552552012-07-27 18:02:54 +01001916 mutex_lock(&tty_mutex);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001917 release_tty(tty, idx);
Alan Coxd1552552012-07-27 18:02:54 +01001918 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919
Alan Coxeeb89d92009-11-30 13:18:29 +00001920 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921}
1922
Alan Coxaf9b8972006-08-27 01:24:01 -07001923/**
Peter Hurley52494ee2014-11-05 12:12:50 -05001924 * tty_open_current_tty - get locked tty of current task
Jiri Slabyb82154a2011-11-09 21:33:19 +01001925 * @device: device number
1926 * @filp: file pointer to tty
Peter Hurley52494ee2014-11-05 12:12:50 -05001927 * @return: locked tty of the current task iff @device is /dev/tty
1928 *
1929 * Performs a re-open of the current task's controlling tty.
Jiri Slabyb82154a2011-11-09 21:33:19 +01001930 *
1931 * We cannot return driver and index like for the other nodes because
1932 * devpts will not work then. It expects inodes to be from devpts FS.
1933 */
1934static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1935{
1936 struct tty_struct *tty;
Peter Hurley52494ee2014-11-05 12:12:50 -05001937 int retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01001938
1939 if (device != MKDEV(TTYAUX_MAJOR, 0))
1940 return NULL;
1941
1942 tty = get_current_tty();
1943 if (!tty)
1944 return ERR_PTR(-ENXIO);
1945
1946 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1947 /* noctty = 1; */
Peter Hurley52494ee2014-11-05 12:12:50 -05001948 tty_lock(tty);
1949 tty_kref_put(tty); /* safe to drop the kref now */
1950
1951 retval = tty_reopen(tty);
1952 if (retval < 0) {
1953 tty_unlock(tty);
1954 tty = ERR_PTR(retval);
1955 }
Jiri Slabyb82154a2011-11-09 21:33:19 +01001956 return tty;
1957}
1958
1959/**
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001960 * tty_lookup_driver - lookup a tty driver for a given device file
1961 * @device: device number
1962 * @filp: file pointer to tty
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001963 * @index: index for the device in the @return driver
1964 * @return: driver for this inode (with increased refcount)
1965 *
1966 * If @return is not erroneous, the caller is responsible to decrement the
1967 * refcount by tty_driver_kref_put.
1968 *
1969 * Locking: tty_mutex protects get_tty_driver
1970 */
1971static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
Peter Hurley11e1d4a2016-01-09 21:13:52 -08001972 int *index)
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001973{
1974 struct tty_driver *driver;
1975
Jiri Slaby2cd00502011-11-09 21:33:22 +01001976 switch (device) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001977#ifdef CONFIG_VT
Jiri Slaby2cd00502011-11-09 21:33:22 +01001978 case MKDEV(TTY_MAJOR, 0): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001979 extern struct tty_driver *console_driver;
1980 driver = tty_driver_kref_get(console_driver);
1981 *index = fg_console;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001982 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001983 }
1984#endif
Jiri Slaby2cd00502011-11-09 21:33:22 +01001985 case MKDEV(TTYAUX_MAJOR, 1): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001986 struct tty_driver *console_driver = console_device(index);
1987 if (console_driver) {
1988 driver = tty_driver_kref_get(console_driver);
1989 if (driver) {
1990 /* Don't let /dev/console block */
1991 filp->f_flags |= O_NONBLOCK;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001992 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001993 }
1994 }
1995 return ERR_PTR(-ENODEV);
1996 }
Jiri Slaby2cd00502011-11-09 21:33:22 +01001997 default:
1998 driver = get_tty_driver(device, index);
1999 if (!driver)
2000 return ERR_PTR(-ENODEV);
2001 break;
2002 }
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002003 return driver;
2004}
2005
2006/**
Peter Hurleyd6203d02016-01-09 21:13:53 -08002007 * tty_open_by_driver - open a tty device
2008 * @device: dev_t of device to open
2009 * @inode: inode of device file
2010 * @filp: file pointer to tty
2011 *
2012 * Performs the driver lookup, checks for a reopen, or otherwise
2013 * performs the first-time tty initialization.
2014 *
2015 * Returns the locked initialized or re-opened &tty_struct
2016 *
2017 * Claims the global tty_mutex to serialize:
2018 * - concurrent first-time tty initialization
2019 * - concurrent tty driver removal w/ lookup
2020 * - concurrent tty removal from driver table
2021 */
2022static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
2023 struct file *filp)
2024{
2025 struct tty_struct *tty;
2026 struct tty_driver *driver = NULL;
2027 int index = -1;
2028 int retval;
2029
2030 mutex_lock(&tty_mutex);
2031 driver = tty_lookup_driver(device, filp, &index);
2032 if (IS_ERR(driver)) {
2033 mutex_unlock(&tty_mutex);
2034 return ERR_CAST(driver);
2035 }
2036
2037 /* check whether we're reopening an existing tty */
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07002038 tty = tty_driver_lookup_tty(driver, filp, index);
Peter Hurleyd6203d02016-01-09 21:13:53 -08002039 if (IS_ERR(tty)) {
2040 mutex_unlock(&tty_mutex);
2041 goto out;
2042 }
2043
2044 if (tty) {
2045 mutex_unlock(&tty_mutex);
2046 retval = tty_lock_interruptible(tty);
Peter Hurley5e00bbf2016-03-31 17:47:07 -07002047 tty_kref_put(tty); /* drop kref from tty_driver_lookup_tty() */
Peter Hurleyd6203d02016-01-09 21:13:53 -08002048 if (retval) {
2049 if (retval == -EINTR)
2050 retval = -ERESTARTSYS;
2051 tty = ERR_PTR(retval);
2052 goto out;
2053 }
Peter Hurleyd6203d02016-01-09 21:13:53 -08002054 retval = tty_reopen(tty);
2055 if (retval < 0) {
2056 tty_unlock(tty);
2057 tty = ERR_PTR(retval);
2058 }
2059 } else { /* Returns with the tty_lock held for now */
2060 tty = tty_init_dev(driver, index);
2061 mutex_unlock(&tty_mutex);
2062 }
2063out:
2064 tty_driver_kref_put(driver);
2065 return tty;
2066}
2067
2068/**
Alan Coxeeb89d92009-11-30 13:18:29 +00002069 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002070 * @inode: inode of device file
2071 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002073 * tty_open and tty_release keep up the tty count that contains the
2074 * number of opens done on a tty. We cannot use the inode-count, as
2075 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002077 * Open-counting is needed for pty masters, as well as for keeping
2078 * track of serial lines: DTR is dropped when the last close happens.
2079 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2080 *
2081 * The termios state of a pty is reset on first open so that
2082 * settings don't persist across reuse.
2083 *
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002084 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002085 * tty->count should protect the rest.
2086 * ->siglock protects ->signal/->sighand
Alan Cox89c8d912012-08-08 16:30:13 +01002087 *
2088 * Note: the tty_unlock/lock cases without a ref are only safe due to
2089 * tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002091
Alan Coxeeb89d92009-11-30 13:18:29 +00002092static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093{
Jiri Slabyb82154a2011-11-09 21:33:19 +01002094 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 int noctty, retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07002097 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098
2099 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08002100
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101retry_open:
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002102 retval = tty_alloc_file(filp);
2103 if (retval)
2104 return -ENOMEM;
2105
Jiri Slabyb82154a2011-11-09 21:33:19 +01002106 tty = tty_open_current_tty(device, filp);
Peter Hurleyd6203d02016-01-09 21:13:53 -08002107 if (!tty)
2108 tty = tty_open_by_driver(device, inode, filp);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01002109
Alan Coxeeb89d92009-11-30 13:18:29 +00002110 if (IS_ERR(tty)) {
Peter Hurleyd6203d02016-01-09 21:13:53 -08002111 tty_free_file(filp);
Jiri Slabyba5db442011-11-09 21:33:21 +01002112 retval = PTR_ERR(tty);
Peter Hurley7f22f6c2016-01-09 21:13:45 -08002113 if (retval != -EAGAIN || signal_pending(current))
Peter Hurleyd6203d02016-01-09 21:13:53 -08002114 return retval;
Peter Hurley7f22f6c2016-01-09 21:13:45 -08002115 schedule();
2116 goto retry_open;
Alan Coxeeb89d92009-11-30 13:18:29 +00002117 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002119 tty_add_file(tty, filp);
Nick Piggind996b622010-08-18 04:37:36 +10002120
Jiri Slaby9de44bd2011-11-09 21:33:24 +01002121 check_tty_count(tty, __func__);
Peter Hurleyd435cef2015-11-08 13:01:19 -05002122 tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
Peter Hurleyaccff792015-07-12 22:49:09 -04002123
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03002124 if (tty->ops->open)
2125 retval = tty->ops->open(tty, filp);
2126 else
2127 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 filp->f_flags = saved_flags;
2129
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 if (retval) {
Peter Hurleyd435cef2015-11-08 13:01:19 -05002131 tty_debug_hangup(tty, "open error %d, releasing\n", retval);
Peter Hurleyaccff792015-07-12 22:49:09 -04002132
Alan Cox89c8d912012-08-08 16:30:13 +01002133 tty_unlock(tty); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00002134 tty_release(inode, filp);
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002135 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 return retval;
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002137
2138 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 return retval;
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002140
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 schedule();
2142 /*
2143 * Need to reset f_op in case a hangup happened.
2144 */
Peter Hurley12569372014-11-05 12:26:24 -05002145 if (tty_hung_up_p(filp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 filp->f_op = &tty_fops;
2147 goto retry_open;
2148 }
Peter Hurleyd4855e12013-11-19 08:46:27 -05002149 clear_bit(TTY_HUPPED, &tty->flags);
Alan Coxeeb89d92009-11-30 13:18:29 +00002150
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002151
Peter Hurley2c411c12014-10-16 14:59:47 -04002152 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002153 spin_lock_irq(&current->sighand->siglock);
Peter Hurley11e1d4a2016-01-09 21:13:52 -08002154 noctty = (filp->f_flags & O_NOCTTY) ||
Peter Hurleyda5a0fc2016-03-31 17:05:30 -07002155 (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
Peter Hurley11e1d4a2016-01-09 21:13:52 -08002156 device == MKDEV(TTYAUX_MAJOR, 1) ||
2157 (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2158 tty->driver->subtype == PTY_TYPE_MASTER);
2159
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 if (!noctty &&
2161 current->signal->leader &&
2162 !current->signal->tty &&
Jann Horn0c5562712015-10-04 19:29:12 +02002163 tty->session == NULL) {
2164 /*
2165 * Don't let a process that only has write access to the tty
2166 * obtain the privileges associated with having a tty as
2167 * controlling terminal (being able to reopen it with full
2168 * access through /dev/tty, being able to perform pushback).
2169 * Many distributions set the group of all ttys to "tty" and
2170 * grant write-only access to all terminals for setgid tty
2171 * binaries, which should not imply full privileges on all ttys.
2172 *
2173 * This could theoretically break old code that performs open()
2174 * on a write-only file descriptor. In that case, it might be
2175 * necessary to also permit this if
2176 * inode_permission(inode, MAY_READ) == 0.
2177 */
2178 if (filp->f_mode & FMODE_READ)
2179 __proc_set_tty(tty);
2180 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002181 spin_unlock_irq(&current->sighand->siglock);
Peter Hurley2c411c12014-10-16 14:59:47 -04002182 read_unlock(&tasklist_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01002183 tty_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 return 0;
2185}
2186
Jonathan Corbet39d95b92008-05-16 09:10:50 -06002187
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
Alan Coxaf9b8972006-08-27 01:24:01 -07002189/**
2190 * tty_poll - check tty status
2191 * @filp: file being polled
2192 * @wait: poll wait structures to update
2193 *
2194 * Call the line discipline polling method to obtain the poll
2195 * status of the device.
2196 *
2197 * Locking: locks called line discipline but ldisc poll method
2198 * may be re-entered freely by other callers.
2199 */
2200
Alan Cox37bdfb02008-02-08 04:18:47 -08002201static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202{
Nick Piggind996b622010-08-18 04:37:36 +10002203 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 struct tty_ldisc *ld;
2205 int ret = 0;
2206
Al Viro6131ffa2013-02-27 16:59:05 -05002207 if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002209
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002211 if (!ld)
2212 return hung_up_tty_poll(filp, wait);
Alan Coxa352def2008-07-16 21:53:12 +01002213 if (ld->ops->poll)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002214 ret = ld->ops->poll(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 tty_ldisc_deref(ld);
2216 return ret;
2217}
2218
Arnd Bergmannec79d602010-06-01 22:53:01 +02002219static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220{
Nick Piggind996b622010-08-18 04:37:36 +10002221 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07002222 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002223 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224
Al Viro6131ffa2013-02-27 16:59:05 -05002225 if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002226 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08002227
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 retval = fasync_helper(fd, filp, on, &tty->fasync);
2229 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002230 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
2232 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002233 enum pid_type type;
2234 struct pid *pid;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002235
Alan Cox47f86832008-04-30 00:53:30 -07002236 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002237 if (tty->pgrp) {
2238 pid = tty->pgrp;
2239 type = PIDTYPE_PGID;
2240 } else {
2241 pid = task_pid(current);
2242 type = PIDTYPE_PID;
2243 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002244 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002245 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002246 __f_setown(filp, pid, type, 0);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002247 put_pid(pid);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002248 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002250out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002251 return retval;
2252}
2253
2254static int tty_fasync(int fd, struct file *filp, int on)
2255{
Alan Cox89c8d912012-08-08 16:30:13 +01002256 struct tty_struct *tty = file_tty(filp);
Peter Hurleya8f3a292016-01-09 21:45:11 -08002257 int retval = -ENOTTY;
Alan Cox89c8d912012-08-08 16:30:13 +01002258
2259 tty_lock(tty);
Peter Hurleya8f3a292016-01-09 21:45:11 -08002260 if (!tty_hung_up_p(filp))
2261 retval = __tty_fasync(fd, filp, on);
Alan Cox89c8d912012-08-08 16:30:13 +01002262 tty_unlock(tty);
2263
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002264 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265}
2266
Alan Coxaf9b8972006-08-27 01:24:01 -07002267/**
2268 * tiocsti - fake input character
2269 * @tty: tty to fake input into
2270 * @p: pointer to character
2271 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002272 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002273 * input management.
2274 *
2275 * FIXME: does not honour flow control ??
2276 *
2277 * Locking:
Peter Hurley137084b2013-06-15 07:04:46 -04002278 * Called functions take tty_ldiscs_lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002279 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002280 *
2281 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002282 */
2283
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284static int tiocsti(struct tty_struct *tty, char __user *p)
2285{
2286 char ch, mbz = 0;
2287 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002288
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2290 return -EPERM;
2291 if (get_user(ch, p))
2292 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002293 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002295 if (!ld)
2296 return -EIO;
Alan Coxa352def2008-07-16 21:53:12 +01002297 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 tty_ldisc_deref(ld);
2299 return 0;
2300}
2301
Alan Coxaf9b8972006-08-27 01:24:01 -07002302/**
2303 * tiocgwinsz - implement window query ioctl
2304 * @tty; tty
2305 * @arg: user buffer for result
2306 *
Alan Cox808a0d32006-09-29 02:00:40 -07002307 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002308 *
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002309 * Locking: tty->winsize_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002310 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002311 */
2312
Alan Cox37bdfb02008-02-08 04:18:47 -08002313static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314{
Alan Cox808a0d32006-09-29 02:00:40 -07002315 int err;
2316
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002317 mutex_lock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002318 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002319 mutex_unlock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002320
2321 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322}
2323
Alan Coxaf9b8972006-08-27 01:24:01 -07002324/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002325 * tty_do_resize - resize event
2326 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002327 * @rows: rows (character)
2328 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002329 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002330 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002331 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002332 */
2333
Alan Coxfc6f6232009-01-02 13:43:17 +00002334int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335{
Alan Coxfc6f6232009-01-02 13:43:17 +00002336 struct pid *pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
Alan Coxfc6f6232009-01-02 13:43:17 +00002338 /* Lock the tty */
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002339 mutex_lock(&tty->winsize_mutex);
Alan Coxfc6f6232009-01-02 13:43:17 +00002340 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002341 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002342
Peter Hurley5b239542014-10-16 14:59:45 -04002343 /* Signal the foreground process group */
2344 pgrp = tty_get_pgrp(tty);
Alan Cox47f86832008-04-30 00:53:30 -07002345 if (pgrp)
2346 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002347 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002348
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002349 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002350done:
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002351 mutex_unlock(&tty->winsize_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 return 0;
2353}
Martin Schwidefsky4d334fd2013-01-04 14:55:13 +01002354EXPORT_SYMBOL(tty_do_resize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355
Alan Coxaf9b8972006-08-27 01:24:01 -07002356/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002357 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002358 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002359 * @arg: user buffer for result
2360 *
2361 * Copies the user idea of the window size to the kernel. Traditionally
2362 * this is just advisory information but for the Linux console it
2363 * actually has driver level meaning and triggers a VC resize.
2364 *
2365 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002366 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002367 * tty termios mutex and ctrl_lock. The console takes its own lock
2368 * then calls into the default method.
2369 */
2370
Alan Coxfc6f6232009-01-02 13:43:17 +00002371static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002372{
2373 struct winsize tmp_ws;
2374 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2375 return -EFAULT;
2376
2377 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002378 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002379 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002380 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002381}
2382
2383/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002384 * tioccons - allow admin to move logical console
2385 * @file: the file to become console
2386 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002387 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002388 *
2389 * Locking: uses redirect_lock to guard the redirect information
2390 */
2391
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392static int tioccons(struct file *file)
2393{
2394 if (!capable(CAP_SYS_ADMIN))
2395 return -EPERM;
2396 if (file->f_op->write == redirected_tty_write) {
2397 struct file *f;
2398 spin_lock(&redirect_lock);
2399 f = redirect;
2400 redirect = NULL;
2401 spin_unlock(&redirect_lock);
2402 if (f)
2403 fput(f);
2404 return 0;
2405 }
2406 spin_lock(&redirect_lock);
2407 if (redirect) {
2408 spin_unlock(&redirect_lock);
2409 return -EBUSY;
2410 }
Al Virocb0942b2012-08-27 14:48:26 -04002411 redirect = get_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 spin_unlock(&redirect_lock);
2413 return 0;
2414}
2415
Alan Coxaf9b8972006-08-27 01:24:01 -07002416/**
2417 * fionbio - non blocking ioctl
2418 * @file: file to set blocking value
2419 * @p: user parameter
2420 *
2421 * Historical tty interfaces had a blocking control ioctl before
2422 * the generic functionality existed. This piece of history is preserved
2423 * in the expected tty API of posix OS's.
2424 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002425 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002426 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427
2428static int fionbio(struct file *file, int __user *p)
2429{
2430 int nonblock;
2431
2432 if (get_user(nonblock, p))
2433 return -EFAULT;
2434
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002435 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 if (nonblock)
2437 file->f_flags |= O_NONBLOCK;
2438 else
2439 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002440 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 return 0;
2442}
2443
Alan Coxaf9b8972006-08-27 01:24:01 -07002444/**
2445 * tiocsctty - set controlling tty
2446 * @tty: tty structure
2447 * @arg: user argument
2448 *
2449 * This ioctl is used to manage job control. It permits a session
2450 * leader to set this tty as the controlling tty for the session.
2451 *
2452 * Locking:
Peter Hurleye218eb32014-10-16 14:59:49 -04002453 * Takes tty_lock() to serialize proc_set_tty() for this tty
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002454 * Takes tasklist_lock internally to walk sessions
2455 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002456 */
2457
Jann Horn0c5562712015-10-04 19:29:12 +02002458static int tiocsctty(struct tty_struct *tty, struct file *file, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002460 int ret = 0;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002461
Peter Hurleye218eb32014-10-16 14:59:49 -04002462 tty_lock(tty);
Peter Hurley2c411c12014-10-16 14:59:47 -04002463 read_lock(&tasklist_lock);
2464
2465 if (current->signal->leader && (task_session(current) == tty->session))
2466 goto unlock;
2467
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 /*
2469 * The process must be a session leader and
2470 * not have a controlling tty already.
2471 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002472 if (!current->signal->leader || current->signal->tty) {
2473 ret = -EPERM;
2474 goto unlock;
2475 }
2476
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002477 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 /*
2479 * This tty is already the controlling
2480 * tty for another session group!
2481 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002482 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 /*
2484 * Steal it away
2485 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002486 session_clear_tty(tty->session);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002487 } else {
2488 ret = -EPERM;
2489 goto unlock;
2490 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 }
Jann Horn0c5562712015-10-04 19:29:12 +02002492
2493 /* See the comment in tty_open(). */
2494 if ((file->f_mode & FMODE_READ) == 0 && !capable(CAP_SYS_ADMIN)) {
2495 ret = -EPERM;
2496 goto unlock;
2497 }
2498
Peter Hurleybce65f12014-10-16 14:59:43 -04002499 proc_set_tty(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002500unlock:
Peter Hurley2c411c12014-10-16 14:59:47 -04002501 read_unlock(&tasklist_lock);
Peter Hurleye218eb32014-10-16 14:59:49 -04002502 tty_unlock(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002503 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504}
2505
Alan Coxaf9b8972006-08-27 01:24:01 -07002506/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002507 * tty_get_pgrp - return a ref counted pgrp pid
2508 * @tty: tty to read
2509 *
2510 * Returns a refcounted instance of the pid struct for the process
2511 * group controlling the tty.
2512 */
2513
2514struct pid *tty_get_pgrp(struct tty_struct *tty)
2515{
2516 unsigned long flags;
2517 struct pid *pgrp;
2518
2519 spin_lock_irqsave(&tty->ctrl_lock, flags);
2520 pgrp = get_pid(tty->pgrp);
2521 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2522
2523 return pgrp;
2524}
2525EXPORT_SYMBOL_GPL(tty_get_pgrp);
2526
Peter Hurleye1c22962014-10-16 14:59:48 -04002527/*
2528 * This checks not only the pgrp, but falls back on the pid if no
2529 * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
2530 * without this...
2531 *
2532 * The caller must hold rcu lock or the tasklist lock.
2533 */
2534static struct pid *session_of_pgrp(struct pid *pgrp)
2535{
2536 struct task_struct *p;
2537 struct pid *sid = NULL;
2538
2539 p = pid_task(pgrp, PIDTYPE_PGID);
2540 if (p == NULL)
2541 p = pid_task(pgrp, PIDTYPE_PID);
2542 if (p != NULL)
2543 sid = task_session(p);
2544
2545 return sid;
2546}
2547
Alan Cox5d0fdf12008-04-30 00:53:31 -07002548/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002549 * tiocgpgrp - get process group
2550 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002551 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002552 * @p: returned pid
2553 *
2554 * Obtain the process group of the tty. If there is no process group
2555 * return an error.
2556 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002557 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002558 */
2559
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2561{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002562 struct pid *pid;
2563 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 /*
2565 * (tty == real_tty) is a cheap way of
2566 * testing if the tty is NOT a master pty.
2567 */
2568 if (tty == real_tty && current->signal->tty != real_tty)
2569 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002570 pid = tty_get_pgrp(real_tty);
2571 ret = put_user(pid_vnr(pid), p);
2572 put_pid(pid);
2573 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574}
2575
Alan Coxaf9b8972006-08-27 01:24:01 -07002576/**
2577 * tiocspgrp - attempt to set process group
2578 * @tty: tty passed by user
2579 * @real_tty: tty side device matching tty passed by user
2580 * @p: pid pointer
2581 *
2582 * Set the process group of the tty to the session passed. Only
2583 * permitted where the tty session is our session.
2584 *
Alan Cox47f86832008-04-30 00:53:30 -07002585 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002586 */
2587
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2589{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002590 struct pid *pgrp;
2591 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 int retval = tty_check_change(real_tty);
2593
2594 if (retval == -EIO)
2595 return -ENOTTY;
2596 if (retval)
2597 return retval;
2598 if (!current->signal->tty ||
2599 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002600 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002602 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002604 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002606 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002607 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002608 retval = -ESRCH;
2609 if (!pgrp)
2610 goto out_unlock;
2611 retval = -EPERM;
2612 if (session_of_pgrp(pgrp) != task_session(current))
2613 goto out_unlock;
2614 retval = 0;
Peter Hurley1e86b5b2015-10-10 20:28:43 -04002615 spin_lock_irq(&tty->ctrl_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002616 put_pid(real_tty->pgrp);
2617 real_tty->pgrp = get_pid(pgrp);
Peter Hurley1e86b5b2015-10-10 20:28:43 -04002618 spin_unlock_irq(&tty->ctrl_lock);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002619out_unlock:
2620 rcu_read_unlock();
2621 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622}
2623
Alan Coxaf9b8972006-08-27 01:24:01 -07002624/**
2625 * tiocgsid - get session id
2626 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002627 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002628 * @p: pointer to returned session id
2629 *
2630 * Obtain the session id of the tty. If there is no session
2631 * return an error.
2632 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002633 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002634 */
2635
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2637{
2638 /*
2639 * (tty == real_tty) is a cheap way of
2640 * testing if the tty is NOT a master pty.
2641 */
2642 if (tty == real_tty && current->signal->tty != real_tty)
2643 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002644 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002646 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647}
2648
Alan Coxaf9b8972006-08-27 01:24:01 -07002649/**
2650 * tiocsetd - set line discipline
2651 * @tty: tty device
2652 * @p: pointer to user data
2653 *
2654 * Set the line discipline according to user request.
2655 *
2656 * Locking: see tty_set_ldisc, this function is just a helper
2657 */
2658
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659static int tiocsetd(struct tty_struct *tty, int __user *p)
2660{
Peter Hurleyc12da962016-01-10 22:41:04 -08002661 int disc;
Alan Cox04f378b2008-04-30 00:53:29 -07002662 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663
Peter Hurleyc12da962016-01-10 22:41:04 -08002664 if (get_user(disc, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002666
Peter Hurleyc12da962016-01-10 22:41:04 -08002667 ret = tty_set_ldisc(tty, disc);
Alan Cox04f378b2008-04-30 00:53:29 -07002668
2669 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670}
2671
Alan Coxaf9b8972006-08-27 01:24:01 -07002672/**
Peter Hurley5c17c862016-01-10 22:40:55 -08002673 * tiocgetd - get line discipline
2674 * @tty: tty device
2675 * @p: pointer to user data
2676 *
2677 * Retrieves the line discipline id directly from the ldisc.
2678 *
2679 * Locking: waits for ldisc reference (in case the line discipline
2680 * is changing or the tty is being hungup)
2681 */
2682
2683static int tiocgetd(struct tty_struct *tty, int __user *p)
2684{
2685 struct tty_ldisc *ld;
2686 int ret;
2687
2688 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002689 if (!ld)
2690 return -EIO;
Peter Hurley5c17c862016-01-10 22:40:55 -08002691 ret = put_user(ld->ops->num, p);
2692 tty_ldisc_deref(ld);
2693 return ret;
2694}
2695
2696/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002697 * send_break - performed time break
2698 * @tty: device to break on
2699 * @duration: timeout in mS
2700 *
2701 * Perform a timed break on hardware that lacks its own driver level
2702 * timed break functionality.
2703 *
2704 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002705 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002706 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002707 */
2708
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002709static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710{
Alan Cox9e989662008-07-22 11:18:03 +01002711 int retval;
2712
2713 if (tty->ops->break_ctl == NULL)
2714 return 0;
2715
2716 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2717 retval = tty->ops->break_ctl(tty, duration);
2718 else {
2719 /* Do the work ourselves */
2720 if (tty_write_lock(tty, 0) < 0)
2721 return -EINTR;
2722 retval = tty->ops->break_ctl(tty, -1);
2723 if (retval)
2724 goto out;
2725 if (!signal_pending(current))
2726 msleep_interruptible(duration);
2727 retval = tty->ops->break_ctl(tty, 0);
2728out:
2729 tty_write_unlock(tty);
2730 if (signal_pending(current))
2731 retval = -EINTR;
2732 }
2733 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734}
2735
Alan Coxaf9b8972006-08-27 01:24:01 -07002736/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002737 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002738 * @tty: tty device
2739 * @file: user file pointer
2740 * @p: pointer to result
2741 *
2742 * Obtain the modem status bits from the tty driver if the feature
2743 * is supported. Return -EINVAL if it is not available.
2744 *
2745 * Locking: none (up to the driver)
2746 */
2747
Alan Cox60b33c12011-02-14 16:26:14 +00002748static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749{
2750 int retval = -EINVAL;
2751
Alan Coxf34d7a52008-04-30 00:54:13 -07002752 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002753 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754
2755 if (retval >= 0)
2756 retval = put_user(retval, p);
2757 }
2758 return retval;
2759}
2760
Alan Coxaf9b8972006-08-27 01:24:01 -07002761/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002762 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002763 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002764 * @cmd: command - clear bits, set bits or set all
2765 * @p: pointer to desired bits
2766 *
2767 * Set the modem status bits from the tty driver if the feature
2768 * is supported. Return -EINVAL if it is not available.
2769 *
2770 * Locking: none (up to the driver)
2771 */
2772
Alan Cox20b9d172011-02-14 16:26:50 +00002773static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 unsigned __user *p)
2775{
Alan Coxae677512008-07-16 21:56:54 +01002776 int retval;
2777 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778
Alan Coxae677512008-07-16 21:56:54 +01002779 if (tty->ops->tiocmset == NULL)
2780 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781
Alan Coxae677512008-07-16 21:56:54 +01002782 retval = get_user(val, p);
2783 if (retval)
2784 return retval;
2785 set = clear = 0;
2786 switch (cmd) {
2787 case TIOCMBIS:
2788 set = val;
2789 break;
2790 case TIOCMBIC:
2791 clear = val;
2792 break;
2793 case TIOCMSET:
2794 set = val;
2795 clear = ~val;
2796 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 }
Alan Coxae677512008-07-16 21:56:54 +01002798 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2799 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002800 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801}
2802
Alan Coxd281da72010-09-16 18:21:24 +01002803static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2804{
2805 int retval = -EINVAL;
2806 struct serial_icounter_struct icount;
2807 memset(&icount, 0, sizeof(icount));
2808 if (tty->ops->get_icount)
2809 retval = tty->ops->get_icount(tty, &icount);
2810 if (retval != 0)
2811 return retval;
2812 if (copy_to_user(arg, &icount, sizeof(icount)))
2813 return -EFAULT;
2814 return 0;
2815}
2816
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002817static void tty_warn_deprecated_flags(struct serial_struct __user *ss)
2818{
2819 static DEFINE_RATELIMIT_STATE(depr_flags,
2820 DEFAULT_RATELIMIT_INTERVAL,
2821 DEFAULT_RATELIMIT_BURST);
2822 char comm[TASK_COMM_LEN];
2823 int flags;
2824
2825 if (get_user(flags, &ss->flags))
2826 return;
2827
2828 flags &= ASYNC_DEPRECATED;
2829
2830 if (flags && __ratelimit(&depr_flags))
2831 pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2832 __func__, get_task_comm(comm, current), flags);
2833}
2834
Peter Hurley8f166e02014-10-16 14:59:41 -04002835/*
2836 * if pty, return the slave side (real_tty)
2837 * otherwise, return self
2838 */
2839static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
Alan Coxe8b70e72009-06-11 12:48:02 +01002840{
2841 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2842 tty->driver->subtype == PTY_TYPE_MASTER)
2843 tty = tty->link;
2844 return tty;
2845}
Alan Coxe8b70e72009-06-11 12:48:02 +01002846
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847/*
2848 * Split this up, as gcc can choke on it otherwise..
2849 */
Alan Cox04f378b2008-04-30 00:53:29 -07002850long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851{
Nick Piggind996b622010-08-18 04:37:36 +10002852 struct tty_struct *tty = file_tty(file);
2853 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 void __user *p = (void __user *)arg;
2855 int retval;
2856 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002857
Al Viro6131ffa2013-02-27 16:59:05 -05002858 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859 return -EINVAL;
2860
Alan Coxe8b70e72009-06-11 12:48:02 +01002861 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862
2863 /*
2864 * Factor out some common prep work
2865 */
2866 switch (cmd) {
2867 case TIOCSETD:
2868 case TIOCSBRK:
2869 case TIOCCBRK:
2870 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002871 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 retval = tty_check_change(tty);
2873 if (retval)
2874 return retval;
2875 if (cmd != TIOCCBRK) {
2876 tty_wait_until_sent(tty, 0);
2877 if (signal_pending(current))
2878 return -EINTR;
2879 }
2880 break;
2881 }
2882
Alan Cox9e989662008-07-22 11:18:03 +01002883 /*
2884 * Now do the stuff.
2885 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002887 case TIOCSTI:
2888 return tiocsti(tty, p);
2889 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002890 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002891 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002892 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002893 case TIOCCONS:
2894 return real_tty != tty ? -EINVAL : tioccons(file);
2895 case FIONBIO:
2896 return fionbio(file, p);
2897 case TIOCEXCL:
2898 set_bit(TTY_EXCLUSIVE, &tty->flags);
2899 return 0;
2900 case TIOCNXCL:
2901 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2902 return 0;
Cyrill Gorcunov84fd7bd2012-10-24 23:43:22 +04002903 case TIOCGEXCL:
2904 {
2905 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2906 return put_user(excl, (int __user *)p);
2907 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002908 case TIOCNOTTY:
2909 if (current->signal->tty != tty)
2910 return -ENOTTY;
2911 no_tty();
2912 return 0;
2913 case TIOCSCTTY:
Peter Hurleyd1d3a0f2015-11-08 09:06:05 -05002914 return tiocsctty(real_tty, file, arg);
Alan Cox37bdfb02008-02-08 04:18:47 -08002915 case TIOCGPGRP:
2916 return tiocgpgrp(tty, real_tty, p);
2917 case TIOCSPGRP:
2918 return tiocspgrp(tty, real_tty, p);
2919 case TIOCGSID:
2920 return tiocgsid(tty, real_tty, p);
2921 case TIOCGETD:
Peter Hurley5c17c862016-01-10 22:40:55 -08002922 return tiocgetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002923 case TIOCSETD:
2924 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002925 case TIOCVHANGUP:
2926 if (!capable(CAP_SYS_ADMIN))
2927 return -EPERM;
2928 tty_vhangup(tty);
2929 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002930 case TIOCGDEV:
2931 {
2932 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2933 return put_user(ret, (unsigned int __user *)p);
2934 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002935 /*
2936 * Break handling
2937 */
2938 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002939 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002940 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002941 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002942 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002943 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002944 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002945 return 0;
2946 case TCSBRK: /* SVID version: non-zero arg --> no break */
2947 /* non-zero arg means wait for all output data
2948 * to be sent (performed above) but don't send break.
2949 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002951 if (!arg)
2952 return send_break(tty, 250);
2953 return 0;
2954 case TCSBRKP: /* support for POSIX tcsendbreak() */
2955 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956
Alan Cox37bdfb02008-02-08 04:18:47 -08002957 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002958 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002959 case TIOCMSET:
2960 case TIOCMBIC:
2961 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002962 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002963 case TIOCGICOUNT:
2964 retval = tty_tiocgicount(tty, p);
2965 /* For the moment allow fall through to the old method */
2966 if (retval != -EINVAL)
2967 return retval;
2968 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002969 case TCFLSH:
2970 switch (arg) {
2971 case TCIFLUSH:
2972 case TCIOFLUSH:
2973 /* flush tty buffer and allow ldisc to process ioctl */
Peter Hurley86c80a82014-11-05 12:13:09 -05002974 tty_buffer_flush(tty, NULL);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002975 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002976 }
2977 break;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002978 case TIOCSSERIAL:
2979 tty_warn_deprecated_flags(p);
2980 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002982 if (tty->ops->ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002983 retval = tty->ops->ioctl(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 if (retval != -ENOIOCTLCMD)
2985 return retval;
2986 }
2987 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002988 if (!ld)
2989 return hung_up_tty_ioctl(file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002991 if (ld->ops->ioctl) {
2992 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 if (retval == -ENOIOCTLCMD)
Wanlong Gaobbb63c52012-08-27 15:23:12 +08002994 retval = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 }
2996 tty_ldisc_deref(ld);
2997 return retval;
2998}
2999
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003000#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08003001static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003002 unsigned long arg)
3003{
Nick Piggind996b622010-08-18 04:37:36 +10003004 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003005 struct tty_ldisc *ld;
3006 int retval = -ENOIOCTLCMD;
3007
Al Viro6131ffa2013-02-27 16:59:05 -05003008 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003009 return -EINVAL;
3010
Alan Coxf34d7a52008-04-30 00:54:13 -07003011 if (tty->ops->compat_ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05003012 retval = tty->ops->compat_ioctl(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003013 if (retval != -ENOIOCTLCMD)
3014 return retval;
3015 }
3016
3017 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08003018 if (!ld)
3019 return hung_up_tty_compat_ioctl(file, cmd, arg);
Alan Coxa352def2008-07-16 21:53:12 +01003020 if (ld->ops->compat_ioctl)
3021 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Thomas Meyer8193c422011-10-05 23:13:13 +02003022 else
3023 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003024 tty_ldisc_deref(ld);
3025
3026 return retval;
3027}
3028#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029
Al Viroc3c073f2012-08-21 22:32:06 -04003030static int this_tty(const void *t, struct file *file, unsigned fd)
3031{
3032 if (likely(file->f_op->read != tty_read))
3033 return 0;
3034 return file_tty(file) != t ? 0 : fd + 1;
3035}
3036
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037/*
3038 * This implements the "Secure Attention Key" --- the idea is to
3039 * prevent trojan horses by killing all processes associated with this
3040 * tty when the user hits the "Secure Attention Key". Required for
3041 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08003042 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003043 * This code could be nicer; ideally it should send a HUP, wait a few
3044 * seconds, then send a INT, and then a KILL signal. But you then
3045 * have to coordinate with the init process, since all processes associated
3046 * with the current tty must be dead before the new getty is allowed
3047 * to spawn.
3048 *
3049 * Now, if it would be correct ;-/ The current code has a nasty hole -
3050 * it doesn't catch files in flight. We may send the descriptor to ourselves
3051 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3052 *
3053 * Nasty bug: do_SAK is being called in interrupt context. This can
3054 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3055 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08003056void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057{
3058#ifdef TTY_SOFT_SAK
3059 tty_hangup(tty);
3060#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08003061 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003062 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -08003064
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065 if (!tty)
3066 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003067 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08003068
Dan Carpenterb3f13de2006-12-13 00:35:09 -08003069 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070
Alan Coxf34d7a52008-04-30 00:54:13 -07003071 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08003072
Linus Torvalds1da177e2005-04-16 15:20:36 -07003073 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003074 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003075 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05003076 tty_notice(tty, "SAK: killed process %d (%s): by session\n",
3077 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003078 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003079 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Hurley9b42bb72015-11-08 13:01:14 -05003080
3081 /* Now kill any processes that happen to have the tty open */
Eric W. Biederman652486f2006-03-28 16:11:02 -08003082 do_each_thread(g, p) {
3083 if (p->signal->tty == tty) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05003084 tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n",
3085 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 send_sig(SIGKILL, p, 1);
3087 continue;
3088 }
3089 task_lock(p);
Al Viroc3c073f2012-08-21 22:32:06 -04003090 i = iterate_fd(p->files, 0, this_tty, tty);
3091 if (i != 0) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05003092 tty_notice(tty, "SAK: killed process %d (%s): by fd#%d\n",
3093 task_pid_nr(p), p->comm, i - 1);
Al Viroc3c073f2012-08-21 22:32:06 -04003094 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 }
3096 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003097 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098 read_unlock(&tasklist_lock);
3099#endif
3100}
3101
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08003102static void do_SAK_work(struct work_struct *work)
3103{
3104 struct tty_struct *tty =
3105 container_of(work, struct tty_struct, SAK_work);
3106 __do_SAK(tty);
3107}
3108
Linus Torvalds1da177e2005-04-16 15:20:36 -07003109/*
3110 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3111 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3112 * the values which we write to it will be identical to the values which it
3113 * already has. --akpm
3114 */
3115void do_SAK(struct tty_struct *tty)
3116{
3117 if (!tty)
3118 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119 schedule_work(&tty->SAK_work);
3120}
3121
3122EXPORT_SYMBOL(do_SAK);
3123
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08003124static int dev_match_devt(struct device *dev, const void *data)
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003125{
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08003126 const dev_t *devt = data;
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003127 return dev->devt == *devt;
3128}
3129
3130/* Must put_device() after it's unused! */
3131static struct device *tty_get_device(struct tty_struct *tty)
3132{
3133 dev_t devt = tty_devnum(tty);
3134 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
3135}
3136
3137
Alan Coxaf9b8972006-08-27 01:24:01 -07003138/**
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003139 * alloc_tty_struct
Alan Coxaf9b8972006-08-27 01:24:01 -07003140 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003141 * This subroutine allocates and initializes a tty structure.
Alan Coxaf9b8972006-08-27 01:24:01 -07003142 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003143 * Locking: none - tty in question is not exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003145
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003146struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147{
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003148 struct tty_struct *tty;
3149
3150 tty = kzalloc(sizeof(*tty), GFP_KERNEL);
3151 if (!tty)
3152 return NULL;
3153
Alan Cox9c9f4de2008-10-13 10:37:26 +01003154 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01003156 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003157 tty->session = NULL;
3158 tty->pgrp = NULL;
Alan Cox89c8d912012-08-08 16:30:13 +01003159 mutex_init(&tty->legacy_mutex);
Peter Hurleyd8c1f922013-06-15 09:14:31 -04003160 mutex_init(&tty->throttle_mutex);
Peter Hurley6a1c0682013-06-15 09:14:23 -04003161 init_rwsem(&tty->termios_rwsem);
Peter Hurleydee4a0b2013-07-24 16:43:51 -04003162 mutex_init(&tty->winsize_mutex);
Peter Hurley36697522013-06-15 07:04:48 -04003163 init_ldsem(&tty->ldisc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164 init_waitqueue_head(&tty->write_wait);
3165 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00003166 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08003167 mutex_init(&tty->atomic_write_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07003168 spin_lock_init(&tty->ctrl_lock);
Peter Hurleyf9e053d2014-09-10 15:06:31 -04003169 spin_lock_init(&tty->flow_lock);
Peter Hurley4a510962016-01-09 21:35:23 -08003170 spin_lock_init(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07003172 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01003173
3174 tty->driver = driver;
3175 tty->ops = driver->ops;
3176 tty->index = idx;
3177 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003178 tty->dev = tty_get_device(tty);
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003179
3180 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181}
3182
Alan Coxf34d7a52008-04-30 00:54:13 -07003183/**
3184 * tty_put_char - write one character to a tty
3185 * @tty: tty
3186 * @ch: character
3187 *
3188 * Write one byte to the tty using the provided put_char method
3189 * if present. Returns the number of characters successfully output.
3190 *
3191 * Note: the specific put_char operation in the driver layer may go
3192 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003194
Alan Coxf34d7a52008-04-30 00:54:13 -07003195int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196{
Alan Coxf34d7a52008-04-30 00:54:13 -07003197 if (tty->ops->put_char)
3198 return tty->ops->put_char(tty, ch);
3199 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200}
Alan Coxf34d7a52008-04-30 00:54:13 -07003201EXPORT_SYMBOL_GPL(tty_put_char);
3202
Alan Coxd81ed102008-10-13 10:41:42 +01003203struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003205static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3206 unsigned int index, unsigned int count)
3207{
Leon Yuc1a752b2015-09-07 13:08:37 +00003208 int err;
3209
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003210 /* init here, since reused cdevs cause crashes */
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003211 driver->cdevs[index] = cdev_alloc();
3212 if (!driver->cdevs[index])
3213 return -ENOMEM;
Leon Yuc1a752b2015-09-07 13:08:37 +00003214 driver->cdevs[index]->ops = &tty_fops;
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003215 driver->cdevs[index]->owner = driver->owner;
Leon Yuc1a752b2015-09-07 13:08:37 +00003216 err = cdev_add(driver->cdevs[index], dev, count);
3217 if (err)
3218 kobject_put(&driver->cdevs[index]->kobj);
3219 return err;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003220}
3221
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003223 * tty_register_device - register a tty device
3224 * @driver: the tty driver that describes the tty device
3225 * @index: the index in the tty driver for this tty device
3226 * @device: a struct device that is associated with this tty device.
3227 * This field is optional, if there is no known struct device
3228 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003230 * Returns a pointer to the struct device for this tty device
3231 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003232 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003233 * This call is required to be made to register an individual tty device
3234 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3235 * that bit is not set, this function should not be called by a tty
3236 * driver.
3237 *
3238 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003239 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003240
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003241struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3242 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243{
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003244 return tty_register_device_attr(driver, index, device, NULL, NULL);
3245}
3246EXPORT_SYMBOL(tty_register_device);
3247
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003248static void tty_device_create_release(struct device *dev)
3249{
Peter Hurley83db1df2015-11-08 13:01:21 -05003250 dev_dbg(dev, "releasing...\n");
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003251 kfree(dev);
3252}
3253
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003254/**
3255 * tty_register_device_attr - register a tty device
3256 * @driver: the tty driver that describes the tty device
3257 * @index: the index in the tty driver for this tty device
3258 * @device: a struct device that is associated with this tty device.
3259 * This field is optional, if there is no known struct device
3260 * for this tty device it can be set to NULL safely.
3261 * @drvdata: Driver data to be set to device.
3262 * @attr_grp: Attribute group to be set on device.
3263 *
3264 * Returns a pointer to the struct device for this tty device
3265 * (or ERR_PTR(-EFOO) on error).
3266 *
3267 * This call is required to be made to register an individual tty device
3268 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3269 * that bit is not set, this function should not be called by a tty
3270 * driver.
3271 *
3272 * Locking: ??
3273 */
3274struct device *tty_register_device_attr(struct tty_driver *driver,
3275 unsigned index, struct device *device,
3276 void *drvdata,
3277 const struct attribute_group **attr_grp)
3278{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 char name[64];
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003280 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3281 struct device *dev = NULL;
3282 int retval = -ENODEV;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003283 bool cdev = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284
3285 if (index >= driver->num) {
Peter Hurley656fb862015-11-08 13:01:15 -05003286 pr_err("%s: Attempt to register invalid tty line number (%d)\n",
3287 driver->name, index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003288 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 }
3290
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291 if (driver->type == TTY_DRIVER_TYPE_PTY)
3292 pty_line_name(driver, index, name);
3293 else
3294 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003295
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003296 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003297 retval = tty_cdev_add(driver, devt, index, 1);
3298 if (retval)
3299 goto error;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003300 cdev = true;
3301 }
3302
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003303 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3304 if (!dev) {
3305 retval = -ENOMEM;
3306 goto error;
3307 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003308
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003309 dev->devt = devt;
3310 dev->class = tty_class;
3311 dev->parent = device;
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003312 dev->release = tty_device_create_release;
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003313 dev_set_name(dev, "%s", name);
3314 dev->groups = attr_grp;
3315 dev_set_drvdata(dev, drvdata);
3316
3317 retval = device_register(dev);
3318 if (retval)
3319 goto error;
3320
3321 return dev;
3322
3323error:
3324 put_device(dev);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003325 if (cdev) {
3326 cdev_del(driver->cdevs[index]);
3327 driver->cdevs[index] = NULL;
3328 }
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003329 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003330}
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003331EXPORT_SYMBOL_GPL(tty_register_device_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332
3333/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003334 * tty_unregister_device - unregister a tty device
3335 * @driver: the tty driver that describes the tty device
3336 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003338 * If a tty device is registered with a call to tty_register_device() then
3339 * this function must be called when the tty device is gone.
3340 *
3341 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003343
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344void tty_unregister_device(struct tty_driver *driver, unsigned index)
3345{
Alan Cox37bdfb02008-02-08 04:18:47 -08003346 device_destroy(tty_class,
3347 MKDEV(driver->major, driver->minor_start) + index);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003348 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3349 cdev_del(driver->cdevs[index]);
3350 driver->cdevs[index] = NULL;
3351 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353EXPORT_SYMBOL(tty_unregister_device);
3354
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003355/**
3356 * __tty_alloc_driver -- allocate tty driver
3357 * @lines: count of lines this driver can handle at most
3358 * @owner: module which is repsonsible for this driver
3359 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3360 *
3361 * This should not be called directly, some of the provided macros should be
3362 * used instead. Use IS_ERR and friends on @retval.
3363 */
3364struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3365 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366{
3367 struct tty_driver *driver;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003368 unsigned int cdevs = 1;
Jiri Slaby16a02082012-08-08 22:26:42 +02003369 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370
Jiri Slaby0019b402012-08-08 22:26:43 +02003371 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003372 return ERR_PTR(-EINVAL);
3373
Jean Delvare506eb992007-07-15 23:40:14 -07003374 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003375 if (!driver)
3376 return ERR_PTR(-ENOMEM);
3377
3378 kref_init(&driver->kref);
3379 driver->magic = TTY_DRIVER_MAGIC;
3380 driver->num = lines;
3381 driver->owner = owner;
3382 driver->flags = flags;
Jiri Slaby16a02082012-08-08 22:26:42 +02003383
3384 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3385 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3386 GFP_KERNEL);
3387 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3388 GFP_KERNEL);
3389 if (!driver->ttys || !driver->termios) {
3390 err = -ENOMEM;
3391 goto err_free_all;
3392 }
3393 }
3394
3395 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3396 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3397 GFP_KERNEL);
3398 if (!driver->ports) {
3399 err = -ENOMEM;
3400 goto err_free_all;
3401 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003402 cdevs = lines;
3403 }
3404
3405 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3406 if (!driver->cdevs) {
3407 err = -ENOMEM;
3408 goto err_free_all;
Jiri Slaby16a02082012-08-08 22:26:42 +02003409 }
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003410
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411 return driver;
Jiri Slaby16a02082012-08-08 22:26:42 +02003412err_free_all:
3413 kfree(driver->ports);
3414 kfree(driver->ttys);
3415 kfree(driver->termios);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003416 kfree(driver->cdevs);
Jiri Slaby16a02082012-08-08 22:26:42 +02003417 kfree(driver);
3418 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419}
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003420EXPORT_SYMBOL(__tty_alloc_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421
Alan Cox7d7b93c2008-10-13 10:42:09 +01003422static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003424 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3425 int i;
3426 struct ktermios *tp;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003427
3428 if (driver->flags & TTY_DRIVER_INSTALLED) {
3429 /*
3430 * Free the termios and termios_locked structures because
3431 * we don't want to get memory leaks when modular tty
3432 * drivers are removed from the kernel.
3433 */
3434 for (i = 0; i < driver->num; i++) {
3435 tp = driver->termios[i];
3436 if (tp) {
3437 driver->termios[i] = NULL;
3438 kfree(tp);
3439 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003440 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3441 tty_unregister_device(driver, i);
3442 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003443 proc_tty_unregister_driver(driver);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003444 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003445 cdev_del(driver->cdevs[0]);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003446 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003447 kfree(driver->cdevs);
Jiri Slaby04831dc2012-06-04 13:35:36 +02003448 kfree(driver->ports);
Jiri Slaby16a02082012-08-08 22:26:42 +02003449 kfree(driver->termios);
3450 kfree(driver->ttys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003451 kfree(driver);
3452}
3453
Alan Cox7d7b93c2008-10-13 10:42:09 +01003454void tty_driver_kref_put(struct tty_driver *driver)
3455{
3456 kref_put(&driver->kref, destruct_tty_driver);
3457}
3458EXPORT_SYMBOL(tty_driver_kref_put);
3459
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003460void tty_set_operations(struct tty_driver *driver,
3461 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462{
Alan Coxf34d7a52008-04-30 00:54:13 -07003463 driver->ops = op;
3464};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003465EXPORT_SYMBOL(tty_set_operations);
3466
Alan Cox7d7b93c2008-10-13 10:42:09 +01003467void put_tty_driver(struct tty_driver *d)
3468{
3469 tty_driver_kref_put(d);
3470}
3471EXPORT_SYMBOL(put_tty_driver);
3472
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473/*
3474 * Called by a tty driver to register itself.
3475 */
3476int tty_register_driver(struct tty_driver *driver)
3477{
3478 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003479 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480 dev_t dev;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003481 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003484 error = alloc_chrdev_region(&dev, driver->minor_start,
3485 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003486 if (!error) {
3487 driver->major = MAJOR(dev);
3488 driver->minor_start = MINOR(dev);
3489 }
3490 } else {
3491 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003492 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 }
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003494 if (error < 0)
Jiri Slaby16a02082012-08-08 22:26:42 +02003495 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003497 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3498 error = tty_cdev_add(driver, dev, 0, driver->num);
3499 if (error)
3500 goto err_unreg_char;
3501 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003503 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003505 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003506
3507 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003508 for (i = 0; i < driver->num; i++) {
3509 d = tty_register_device(driver, i, NULL);
3510 if (IS_ERR(d)) {
3511 error = PTR_ERR(d);
Jiri Slaby16a02082012-08-08 22:26:42 +02003512 goto err_unreg_devs;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003513 }
3514 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515 }
3516 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003517 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003518 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003519
Jiri Slaby16a02082012-08-08 22:26:42 +02003520err_unreg_devs:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003521 for (i--; i >= 0; i--)
3522 tty_unregister_device(driver, i);
3523
3524 mutex_lock(&tty_mutex);
3525 list_del(&driver->tty_drivers);
3526 mutex_unlock(&tty_mutex);
3527
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003528err_unreg_char:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003529 unregister_chrdev_region(dev, driver->num);
Jiri Slaby16a02082012-08-08 22:26:42 +02003530err:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003531 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003532}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003533EXPORT_SYMBOL(tty_register_driver);
3534
3535/*
3536 * Called by a tty driver to unregister itself.
3537 */
3538int tty_unregister_driver(struct tty_driver *driver)
3539{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003540#if 0
3541 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003542 if (driver->refcount)
3543 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003544#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3546 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003547 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003548 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003549 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003550 return 0;
3551}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003552
Linus Torvalds1da177e2005-04-16 15:20:36 -07003553EXPORT_SYMBOL(tty_unregister_driver);
3554
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003555dev_t tty_devnum(struct tty_struct *tty)
3556{
3557 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3558}
3559EXPORT_SYMBOL(tty_devnum);
3560
Alan Coxd81ed102008-10-13 10:41:42 +01003561void tty_default_fops(struct file_operations *fops)
3562{
3563 *fops = tty_fops;
3564}
3565
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566/*
3567 * Initialize the console device. This is called *early*, so
3568 * we can't necessarily depend on lots of kernel help here.
3569 * Just do some early initializations, and do the complex setup
3570 * later.
3571 */
3572void __init console_init(void)
3573{
3574 initcall_t *call;
3575
3576 /* Setup the default TTY line discipline. */
Peter Hurley27228732016-01-09 21:35:19 -08003577 n_tty_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578
3579 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003580 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581 * inform about problems etc..
3582 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003583 call = __con_initcall_start;
3584 while (call < __con_initcall_end) {
3585 (*call)();
3586 call++;
3587 }
3588}
3589
Al Viro2c9ede52011-07-23 20:24:48 -04003590static char *tty_devnode(struct device *dev, umode_t *mode)
Kay Sieverse454cea2009-09-18 23:01:12 +02003591{
3592 if (!mode)
3593 return NULL;
3594 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3595 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3596 *mode = 0666;
3597 return NULL;
3598}
3599
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600static int __init tty_class_init(void)
3601{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003602 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603 if (IS_ERR(tty_class))
3604 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003605 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606 return 0;
3607}
3608
3609postcore_initcall(tty_class_init);
3610
3611/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003612static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003613
Kay Sieversfbc92a32010-12-01 18:51:05 +01003614static ssize_t show_cons_active(struct device *dev,
3615 struct device_attribute *attr, char *buf)
3616{
3617 struct console *cs[16];
3618 int i = 0;
3619 struct console *c;
3620 ssize_t count = 0;
3621
Torben Hohnac751ef2011-01-25 15:07:35 -08003622 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003623 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003624 if (!c->device)
3625 continue;
3626 if (!c->write)
3627 continue;
3628 if ((c->flags & CON_ENABLED) == 0)
3629 continue;
3630 cs[i++] = c;
3631 if (i >= ARRAY_SIZE(cs))
3632 break;
3633 }
Hannes Reinecke723abd82014-02-27 12:30:51 +01003634 while (i--) {
3635 int index = cs[i]->index;
3636 struct tty_driver *drv = cs[i]->device(cs[i], &index);
3637
3638 /* don't resolve tty0 as some programs depend on it */
3639 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
3640 count += tty_line_name(drv, index, buf + count);
3641 else
3642 count += sprintf(buf + count, "%s%d",
3643 cs[i]->name, cs[i]->index);
3644
3645 count += sprintf(buf + count, "%c", i ? ' ':'\n');
3646 }
Torben Hohnac751ef2011-01-25 15:07:35 -08003647 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003648
3649 return count;
3650}
3651static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3652
Takashi Iwai1083a7b2015-02-05 11:07:42 +01003653static struct attribute *cons_dev_attrs[] = {
3654 &dev_attr_active.attr,
3655 NULL
3656};
3657
3658ATTRIBUTE_GROUPS(cons_dev);
3659
Kay Sieversfbc92a32010-12-01 18:51:05 +01003660static struct device *consdev;
3661
3662void console_sysfs_notify(void)
3663{
3664 if (consdev)
3665 sysfs_notify(&consdev->kobj, NULL, "active");
3666}
3667
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668/*
3669 * Ok, now we can initialize the rest of the tty devices and can count
3670 * on memory allocations, interrupts etc..
3671 */
David Howells31d1d482010-08-06 16:34:43 +01003672int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003673{
3674 cdev_init(&tty_cdev, &tty_fops);
3675 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3676 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3677 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003678 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679
3680 cdev_init(&console_cdev, &console_fops);
3681 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3682 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3683 panic("Couldn't register /dev/console driver\n");
Takashi Iwai1083a7b2015-02-05 11:07:42 +01003684 consdev = device_create_with_groups(tty_class, NULL,
3685 MKDEV(TTYAUX_MAJOR, 1), NULL,
3686 cons_dev_groups, "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003687 if (IS_ERR(consdev))
3688 consdev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003689
Linus Torvalds1da177e2005-04-16 15:20:36 -07003690#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003691 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003692#endif
3693 return 0;
3694}
David Howells31d1d482010-08-06 16:34:43 +01003695