blob: 6267efa99bed98366d3dc5bead99cc3c758b0c97 [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) {
Miles Chen92060162018-10-08 10:39:17 +0800357 if (!len || strncmp(name, p->name, len) != 0)
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500358 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
Greg Kroah-Hartman9b7984e2019-01-21 17:26:42 +0100523extern void tty_sysctl_init(void);
524
Peter Hurley2c411c12014-10-16 14:59:47 -0400525/**
526 * proc_set_tty - set the controlling terminal
527 *
528 * Only callable by the session leader and only if it does not already have
529 * a controlling terminal.
530 *
Peter Hurleye218eb32014-10-16 14:59:49 -0400531 * Caller must hold: tty_lock()
532 * a readlock on tasklist_lock
Peter Hurley2c411c12014-10-16 14:59:47 -0400533 * sighand lock
534 */
Peter Hurleybce65f12014-10-16 14:59:43 -0400535static void __proc_set_tty(struct tty_struct *tty)
Peter Hurley11d9bef2014-10-16 14:59:42 -0400536{
Peter Hurleyae28fa72014-10-16 14:59:46 -0400537 unsigned long flags;
538
Peter Hurleyae28fa72014-10-16 14:59:46 -0400539 spin_lock_irqsave(&tty->ctrl_lock, flags);
Peter Hurleya3618582014-10-16 14:59:50 -0400540 /*
541 * The session and fg pgrp references will be non-NULL if
542 * tiocsctty() is stealing the controlling tty
543 */
Peter Hurleyae28fa72014-10-16 14:59:46 -0400544 put_pid(tty->session);
545 put_pid(tty->pgrp);
546 tty->pgrp = get_pid(task_pgrp(current));
547 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
548 tty->session = get_pid(task_session(current));
549 if (current->signal->tty) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -0400550 tty_debug(tty, "current tty %s not NULL!!\n",
551 current->signal->tty->name);
Peter Hurleyae28fa72014-10-16 14:59:46 -0400552 tty_kref_put(current->signal->tty);
Peter Hurley11d9bef2014-10-16 14:59:42 -0400553 }
Peter Hurleybce65f12014-10-16 14:59:43 -0400554 put_pid(current->signal->tty_old_pgrp);
555 current->signal->tty = tty_kref_get(tty);
556 current->signal->tty_old_pgrp = NULL;
Peter Hurley11d9bef2014-10-16 14:59:42 -0400557}
558
Peter Hurleybce65f12014-10-16 14:59:43 -0400559static void proc_set_tty(struct tty_struct *tty)
Peter Hurley11d9bef2014-10-16 14:59:42 -0400560{
Peter Hurleybce65f12014-10-16 14:59:43 -0400561 spin_lock_irq(&current->sighand->siglock);
562 __proc_set_tty(tty);
563 spin_unlock_irq(&current->sighand->siglock);
Peter Hurley11d9bef2014-10-16 14:59:42 -0400564}
565
566struct tty_struct *get_current_tty(void)
567{
568 struct tty_struct *tty;
569 unsigned long flags;
570
571 spin_lock_irqsave(&current->sighand->siglock, flags);
572 tty = tty_kref_get(current->signal->tty);
573 spin_unlock_irqrestore(&current->sighand->siglock, flags);
574 return tty;
575}
576EXPORT_SYMBOL_GPL(get_current_tty);
577
578static void session_clear_tty(struct pid *session)
579{
580 struct task_struct *p;
581 do_each_pid_task(session, PIDTYPE_SID, p) {
582 proc_clear_tty(p);
583 } while_each_pid_task(session, PIDTYPE_SID, p);
584}
585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586/**
587 * tty_wakeup - request more data
588 * @tty: terminal
589 *
590 * Internal and external helper for wakeups of tty. This function
591 * informs the line discipline if present that the driver is ready
592 * to receive more output data.
593 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595void tty_wakeup(struct tty_struct *tty)
596{
597 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
600 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800601 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100602 if (ld->ops->write_wakeup)
603 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 tty_ldisc_deref(ld);
605 }
606 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700607 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
609
610EXPORT_SYMBOL_GPL(tty_wakeup);
611
612/**
Peter Hurleyea648a42013-03-06 07:20:53 -0500613 * tty_signal_session_leader - sends SIGHUP to session leader
Peter Hurleyf91e2592013-03-06 07:20:56 -0500614 * @tty controlling tty
615 * @exit_session if non-zero, signal all foreground group processes
Peter Hurleyea648a42013-03-06 07:20:53 -0500616 *
Peter Hurleyf91e2592013-03-06 07:20:56 -0500617 * Send SIGHUP and SIGCONT to the session leader and its process group.
618 * Optionally, signal all processes in the foreground process group.
Peter Hurleyea648a42013-03-06 07:20:53 -0500619 *
620 * Returns the number of processes in the session with this tty
621 * as their controlling terminal. This value is used to drop
622 * tty references for those processes.
623 */
Peter Hurleyf91e2592013-03-06 07:20:56 -0500624static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)
Peter Hurleyea648a42013-03-06 07:20:53 -0500625{
626 struct task_struct *p;
Peter Hurleyea648a42013-03-06 07:20:53 -0500627 int refs = 0;
Peter Hurleyf91e2592013-03-06 07:20:56 -0500628 struct pid *tty_pgrp = NULL;
Peter Hurleyea648a42013-03-06 07:20:53 -0500629
630 read_lock(&tasklist_lock);
631 if (tty->session) {
632 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
633 spin_lock_irq(&p->sighand->siglock);
634 if (p->signal->tty == tty) {
635 p->signal->tty = NULL;
636 /* We defer the dereferences outside fo
637 the tasklist lock */
638 refs++;
639 }
640 if (!p->signal->leader) {
641 spin_unlock_irq(&p->sighand->siglock);
642 continue;
643 }
644 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
645 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
646 put_pid(p->signal->tty_old_pgrp); /* A noop */
Peter Hurleybc30c3b2013-03-06 07:20:55 -0500647 spin_lock(&tty->ctrl_lock);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500648 tty_pgrp = get_pid(tty->pgrp);
Peter Hurleyea648a42013-03-06 07:20:53 -0500649 if (tty->pgrp)
650 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Peter Hurleybc30c3b2013-03-06 07:20:55 -0500651 spin_unlock(&tty->ctrl_lock);
Peter Hurleyea648a42013-03-06 07:20:53 -0500652 spin_unlock_irq(&p->sighand->siglock);
653 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
654 }
655 read_unlock(&tasklist_lock);
656
Peter Hurleyf91e2592013-03-06 07:20:56 -0500657 if (tty_pgrp) {
658 if (exit_session)
659 kill_pgrp(tty_pgrp, SIGHUP, exit_session);
660 put_pid(tty_pgrp);
661 }
662
Peter Hurleyea648a42013-03-06 07:20:53 -0500663 return refs;
664}
665
666/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200667 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000668 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700669 *
Kevin Cernekeeef4f5272012-12-26 20:43:41 -0800670 * This can be called by a "kworker" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700671 * synchronous but doesn't hold any locks, so we need to make sure we
672 * have the appropriate locks for what we're doing.
673 *
674 * The hangup event clears any pending redirections onto the hung up
675 * device. It ensures future writes will error and it does the needed
676 * line discipline hangup and signal delivery. The tty object itself
677 * remains intact.
678 *
679 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200680 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800681 * redirect lock for undoing redirection
682 * file list lock for manipulating list of ttys
Peter Hurley137084b2013-06-15 07:04:46 -0400683 * tty_ldiscs_lock from called functions
Peter Hurley6a1c0682013-06-15 09:14:23 -0400684 * termios_rwsem resetting termios data
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800685 * tasklist_lock to walk task list for hangup event
686 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 */
Peter Hurleyf91e2592013-03-06 07:20:56 -0500688static void __tty_hangup(struct tty_struct *tty, int exit_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689{
Alan Cox37bdfb02008-02-08 04:18:47 -0800690 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 struct file *filp, *f = NULL;
Nick Piggind996b622010-08-18 04:37:36 +1000692 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 int closecount = 0, n;
Peter Hurleyea648a42013-03-06 07:20:53 -0500694 int refs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 if (!tty)
697 return;
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000701 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 f = redirect;
703 redirect = NULL;
704 }
705 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800706
Alan Cox89c8d912012-08-08 16:30:13 +0100707 tty_lock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200708
Peter Hurleycb50e522013-07-31 14:05:45 -0400709 if (test_bit(TTY_HUPPED, &tty->flags)) {
710 tty_unlock(tty);
711 return;
712 }
713
Tejun Heoa7e19062018-02-13 07:38:08 -0800714 /*
715 * Some console devices aren't actually hung up for technical and
716 * historical reasons, which can lead to indefinite interruptible
717 * sleep in n_tty_read(). The following explicitly tells
718 * n_tty_read() to abort readers.
719 */
720 set_bit(TTY_HUPPING, &tty->flags);
721
Arnd Bergmannec79d602010-06-01 22:53:01 +0200722 /* inuse_filps is protected by the single tty lock,
723 this really needs to change if we want to flush the
724 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200725 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000726
Peter Hurley4a510962016-01-09 21:35:23 -0800727 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000729 list_for_each_entry(priv, &tty->tty_files, list) {
730 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 if (filp->f_op->write == redirected_tty_write)
732 cons_filp = filp;
733 if (filp->f_op->write != tty_write)
734 continue;
735 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200736 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 filp->f_op = &hung_up_tty_fops;
738 }
Peter Hurley4a510962016-01-09 21:35:23 -0800739 spin_unlock(&tty->files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800740
Peter Hurley25fdf242013-03-06 07:20:57 -0500741 refs = tty_signal_session_leader(tty, exit_session);
742 /* Account for the p->signal references we killed */
743 while (refs--)
744 tty_kref_put(tty);
745
Peter Hurley892d1fa2016-01-10 22:41:06 -0800746 tty_ldisc_hangup(tty, cons_filp != NULL);
Alan Cox37bdfb02008-02-08 04:18:47 -0800747
Peter Hurley20cc2252013-03-06 07:20:54 -0500748 spin_lock_irq(&tty->ctrl_lock);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100749 clear_bit(TTY_THROTTLED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100750 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600751 put_pid(tty->session);
752 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800753 tty->session = NULL;
754 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 tty->ctrl_status = 0;
Peter Hurley20cc2252013-03-06 07:20:54 -0500756 spin_unlock_irq(&tty->ctrl_lock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100757
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800759 * If one of the devices matches a console pointer, we
760 * cannot just call hangup() because that will cause
761 * tty->count and state->count to go out of sync.
762 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 */
764 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700765 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700767 tty->ops->close(tty, cons_filp);
768 } else if (tty->ops->hangup)
Peter Hurley7c6d3402014-06-16 09:17:08 -0400769 tty->ops->hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800770 /*
Peter Hurley892d1fa2016-01-10 22:41:06 -0800771 * We don't want to have driver/ldisc interactions beyond the ones
772 * we did here. The driver layer expects no calls after ->hangup()
773 * from the ldisc side, which is now guaranteed.
Alan Cox37bdfb02008-02-08 04:18:47 -0800774 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 set_bit(TTY_HUPPED, &tty->flags);
Tejun Heoa7e19062018-02-13 07:38:08 -0800776 clear_bit(TTY_HUPPING, &tty->flags);
Alan Cox89c8d912012-08-08 16:30:13 +0100777 tty_unlock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200778
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 if (f)
780 fput(f);
781}
782
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200783static void do_tty_hangup(struct work_struct *work)
784{
785 struct tty_struct *tty =
786 container_of(work, struct tty_struct, hangup_work);
787
Peter Hurleyf91e2592013-03-06 07:20:56 -0500788 __tty_hangup(tty, 0);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200789}
790
Alan Coxaf9b8972006-08-27 01:24:01 -0700791/**
792 * tty_hangup - trigger a hangup event
793 * @tty: tty to hangup
794 *
795 * A carrier loss (virtual or otherwise) has occurred on this like
796 * schedule a hangup sequence to run after this event.
797 */
798
Alan Cox37bdfb02008-02-08 04:18:47 -0800799void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500801 tty_debug_hangup(tty, "hangup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 schedule_work(&tty->hangup_work);
803}
804
805EXPORT_SYMBOL(tty_hangup);
806
Alan Coxaf9b8972006-08-27 01:24:01 -0700807/**
808 * tty_vhangup - process vhangup
809 * @tty: tty to hangup
810 *
811 * The user has asked via system call for the terminal to be hung up.
812 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200813 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700814 */
815
Alan Cox37bdfb02008-02-08 04:18:47 -0800816void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500818 tty_debug_hangup(tty, "vhangup\n");
Peter Hurleyf91e2592013-03-06 07:20:56 -0500819 __tty_hangup(tty, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820}
Alan Cox37bdfb02008-02-08 04:18:47 -0800821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822EXPORT_SYMBOL(tty_vhangup);
823
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200824
Alan Coxaf9b8972006-08-27 01:24:01 -0700825/**
Alan Cox2cb59982008-10-13 10:40:30 +0100826 * tty_vhangup_self - process vhangup for own ctty
827 *
828 * Perform a vhangup on the current controlling tty
829 */
830
831void tty_vhangup_self(void)
832{
833 struct tty_struct *tty;
834
Alan Cox2cb59982008-10-13 10:40:30 +0100835 tty = get_current_tty();
836 if (tty) {
837 tty_vhangup(tty);
838 tty_kref_put(tty);
839 }
Alan Cox2cb59982008-10-13 10:40:30 +0100840}
841
842/**
Peter Hurleyf91e2592013-03-06 07:20:56 -0500843 * tty_vhangup_session - hangup session leader exit
844 * @tty: tty to hangup
845 *
846 * The session leader is exiting and hanging up its controlling terminal.
847 * Every process in the foreground process group is signalled SIGHUP.
848 *
849 * We do this synchronously so that when the syscall returns the process
850 * is complete. That guarantee is necessary for security reasons.
851 */
852
Changlong Xie44a459f2013-03-20 08:42:04 +0800853static void tty_vhangup_session(struct tty_struct *tty)
Peter Hurleyf91e2592013-03-06 07:20:56 -0500854{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500855 tty_debug_hangup(tty, "session hangup\n");
Peter Hurleyf91e2592013-03-06 07:20:56 -0500856 __tty_hangup(tty, 1);
857}
858
859/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700860 * tty_hung_up_p - was tty hung up
861 * @filp: file pointer of tty
862 *
863 * Return true if the tty has been subject to a vhangup or a carrier
864 * loss
865 */
866
Alan Cox37bdfb02008-02-08 04:18:47 -0800867int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868{
869 return (filp->f_op == &hung_up_tty_fops);
870}
871
872EXPORT_SYMBOL(tty_hung_up_p);
873
Alan Coxaf9b8972006-08-27 01:24:01 -0700874/**
875 * disassociate_ctty - disconnect controlling tty
876 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700878 * This function is typically called only by the session leader, when
879 * it wants to disassociate itself from its controlling tty.
880 *
881 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
883 * (2) Clears the tty from being controlling the session
884 * (3) Clears the controlling tty for all processes in the
885 * session group.
886 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700887 * The argument on_exit is set to 1 if called when a process is
888 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
889 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800890 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200891 * BTM is taken for hysterical raisins, and held when
892 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800893 * tty_mutex is taken to protect tty
894 * ->siglock is taken to protect ->signal/->sighand
895 * tasklist_lock is taken to walk process list for sessions
896 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700898
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899void disassociate_ctty(int on_exit)
900{
901 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
Alan Cox5ec93d12009-11-30 13:18:45 +0000903 if (!current->signal->leader)
904 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800906 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 if (tty) {
Peter Hurleyf91e2592013-03-06 07:20:56 -0500908 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {
909 tty_vhangup_session(tty);
910 } else {
911 struct pid *tty_pgrp = tty_get_pgrp(tty);
912 if (tty_pgrp) {
913 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Oleg Nesterov03e12612013-09-15 17:50:26 +0200914 if (!on_exit)
915 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500916 put_pid(tty_pgrp);
917 }
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200918 }
Alan Cox452a00d2008-10-13 10:39:13 +0100919 tty_kref_put(tty);
Peter Hurleyf91e2592013-03-06 07:20:56 -0500920
Eric W. Biederman680a9672007-02-12 00:52:52 -0800921 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800922 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800923 spin_lock_irq(&current->sighand->siglock);
924 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800925 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800926 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800927 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800928 kill_pgrp(old_pgrp, SIGHUP, on_exit);
929 kill_pgrp(old_pgrp, SIGCONT, on_exit);
930 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 return;
933 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800935 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700936 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800937 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800938
Chen Tingjiec70dbb12014-04-15 11:52:51 +0800939 tty = tty_kref_get(current->signal->tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800940 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700941 unsigned long flags;
942 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800943 put_pid(tty->session);
944 put_pid(tty->pgrp);
945 tty->session = NULL;
946 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700947 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100948 tty_kref_put(tty);
Peter Hurleyaccff792015-07-12 22:49:09 -0400949 } else
950 tty_debug_hangup(tty, "no current tty\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951
Chen Tingjiec70dbb12014-04-15 11:52:51 +0800952 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 /* Now clear signal->tty under the lock */
954 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800955 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957}
958
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700959/**
960 *
961 * no_tty - Ensure the current process does not have a controlling tty
962 */
963void no_tty(void)
964{
Alan Cox3af502b2012-05-03 22:21:53 +0100965 /* FIXME: Review locking here. The tty_lock never covered any race
966 between a new association and proc_clear_tty but possible we need
967 to protect against this anyway */
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700968 struct task_struct *tsk = current;
Alan Cox5ec93d12009-11-30 13:18:45 +0000969 disassociate_ctty(0);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700970 proc_clear_tty(tsk);
971}
972
Alan Coxaf9b8972006-08-27 01:24:01 -0700973
974/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200975 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700976 * @tty: tty to stop
977 *
Peter Hurley01adc802014-09-10 15:06:32 -0400978 * Perform flow control to the driver. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700979 * on an already stopped device and will not re-call the driver
980 * method.
981 *
982 * This functionality is used by both the line disciplines for
983 * halting incoming flow and by the driver. It may therefore be
984 * called from any context, may be under the tty atomic_write_lock
985 * but not always.
986 *
987 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400988 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700989 */
990
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400991void __stop_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992{
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400993 if (tty->stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 return;
995 tty->stopped = 1;
Alan Coxf34d7a52008-04-30 00:54:13 -0700996 if (tty->ops->stop)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500997 tty->ops->stop(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998}
999
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001000void stop_tty(struct tty_struct *tty)
1001{
1002 unsigned long flags;
1003
1004 spin_lock_irqsave(&tty->flow_lock, flags);
1005 __stop_tty(tty);
1006 spin_unlock_irqrestore(&tty->flow_lock, flags);
1007}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008EXPORT_SYMBOL(stop_tty);
1009
Alan Coxaf9b8972006-08-27 01:24:01 -07001010/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +02001011 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -07001012 * @tty: tty to start
1013 *
Peter Hurley01adc802014-09-10 15:06:32 -04001014 * Start a tty that has been stopped if at all possible. If this
1015 * tty was previous stopped and is now being started, the driver
1016 * start method is invoked and the line discipline woken.
Alan Coxaf9b8972006-08-27 01:24:01 -07001017 *
1018 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001019 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -07001020 */
1021
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001022void __start_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023{
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001024 if (!tty->stopped || tty->flow_stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 return;
1026 tty->stopped = 0;
Alan Coxf34d7a52008-04-30 00:54:13 -07001027 if (tty->ops->start)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05001028 tty->ops->start(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030}
1031
Peter Hurleyf9e053d2014-09-10 15:06:31 -04001032void start_tty(struct tty_struct *tty)
1033{
1034 unsigned long flags;
1035
1036 spin_lock_irqsave(&tty->flow_lock, flags);
1037 __start_tty(tty);
1038 spin_unlock_irqrestore(&tty->flow_lock, flags);
1039}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040EXPORT_SYMBOL(start_tty);
1041
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001042static void tty_update_time(struct timespec *time)
1043{
Jiri Slabyf0bf0bd2015-02-27 18:40:31 +01001044 unsigned long sec = get_seconds();
Greg Kroah-Hartmanfbf47632015-03-26 23:10:27 +01001045
1046 /*
1047 * We only care if the two values differ in anything other than the
1048 * lower three bits (i.e every 8 seconds). If so, then we can update
1049 * the time of the tty device, otherwise it could be construded as a
1050 * security leak to let userspace know the exact timing of the tty.
1051 */
1052 if ((sec ^ time->tv_sec) & ~7)
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001053 time->tv_sec = sec;
1054}
1055
Alan Coxaf9b8972006-08-27 01:24:01 -07001056/**
1057 * tty_read - read method for tty device files
1058 * @file: pointer to tty file
1059 * @buf: user buffer
1060 * @count: size of user buffer
1061 * @ppos: unused
1062 *
1063 * Perform the read system call function on this terminal device. Checks
1064 * for hung up devices before calling the line discipline method.
1065 *
1066 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -07001067 * Locks the line discipline internally while needed. Multiple
1068 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -07001069 */
1070
Alan Cox37bdfb02008-02-08 04:18:47 -08001071static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 loff_t *ppos)
1073{
1074 int i;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001075 struct inode *inode = file_inode(file);
Nick Piggind996b622010-08-18 04:37:36 +10001076 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 struct tty_ldisc *ld;
1078
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001079 if (tty_paranoia_check(tty, inode, "tty_read"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 return -EIO;
Peter Hurley18900ca2016-04-09 17:06:48 -07001081 if (!tty || tty_io_error(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 return -EIO;
1083
1084 /* We want to wait for the line discipline to sort out in this
1085 situation */
1086 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08001087 if (!ld)
1088 return hung_up_tty_read(file, buf, count, ppos);
Alan Coxa352def2008-07-16 21:53:12 +01001089 if (ld->ops->read)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05001090 i = ld->ops->read(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 else
1092 i = -EIO;
1093 tty_ldisc_deref(ld);
Jiri Slabyb0de59b2013-02-15 15:25:05 +01001094
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001095 if (i > 0)
1096 tty_update_time(&inode->i_atime);
1097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 return i;
1099}
1100
Peter Hurley136d5252014-09-10 15:06:34 -04001101static void tty_write_unlock(struct tty_struct *tty)
Alan Cox9c1729d2007-07-15 23:39:43 -07001102{
1103 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -07001104 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -07001105}
1106
Peter Hurley136d5252014-09-10 15:06:34 -04001107static int tty_write_lock(struct tty_struct *tty, int ndelay)
Alan Cox9c1729d2007-07-15 23:39:43 -07001108{
1109 if (!mutex_trylock(&tty->atomic_write_lock)) {
1110 if (ndelay)
1111 return -EAGAIN;
1112 if (mutex_lock_interruptible(&tty->atomic_write_lock))
1113 return -ERESTARTSYS;
1114 }
1115 return 0;
1116}
1117
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118/*
1119 * Split writes up in sane blocksizes to avoid
1120 * denial-of-service type attacks
1121 */
1122static inline ssize_t do_tty_write(
1123 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1124 struct tty_struct *tty,
1125 struct file *file,
1126 const char __user *buf,
1127 size_t count)
1128{
Alan Cox9c1729d2007-07-15 23:39:43 -07001129 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -08001131
Alan Cox9c1729d2007-07-15 23:39:43 -07001132 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1133 if (ret < 0)
1134 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135
1136 /*
1137 * We chunk up writes into a temporary buffer. This
1138 * simplifies low-level drivers immensely, since they
1139 * don't have locking issues and user mode accesses.
1140 *
1141 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1142 * big chunk-size..
1143 *
1144 * The default chunk-size is 2kB, because the NTTY
1145 * layer has problems with bigger chunks. It will
1146 * claim to be able to handle more characters than
1147 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001148 *
1149 * FIXME: This can probably go away now except that 64K chunks
1150 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 */
1152 chunk = 2048;
1153 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1154 chunk = 65536;
1155 if (count < chunk)
1156 chunk = count;
1157
Ingo Molnar70522e12006-03-23 03:00:31 -08001158 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001160 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 if (chunk < 1024)
1163 chunk = 1024;
1164
Jason Wessel402fda92008-10-13 10:45:36 +01001165 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1166 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001167 ret = -ENOMEM;
1168 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 }
1170 kfree(tty->write_buf);
1171 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001172 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 }
1174
1175 /* Do the write .. */
1176 for (;;) {
1177 size_t size = count;
1178 if (size > chunk)
1179 size = chunk;
1180 ret = -EFAULT;
1181 if (copy_from_user(tty->write_buf, buf, size))
1182 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 if (ret <= 0)
1185 break;
1186 written += ret;
1187 buf += ret;
1188 count -= ret;
1189 if (!count)
1190 break;
1191 ret = -ERESTARTSYS;
1192 if (signal_pending(current))
1193 break;
1194 cond_resched();
1195 }
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001196 if (written) {
1197 tty_update_time(&file_inode(file)->i_mtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 ret = written;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +02001199 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001200out:
1201 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 return ret;
1203}
1204
Alan Cox95f9bfc2008-10-13 10:39:23 +01001205/**
1206 * tty_write_message - write a message to a certain tty, not just the console.
1207 * @tty: the destination tty_struct
1208 * @msg: the message to write
1209 *
1210 * This is used for messages that need to be redirected to a specific tty.
1211 * We don't put it into the syslog queue right now maybe in the future if
1212 * really needed.
1213 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001214 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001215 */
1216
1217void tty_write_message(struct tty_struct *tty, char *msg)
1218{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001219 if (tty) {
1220 mutex_lock(&tty->atomic_write_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01001221 tty_lock(tty);
Peter Hurley4b41b952015-10-10 20:28:44 -04001222 if (tty->ops->write && tty->count > 0)
Alan Cox95f9bfc2008-10-13 10:39:23 +01001223 tty->ops->write(tty, msg, strlen(msg));
Peter Hurley4b41b952015-10-10 20:28:44 -04001224 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001225 tty_write_unlock(tty);
1226 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001227 return;
1228}
1229
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Alan Coxaf9b8972006-08-27 01:24:01 -07001231/**
1232 * tty_write - write method for tty device file
1233 * @file: tty file pointer
1234 * @buf: user data to write
1235 * @count: bytes to write
1236 * @ppos: unused
1237 *
1238 * Write data to a tty device via the line discipline.
1239 *
1240 * Locking:
1241 * Locks the line discipline as required
1242 * Writes to the tty driver are serialized by the atomic_write_lock
1243 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001244 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001245 */
1246
Alan Cox37bdfb02008-02-08 04:18:47 -08001247static ssize_t tty_write(struct file *file, const char __user *buf,
1248 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249{
Nick Piggind996b622010-08-18 04:37:36 +10001250 struct tty_struct *tty = file_tty(file);
1251 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001253
Al Viro6131ffa2013-02-27 16:59:05 -05001254 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 return -EIO;
Peter Hurley18900ca2016-04-09 17:06:48 -07001256 if (!tty || !tty->ops->write || tty_io_error(tty))
Alan Cox37bdfb02008-02-08 04:18:47 -08001257 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001258 /* Short term debug to catch buggy drivers */
1259 if (tty->ops->write_room == NULL)
Peter Hurley339f36b2015-11-08 13:01:13 -05001260 tty_err(tty, "missing write_room method\n");
Alan Cox37bdfb02008-02-08 04:18:47 -08001261 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08001262 if (!ld)
1263 return hung_up_tty_write(file, buf, count, ppos);
Alan Coxa352def2008-07-16 21:53:12 +01001264 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 ret = -EIO;
1266 else
Alan Coxa352def2008-07-16 21:53:12 +01001267 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 tty_ldisc_deref(ld);
1269 return ret;
1270}
1271
Alan Cox37bdfb02008-02-08 04:18:47 -08001272ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1273 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274{
1275 struct file *p = NULL;
1276
1277 spin_lock(&redirect_lock);
Al Virocb0942b2012-08-27 14:48:26 -04001278 if (redirect)
1279 p = get_file(redirect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 spin_unlock(&redirect_lock);
1281
1282 if (p) {
1283 ssize_t res;
1284 res = vfs_write(p, buf, count, &p->f_pos);
1285 fput(p);
1286 return res;
1287 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 return tty_write(file, buf, count, ppos);
1289}
1290
Peter Hurley136d5252014-09-10 15:06:34 -04001291/**
1292 * tty_send_xchar - send priority character
1293 *
1294 * Send a high priority character to the tty even if stopped
1295 *
1296 * Locking: none for xchar method, write ordering for write method.
1297 */
1298
1299int tty_send_xchar(struct tty_struct *tty, char ch)
1300{
1301 int was_stopped = tty->stopped;
1302
1303 if (tty->ops->send_xchar) {
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001304 down_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001305 tty->ops->send_xchar(tty, ch);
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001306 up_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001307 return 0;
1308 }
1309
1310 if (tty_write_lock(tty, 0) < 0)
1311 return -ERESTARTSYS;
1312
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001313 down_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001314 if (was_stopped)
1315 start_tty(tty);
1316 tty->ops->write(tty, &ch, 1);
1317 if (was_stopped)
1318 stop_tty(tty);
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001319 up_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001320 tty_write_unlock(tty);
1321 return 0;
1322}
1323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324static char ptychar[] = "pqrstuvwxyzabcde";
1325
Alan Coxaf9b8972006-08-27 01:24:01 -07001326/**
1327 * pty_line_name - generate name for a pty
1328 * @driver: the tty driver in use
1329 * @index: the minor number
1330 * @p: output buffer of at least 6 bytes
1331 *
1332 * Generate a name from a driver reference and write it to the output
1333 * buffer.
1334 *
1335 * Locking: None
1336 */
1337static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338{
1339 int i = index + driver->name_base;
1340 /* ->name is initialized to "ttyp", but "tty" is expected */
1341 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001342 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1343 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344}
1345
Alan Coxaf9b8972006-08-27 01:24:01 -07001346/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001347 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001348 * @driver: the tty driver in use
1349 * @index: the minor number
1350 * @p: output buffer of at least 7 bytes
1351 *
1352 * Generate a name from a driver reference and write it to the output
Greg Kroah-Hartman5c0a2452014-02-22 14:31:04 -08001353 * buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07001354 *
1355 * Locking: None
1356 */
Hannes Reinecke723abd82014-02-27 12:30:51 +01001357static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358{
Jiri Slaby0019b402012-08-08 22:26:43 +02001359 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
Hannes Reinecke723abd82014-02-27 12:30:51 +01001360 return sprintf(p, "%s", driver->name);
Jiri Slaby0019b402012-08-08 22:26:43 +02001361 else
Hannes Reinecke723abd82014-02-27 12:30:51 +01001362 return sprintf(p, "%s%d", driver->name,
1363 index + driver->name_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364}
1365
Alan Cox99f1fe12008-10-13 10:42:00 +01001366/**
1367 * tty_driver_lookup_tty() - find an existing tty, if any
1368 * @driver: the driver for the tty
1369 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001370 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001371 * Return the tty, if found. If not found, return NULL or ERR_PTR() if the
1372 * driver lookup() method returns an error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001373 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001374 * Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001375 */
Jason Wessela47d5452009-01-02 13:43:04 +00001376static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07001377 struct file *file, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001378{
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001379 struct tty_struct *tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001380
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001381 if (driver->ops->lookup)
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07001382 tty = driver->ops->lookup(driver, file, idx);
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001383 else
1384 tty = driver->ttys[idx];
1385
1386 if (!IS_ERR(tty))
1387 tty_kref_get(tty);
1388 return tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001389}
1390
Alan Cox99f1fe12008-10-13 10:42:00 +01001391/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001392 * tty_init_termios - helper for termios setup
1393 * @tty: the tty to set up
1394 *
1395 * Initialise the termios structures for this tty. Thus runs under
1396 * the tty_mutex currently so we can be relaxed about ordering.
1397 */
1398
Peter Hurleya3123fd2016-01-09 21:13:48 -08001399void tty_init_termios(struct tty_struct *tty)
Alan Coxbf970ee2008-10-13 10:42:39 +01001400{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001401 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001402 int idx = tty->index;
1403
Alan Cox36b3c072012-07-17 17:06:57 +01001404 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1405 tty->termios = tty->driver->init_termios;
1406 else {
1407 /* Check for lazy saved data */
1408 tp = tty->driver->termios[idx];
Peter Hurleyece53402016-01-10 22:40:57 -08001409 if (tp != NULL) {
Alan Cox36b3c072012-07-17 17:06:57 +01001410 tty->termios = *tp;
Peter Hurleyece53402016-01-10 22:40:57 -08001411 tty->termios.c_line = tty->driver->init_termios.c_line;
1412 } else
Alan Cox36b3c072012-07-17 17:06:57 +01001413 tty->termios = tty->driver->init_termios;
Alan Coxbf970ee2008-10-13 10:42:39 +01001414 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001415 /* Compatibility until drivers always set this */
Alan Coxadc8d742012-07-14 15:31:47 +01001416 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1417 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001418}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001419EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001420
Jiri Slaby66d450e2012-01-30 21:14:28 +01001421int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1422{
Peter Hurleya3123fd2016-01-09 21:13:48 -08001423 tty_init_termios(tty);
Jiri Slaby66d450e2012-01-30 21:14:28 +01001424 tty_driver_kref_get(driver);
1425 tty->count++;
1426 driver->ttys[tty->index] = tty;
1427 return 0;
1428}
1429EXPORT_SYMBOL_GPL(tty_standard_install);
1430
Alan Coxbf970ee2008-10-13 10:42:39 +01001431/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001432 * tty_driver_install_tty() - install a tty entry in the driver
1433 * @driver: the driver for the tty
1434 * @tty: the tty
1435 *
1436 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001437 * will be set by the time this is called. This method is responsible
1438 * for ensuring any need additional structures are allocated and
1439 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001440 *
1441 * Locking: tty_mutex for now
1442 */
1443static int tty_driver_install_tty(struct tty_driver *driver,
1444 struct tty_struct *tty)
1445{
Jiri Slaby66d450e2012-01-30 21:14:28 +01001446 return driver->ops->install ? driver->ops->install(driver, tty) :
1447 tty_standard_install(driver, tty);
Alan Cox8b0a88d2008-10-13 10:42:19 +01001448}
1449
1450/**
1451 * tty_driver_remove_tty() - remove a tty from the driver tables
1452 * @driver: the driver for the tty
1453 * @idx: the minor number
1454 *
1455 * Remvoe a tty object from the driver tables. The tty->index field
1456 * will be set by the time this is called.
1457 *
1458 * Locking: tty_mutex for now
1459 */
Peter Hurley05de87ed2016-01-09 21:13:49 -08001460static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +01001461{
1462 if (driver->ops->remove)
1463 driver->ops->remove(driver, tty);
1464 else
1465 driver->ttys[tty->index] = NULL;
1466}
1467
1468/*
1469 * tty_reopen() - fast re-open of an open tty
1470 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001471 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001472 * Return 0 on success, -errno on error.
Peter Hurley5d93e742014-11-05 12:12:47 -05001473 * Re-opens on master ptys are not allowed and return -EIO.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001474 *
Peter Hurley5d93e742014-11-05 12:12:47 -05001475 * Locking: Caller must hold tty_lock
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001476 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001477static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001478{
1479 struct tty_driver *driver = tty->driver;
Dmitry Safonova172c5d2019-01-09 01:17:40 +00001480 struct tty_ldisc *ld;
1481 int retval = 0;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001482
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001483 if (driver->type == TTY_DRIVER_TYPE_PTY &&
Peter Hurley5d93e742014-11-05 12:12:47 -05001484 driver->subtype == PTY_TYPE_MASTER)
1485 return -EIO;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001486
Peter Hurley7f22f6c2016-01-09 21:13:45 -08001487 if (!tty->count)
1488 return -EAGAIN;
1489
Peter Hurley86f2c002014-12-30 10:39:25 -05001490 if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1491 return -EBUSY;
1492
Dmitry Safonova172c5d2019-01-09 01:17:40 +00001493 ld = tty_ldisc_ref_wait(tty);
1494 if (ld) {
1495 tty_ldisc_deref(ld);
1496 } else {
1497 retval = tty_ldisc_lock(tty, 5 * HZ);
1498 if (retval)
1499 return retval;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001500
Dmitry Safonova172c5d2019-01-09 01:17:40 +00001501 if (!tty->ldisc)
1502 retval = tty_ldisc_reinit(tty, tty->termios.c_line);
1503 tty_ldisc_unlock(tty);
1504 }
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001505
Dmitry Safonov383cf642018-11-01 00:24:49 +00001506 if (retval == 0)
1507 tty->count++;
Dmitry Safonov381d8ec2018-09-18 00:52:52 +01001508
1509 return retval;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001510}
1511
Alan Coxaf9b8972006-08-27 01:24:01 -07001512/**
Alan Coxd81ed102008-10-13 10:41:42 +01001513 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001514 * @driver: tty driver we are opening a device on
1515 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001516 * @ret_tty: returned tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -07001517 *
1518 * Prepare a tty device. This may not be a "new" clean device but
1519 * could also be an active device. The pty drivers require special
1520 * handling because of this.
1521 *
1522 * Locking:
1523 * The function is called under the tty_mutex, which
1524 * protects us from the tty struct or driver itself going away.
1525 *
1526 * On exit the tty device has the line discipline attached and
1527 * a reference count of 1. If a pair was created for pty/tty use
1528 * and the other was a pty master then it too has a reference count of 1.
1529 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001531 * failed open. The new code protects the open with a mutex, so it's
1532 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 * relaxed for the (most common) case of reopening a tty.
1534 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001535
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001536struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537{
Alan Coxbf970ee2008-10-13 10:42:39 +01001538 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001539 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 /*
1542 * First time open is complex, especially for PTY devices.
1543 * This code guarantees that either everything succeeds and the
1544 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001545 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 * and locked termios may be retained.)
1547 */
1548
Alan Cox73ec06f2008-10-13 10:42:29 +01001549 if (!try_module_get(driver->owner))
1550 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02001552 tty = alloc_tty_struct(driver, idx);
Jiri Slabyd5543502011-03-23 10:48:32 +01001553 if (!tty) {
1554 retval = -ENOMEM;
1555 goto err_module_put;
1556 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
Alan Cox89c8d912012-08-08 16:30:13 +01001558 tty_lock(tty);
Alan Cox73ec06f2008-10-13 10:42:29 +01001559 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001560 if (retval < 0)
Peter Hurleyc8b710b2016-01-09 21:13:46 -08001561 goto err_free_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001562
Jiri Slaby04831dc2012-06-04 13:35:36 +02001563 if (!tty->port)
1564 tty->port = driver->ports[idx];
1565
Jiri Slaby5d4121c2012-08-17 14:27:52 +02001566 WARN_RATELIMIT(!tty->port,
1567 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1568 __func__, tty->driver->name);
1569
Gaurav Kohli55eaecf2018-01-23 13:16:34 +05301570 retval = tty_ldisc_lock(tty, 5 * HZ);
1571 if (retval)
1572 goto err_release_lock;
Jiri Slaby967fab62012-10-18 22:26:46 +02001573 tty->port->itty = tty;
1574
Alan Cox37bdfb02008-02-08 04:18:47 -08001575 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001577 * If we fail here just call release_tty to clean up. No need
1578 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001580 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001581 if (retval)
Jiri Slabyd5543502011-03-23 10:48:32 +01001582 goto err_release_tty;
Gaurav Kohli55eaecf2018-01-23 13:16:34 +05301583 tty_ldisc_unlock(tty);
Alan Cox89c8d912012-08-08 16:30:13 +01001584 /* Return the tty locked so that it cannot vanish under the caller */
Alan Cox73ec06f2008-10-13 10:42:29 +01001585 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
Peter Hurleyc8b710b2016-01-09 21:13:46 -08001587err_free_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001588 tty_unlock(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001589 free_tty_struct(tty);
1590err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001592 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001594 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001595err_release_tty:
Gaurav Kohli55eaecf2018-01-23 13:16:34 +05301596 tty_ldisc_unlock(tty);
Peter Hurley339f36b2015-11-08 13:01:13 -05001597 tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
1598 retval, idx);
Gaurav Kohli55eaecf2018-01-23 13:16:34 +05301599err_release_lock:
1600 tty_unlock(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001601 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001602 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603}
1604
Peter Hurleya3123fd2016-01-09 21:13:48 -08001605static void tty_free_termios(struct tty_struct *tty)
Alan Coxfeebed62008-10-13 10:41:30 +01001606{
1607 struct ktermios *tp;
1608 int idx = tty->index;
Alan Cox36b3c072012-07-17 17:06:57 +01001609
1610 /* If the port is going to reset then it has no termios to save */
1611 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1612 return;
1613
1614 /* Stash the termios data */
1615 tp = tty->driver->termios[idx];
1616 if (tp == NULL) {
1617 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
Peter Hurley25080652015-11-08 13:01:11 -05001618 if (tp == NULL)
Alan Cox36b3c072012-07-17 17:06:57 +01001619 return;
Dan Carpenter4ac5d702012-07-24 12:51:52 +01001620 tty->driver->termios[idx] = tp;
Alan Coxfeebed62008-10-13 10:41:30 +01001621 }
Alan Cox36b3c072012-07-17 17:06:57 +01001622 *tp = tty->termios;
Alan Coxfeebed62008-10-13 10:41:30 +01001623}
Alan Coxfeebed62008-10-13 10:41:30 +01001624
Peter Hurleya2965b72013-03-11 16:44:35 -04001625/**
Peter Hurley949aa642014-11-05 12:12:57 -05001626 * tty_flush_works - flush all works of a tty/pty pair
1627 * @tty: tty device to flush works for (or either end of a pty pair)
Peter Hurleya2965b72013-03-11 16:44:35 -04001628 *
Peter Hurley949aa642014-11-05 12:12:57 -05001629 * Sync flush all works belonging to @tty (and the 'other' tty).
Peter Hurleya2965b72013-03-11 16:44:35 -04001630 */
1631static void tty_flush_works(struct tty_struct *tty)
1632{
1633 flush_work(&tty->SAK_work);
1634 flush_work(&tty->hangup_work);
Peter Hurley949aa642014-11-05 12:12:57 -05001635 if (tty->link) {
1636 flush_work(&tty->link->SAK_work);
1637 flush_work(&tty->link->hangup_work);
1638 }
Peter Hurleya2965b72013-03-11 16:44:35 -04001639}
Alan Coxfeebed62008-10-13 10:41:30 +01001640
Alan Coxaf9b8972006-08-27 01:24:01 -07001641/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001642 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001643 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001644 *
1645 * Releases memory associated with a tty structure, and clears out the
1646 * driver table slots. This function is called when a device is no longer
1647 * in use. It also gets called when setup of a device fails.
1648 *
1649 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -07001650 * takes the file list lock internally when working on the list
1651 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001652 *
1653 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001654 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 */
Alan Coxb50989d2009-09-19 13:13:22 -07001656static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657{
Alan Coxb50989d2009-09-19 13:13:22 -07001658 struct tty_struct *tty =
1659 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001660 struct tty_driver *driver = tty->driver;
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001661 struct module *owner = driver->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Dave Youngf278a2f2009-09-27 16:00:42 +00001663 if (tty->ops->cleanup)
1664 tty->ops->cleanup(tty);
1665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001667 tty_driver_kref_put(driver);
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001668 module_put(owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001669
Peter Hurley4a510962016-01-09 21:35:23 -08001670 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 list_del_init(&tty->tty_files);
Peter Hurley4a510962016-01-09 21:35:23 -08001672 spin_unlock(&tty->files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001673
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001674 put_pid(tty->pgrp);
1675 put_pid(tty->session);
Neeraj Upadhyaydab446f2018-10-10 13:49:54 +05301676#if defined(CONFIG_TTY_FLUSH_LOCAL_ECHO)
1677 if (tty->echo_delayed_work.work.func)
1678 cancel_delayed_work_sync(&tty->echo_delayed_work);
1679#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 free_tty_struct(tty);
1681}
1682
Alan Coxb50989d2009-09-19 13:13:22 -07001683static void queue_release_one_tty(struct kref *kref)
1684{
1685 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001686
Alan Coxb50989d2009-09-19 13:13:22 -07001687 /* The hangup queue is now free so we can reuse it rather than
1688 waste a chunk of memory for each port */
1689 INIT_WORK(&tty->hangup_work, release_one_tty);
1690 schedule_work(&tty->hangup_work);
1691}
1692
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001693/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001694 * tty_kref_put - release a tty kref
1695 * @tty: tty device
1696 *
1697 * Release a reference to a tty device and if need be let the kref
1698 * layer destruct the object for us
1699 */
1700
1701void tty_kref_put(struct tty_struct *tty)
1702{
1703 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001704 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001705}
1706EXPORT_SYMBOL(tty_kref_put);
1707
1708/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001709 * release_tty - release tty structure memory
1710 *
1711 * Release both @tty and a possible linked partner (think pty pair),
1712 * and decrement the refcount of the backing module.
1713 *
1714 * Locking:
Alan Coxd1552552012-07-27 18:02:54 +01001715 * tty_mutex
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001716 * takes the file list lock internally when working on the list
1717 * of ttys that the driver keeps.
Alan Cox9c9f4de2008-10-13 10:37:26 +01001718 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001719 */
1720static void release_tty(struct tty_struct *tty, int idx)
1721{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001722 /* This should always be true but check for the moment */
1723 WARN_ON(tty->index != idx);
Alan Coxd1552552012-07-27 18:02:54 +01001724 WARN_ON(!mutex_is_locked(&tty_mutex));
Alan Cox36b3c072012-07-17 17:06:57 +01001725 if (tty->ops->shutdown)
1726 tty->ops->shutdown(tty);
1727 tty_free_termios(tty);
1728 tty_driver_remove_tty(tty->driver, tty);
Jiri Slaby967fab62012-10-18 22:26:46 +02001729 tty->port->itty = NULL;
Peter Hurley64e377d2013-06-15 09:01:00 -04001730 if (tty->link)
1731 tty->link->port->itty = NULL;
Peter Hurleye1760582015-10-17 16:36:23 -04001732 tty_buffer_cancel_work(tty->port);
Saharad69cf852017-12-13 09:10:48 +04001733 if (tty->link)
1734 tty_buffer_cancel_work(tty->link->port);
Alan Cox36b3c072012-07-17 17:06:57 +01001735
Markus Elfringa211b1a2014-11-21 13:42:29 +01001736 tty_kref_put(tty->link);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001737 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001738}
1739
Alan Coxeeb89d92009-11-30 13:18:29 +00001740/**
Jiri Slaby955787ca2011-11-11 10:47:23 +01001741 * tty_release_checks - check a tty before real release
1742 * @tty: tty to check
1743 * @o_tty: link of @tty (if any)
1744 * @idx: index of the tty
1745 *
1746 * Performs some paranoid checking before true release of the @tty.
1747 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1748 */
Peter Hurley359b9fb2014-11-05 12:12:59 -05001749static int tty_release_checks(struct tty_struct *tty, int idx)
Jiri Slaby955787ca2011-11-11 10:47:23 +01001750{
1751#ifdef TTY_PARANOIA_CHECK
1752 if (idx < 0 || idx >= tty->driver->num) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001753 tty_debug(tty, "bad idx %d\n", idx);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001754 return -1;
1755 }
1756
1757 /* not much to check for devpts */
1758 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1759 return 0;
1760
1761 if (tty != tty->driver->ttys[idx]) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001762 tty_debug(tty, "bad driver table[%d] = %p\n",
1763 idx, tty->driver->ttys[idx]);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001764 return -1;
1765 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001766 if (tty->driver->other) {
Peter Hurley359b9fb2014-11-05 12:12:59 -05001767 struct tty_struct *o_tty = tty->link;
1768
Jiri Slaby955787ca2011-11-11 10:47:23 +01001769 if (o_tty != tty->driver->other->ttys[idx]) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001770 tty_debug(tty, "bad other table[%d] = %p\n",
1771 idx, tty->driver->other->ttys[idx]);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001772 return -1;
1773 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001774 if (o_tty->link != tty) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001775 tty_debug(tty, "bad link = %p\n", o_tty->link);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001776 return -1;
1777 }
1778 }
1779#endif
1780 return 0;
1781}
1782
1783/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001784 * tty_release - vfs callback for close
1785 * @inode: inode of tty
1786 * @filp: file pointer for handle to tty
1787 *
1788 * Called the last time each file handle is closed that references
1789 * this tty. There may however be several such references.
1790 *
1791 * Locking:
1792 * Takes bkl. See tty_release_dev
1793 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 * Even releasing the tty structures is a tricky business.. We have
1795 * to be very careful that the structures are all released at the
1796 * same time, as interrupts might otherwise get the wrong pointers.
1797 *
1798 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1799 * lead to double frees or releasing memory still in use.
1800 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001801
1802int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803{
Nick Piggind996b622010-08-18 04:37:36 +10001804 struct tty_struct *tty = file_tty(filp);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001805 struct tty_struct *o_tty = NULL;
1806 int do_sleep, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 int idx;
Peter Hurley37b16452014-10-16 13:51:30 -04001808 long timeout = 0;
Peter Hurley494c1ea2014-10-16 13:54:36 -04001809 int once = 1;
Alan Cox37bdfb02008-02-08 04:18:47 -08001810
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001811 if (tty_paranoia_check(tty, inode, __func__))
Alan Coxeeb89d92009-11-30 13:18:29 +00001812 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813
Alan Cox89c8d912012-08-08 16:30:13 +01001814 tty_lock(tty);
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001815 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816
Arnd Bergmannec79d602010-06-01 22:53:01 +02001817 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818
1819 idx = tty->index;
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001820 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1821 tty->driver->subtype == PTY_TYPE_MASTER)
1822 o_tty = tty->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
Peter Hurley359b9fb2014-11-05 12:12:59 -05001824 if (tty_release_checks(tty, idx)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001825 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001826 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
Peter Hurleyd435cef2015-11-08 13:01:19 -05001829 tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
Alan Coxf34d7a52008-04-30 00:54:13 -07001831 if (tty->ops->close)
1832 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833
Peter Hurley2aff5e22014-11-05 12:13:01 -05001834 /* If tty is pty master, lock the slave pty (stable lock order) */
1835 tty_lock_slave(o_tty);
1836
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 /*
1838 * Sanity check: if tty->count is going to zero, there shouldn't be
1839 * any waiters on tty->read_wait or tty->write_wait. We test the
1840 * wait queues and kick everyone out _before_ actually starting to
1841 * close. This ensures that we won't block while releasing the tty
1842 * structure.
1843 *
1844 * The test for the o_tty closing is necessary, since the master and
1845 * slave sides may close in any order. If the slave side closes out
1846 * first, its count will be one, since the master side holds an open.
Peter Hurley324c1652014-11-05 12:12:56 -05001847 * Thus this test wouldn't be triggered at the time the slave closed,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 * so we do it now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 */
1850 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 do_sleep = 0;
1852
Peter Hurley324c1652014-11-05 12:12:56 -05001853 if (tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001855 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 do_sleep++;
1857 }
1858 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001859 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 do_sleep++;
1861 }
1862 }
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001863 if (o_tty && o_tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001865 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 do_sleep++;
1867 }
1868 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001869 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 do_sleep++;
1871 }
1872 }
1873 if (!do_sleep)
1874 break;
1875
Peter Hurley494c1ea2014-10-16 13:54:36 -04001876 if (once) {
1877 once = 0;
Peter Hurley339f36b2015-11-08 13:01:13 -05001878 tty_warn(tty, "read/write wait queue active!\n");
Peter Hurley494c1ea2014-10-16 13:54:36 -04001879 }
Peter Hurley37b16452014-10-16 13:51:30 -04001880 schedule_timeout_killable(timeout);
1881 if (timeout < 120 * HZ)
1882 timeout = 2 * timeout + 1;
1883 else
1884 timeout = MAX_SCHEDULE_TIMEOUT;
Alan Cox37bdfb02008-02-08 04:18:47 -08001885 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001887 if (o_tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 if (--o_tty->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -05001889 tty_warn(tty, "bad slave count (%d)\n", o_tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 o_tty->count = 0;
1891 }
1892 }
1893 if (--tty->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -05001894 tty_warn(tty, "bad tty->count (%d)\n", tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 tty->count = 0;
1896 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001897
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 /*
1899 * We've decremented tty->count, so we need to remove this file
1900 * descriptor off the tty->tty_files list; this serves two
1901 * purposes:
1902 * - check_tty_count sees the correct number of file descriptors
1903 * associated with this tty.
1904 * - do_tty_hangup no longer sees this file descriptor as
1905 * something that needs to be handled for hangups.
1906 */
Nick Piggind996b622010-08-18 04:37:36 +10001907 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
1909 /*
1910 * Perform some housekeeping before deciding whether to return.
1911 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 * If _either_ side is closing, make sure there aren't any
1913 * processes that still think tty or o_tty is their controlling
1914 * tty.
1915 */
Peter Hurley324c1652014-11-05 12:12:56 -05001916 if (!tty->count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001918 session_clear_tty(tty->session);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001919 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001920 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 read_unlock(&tasklist_lock);
1922 }
1923
Peter Hurley324c1652014-11-05 12:12:56 -05001924 /* check whether both sides are closing ... */
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001925 final = !tty->count && !(o_tty && o_tty->count);
Peter Hurley324c1652014-11-05 12:12:56 -05001926
Peter Hurley2aff5e22014-11-05 12:13:01 -05001927 tty_unlock_slave(o_tty);
1928 tty_unlock(tty);
1929
Peter Hurley04980702014-11-05 12:12:52 -05001930 /* At this point, the tty->count == 0 should ensure a dead tty
Alan Coxd1552552012-07-27 18:02:54 +01001931 cannot be re-opened by a racing opener */
Paul Fulghumda965822006-02-14 13:53:00 -08001932
Peter Hurley324c1652014-11-05 12:12:56 -05001933 if (!final)
Alan Coxeeb89d92009-11-30 13:18:29 +00001934 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001935
Peter Hurleyaccff792015-07-12 22:49:09 -04001936 tty_debug_hangup(tty, "final close\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001938 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 */
Peter Hurley62462ae2014-11-05 12:12:58 -05001940 tty_ldisc_release(tty);
Peter Hurleya2965b72013-03-11 16:44:35 -04001941
1942 /* Wait for pending work before tty destruction commmences */
1943 tty_flush_works(tty);
Peter Hurleya2965b72013-03-11 16:44:35 -04001944
Peter Hurleyd435cef2015-11-08 13:01:19 -05001945 tty_debug_hangup(tty, "freeing structure\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001947 * The release_tty function takes care of the details of clearing
Alan Cox89c8d912012-08-08 16:30:13 +01001948 * the slots and preserving the termios structure. The tty_unlock_pair
1949 * should be safe as we keep a kref while the tty is locked (so the
1950 * unlock never unlocks a freed tty).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 */
Alan Coxd1552552012-07-27 18:02:54 +01001952 mutex_lock(&tty_mutex);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001953 release_tty(tty, idx);
Alan Coxd1552552012-07-27 18:02:54 +01001954 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
Alan Coxeeb89d92009-11-30 13:18:29 +00001956 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957}
1958
Alan Coxaf9b8972006-08-27 01:24:01 -07001959/**
Peter Hurley52494ee2014-11-05 12:12:50 -05001960 * tty_open_current_tty - get locked tty of current task
Jiri Slabyb82154a2011-11-09 21:33:19 +01001961 * @device: device number
1962 * @filp: file pointer to tty
Peter Hurley52494ee2014-11-05 12:12:50 -05001963 * @return: locked tty of the current task iff @device is /dev/tty
1964 *
1965 * Performs a re-open of the current task's controlling tty.
Jiri Slabyb82154a2011-11-09 21:33:19 +01001966 *
1967 * We cannot return driver and index like for the other nodes because
1968 * devpts will not work then. It expects inodes to be from devpts FS.
1969 */
1970static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1971{
1972 struct tty_struct *tty;
Peter Hurley52494ee2014-11-05 12:12:50 -05001973 int retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01001974
1975 if (device != MKDEV(TTYAUX_MAJOR, 0))
1976 return NULL;
1977
1978 tty = get_current_tty();
1979 if (!tty)
1980 return ERR_PTR(-ENXIO);
1981
1982 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1983 /* noctty = 1; */
Peter Hurley52494ee2014-11-05 12:12:50 -05001984 tty_lock(tty);
1985 tty_kref_put(tty); /* safe to drop the kref now */
1986
1987 retval = tty_reopen(tty);
1988 if (retval < 0) {
1989 tty_unlock(tty);
1990 tty = ERR_PTR(retval);
1991 }
Jiri Slabyb82154a2011-11-09 21:33:19 +01001992 return tty;
1993}
1994
1995/**
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001996 * tty_lookup_driver - lookup a tty driver for a given device file
1997 * @device: device number
1998 * @filp: file pointer to tty
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001999 * @index: index for the device in the @return driver
2000 * @return: driver for this inode (with increased refcount)
2001 *
2002 * If @return is not erroneous, the caller is responsible to decrement the
2003 * refcount by tty_driver_kref_put.
2004 *
2005 * Locking: tty_mutex protects get_tty_driver
2006 */
2007static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
Peter Hurley11e1d4a2016-01-09 21:13:52 -08002008 int *index)
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002009{
2010 struct tty_driver *driver;
2011
Jiri Slaby2cd00502011-11-09 21:33:22 +01002012 switch (device) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002013#ifdef CONFIG_VT
Jiri Slaby2cd00502011-11-09 21:33:22 +01002014 case MKDEV(TTY_MAJOR, 0): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002015 extern struct tty_driver *console_driver;
2016 driver = tty_driver_kref_get(console_driver);
2017 *index = fg_console;
Jiri Slaby2cd00502011-11-09 21:33:22 +01002018 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002019 }
2020#endif
Jiri Slaby2cd00502011-11-09 21:33:22 +01002021 case MKDEV(TTYAUX_MAJOR, 1): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002022 struct tty_driver *console_driver = console_device(index);
2023 if (console_driver) {
2024 driver = tty_driver_kref_get(console_driver);
2025 if (driver) {
2026 /* Don't let /dev/console block */
2027 filp->f_flags |= O_NONBLOCK;
Jiri Slaby2cd00502011-11-09 21:33:22 +01002028 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002029 }
2030 }
2031 return ERR_PTR(-ENODEV);
2032 }
Jiri Slaby2cd00502011-11-09 21:33:22 +01002033 default:
2034 driver = get_tty_driver(device, index);
2035 if (!driver)
2036 return ERR_PTR(-ENODEV);
2037 break;
2038 }
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002039 return driver;
2040}
2041
2042/**
Peter Hurleyd6203d02016-01-09 21:13:53 -08002043 * tty_open_by_driver - open a tty device
2044 * @device: dev_t of device to open
2045 * @inode: inode of device file
2046 * @filp: file pointer to tty
2047 *
2048 * Performs the driver lookup, checks for a reopen, or otherwise
2049 * performs the first-time tty initialization.
2050 *
2051 * Returns the locked initialized or re-opened &tty_struct
2052 *
2053 * Claims the global tty_mutex to serialize:
2054 * - concurrent first-time tty initialization
2055 * - concurrent tty driver removal w/ lookup
2056 * - concurrent tty removal from driver table
2057 */
2058static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
2059 struct file *filp)
2060{
2061 struct tty_struct *tty;
2062 struct tty_driver *driver = NULL;
2063 int index = -1;
2064 int retval;
2065
2066 mutex_lock(&tty_mutex);
2067 driver = tty_lookup_driver(device, filp, &index);
2068 if (IS_ERR(driver)) {
2069 mutex_unlock(&tty_mutex);
2070 return ERR_CAST(driver);
2071 }
2072
2073 /* check whether we're reopening an existing tty */
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07002074 tty = tty_driver_lookup_tty(driver, filp, index);
Peter Hurleyd6203d02016-01-09 21:13:53 -08002075 if (IS_ERR(tty)) {
2076 mutex_unlock(&tty_mutex);
2077 goto out;
2078 }
2079
2080 if (tty) {
2081 mutex_unlock(&tty_mutex);
2082 retval = tty_lock_interruptible(tty);
Peter Hurley5e00bbf2016-03-31 17:47:07 -07002083 tty_kref_put(tty); /* drop kref from tty_driver_lookup_tty() */
Peter Hurleyd6203d02016-01-09 21:13:53 -08002084 if (retval) {
2085 if (retval == -EINTR)
2086 retval = -ERESTARTSYS;
2087 tty = ERR_PTR(retval);
2088 goto out;
2089 }
Peter Hurleyd6203d02016-01-09 21:13:53 -08002090 retval = tty_reopen(tty);
2091 if (retval < 0) {
2092 tty_unlock(tty);
2093 tty = ERR_PTR(retval);
2094 }
2095 } else { /* Returns with the tty_lock held for now */
2096 tty = tty_init_dev(driver, index);
2097 mutex_unlock(&tty_mutex);
2098 }
2099out:
2100 tty_driver_kref_put(driver);
2101 return tty;
2102}
2103
2104/**
Alan Coxeeb89d92009-11-30 13:18:29 +00002105 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002106 * @inode: inode of device file
2107 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002109 * tty_open and tty_release keep up the tty count that contains the
2110 * number of opens done on a tty. We cannot use the inode-count, as
2111 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002113 * Open-counting is needed for pty masters, as well as for keeping
2114 * track of serial lines: DTR is dropped when the last close happens.
2115 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2116 *
2117 * The termios state of a pty is reset on first open so that
2118 * settings don't persist across reuse.
2119 *
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002120 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002121 * tty->count should protect the rest.
2122 * ->siglock protects ->signal/->sighand
Alan Cox89c8d912012-08-08 16:30:13 +01002123 *
2124 * Note: the tty_unlock/lock cases without a ref are only safe due to
2125 * tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002127
Alan Coxeeb89d92009-11-30 13:18:29 +00002128static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129{
Jiri Slabyb82154a2011-11-09 21:33:19 +01002130 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 int noctty, retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07002133 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134
2135 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08002136
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137retry_open:
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002138 retval = tty_alloc_file(filp);
2139 if (retval)
2140 return -ENOMEM;
2141
Jiri Slabyb82154a2011-11-09 21:33:19 +01002142 tty = tty_open_current_tty(device, filp);
Peter Hurleyd6203d02016-01-09 21:13:53 -08002143 if (!tty)
2144 tty = tty_open_by_driver(device, inode, filp);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01002145
Alan Coxeeb89d92009-11-30 13:18:29 +00002146 if (IS_ERR(tty)) {
Peter Hurleyd6203d02016-01-09 21:13:53 -08002147 tty_free_file(filp);
Jiri Slabyba5db442011-11-09 21:33:21 +01002148 retval = PTR_ERR(tty);
Peter Hurley7f22f6c2016-01-09 21:13:45 -08002149 if (retval != -EAGAIN || signal_pending(current))
Peter Hurleyd6203d02016-01-09 21:13:53 -08002150 return retval;
Peter Hurley7f22f6c2016-01-09 21:13:45 -08002151 schedule();
2152 goto retry_open;
Alan Coxeeb89d92009-11-30 13:18:29 +00002153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002155 tty_add_file(tty, filp);
Nick Piggind996b622010-08-18 04:37:36 +10002156
Jiri Slaby9de44bd2011-11-09 21:33:24 +01002157 check_tty_count(tty, __func__);
Peter Hurleyd435cef2015-11-08 13:01:19 -05002158 tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
Peter Hurleyaccff792015-07-12 22:49:09 -04002159
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03002160 if (tty->ops->open)
2161 retval = tty->ops->open(tty, filp);
2162 else
2163 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 filp->f_flags = saved_flags;
2165
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 if (retval) {
Peter Hurleyd435cef2015-11-08 13:01:19 -05002167 tty_debug_hangup(tty, "open error %d, releasing\n", retval);
Peter Hurleyaccff792015-07-12 22:49:09 -04002168
Alan Cox89c8d912012-08-08 16:30:13 +01002169 tty_unlock(tty); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00002170 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002171 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002173
2174 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002176
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 schedule();
2178 /*
2179 * Need to reset f_op in case a hangup happened.
2180 */
Peter Hurley12569372014-11-05 12:26:24 -05002181 if (tty_hung_up_p(filp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 filp->f_op = &tty_fops;
2183 goto retry_open;
2184 }
Peter Hurleyd4855e12013-11-19 08:46:27 -05002185 clear_bit(TTY_HUPPED, &tty->flags);
Alan Coxeeb89d92009-11-30 13:18:29 +00002186
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002187
Peter Hurley2c411c12014-10-16 14:59:47 -04002188 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002189 spin_lock_irq(&current->sighand->siglock);
Peter Hurley11e1d4a2016-01-09 21:13:52 -08002190 noctty = (filp->f_flags & O_NOCTTY) ||
Peter Hurleyda5a0fc2016-03-31 17:05:30 -07002191 (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
Peter Hurley11e1d4a2016-01-09 21:13:52 -08002192 device == MKDEV(TTYAUX_MAJOR, 1) ||
2193 (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2194 tty->driver->subtype == PTY_TYPE_MASTER);
2195
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 if (!noctty &&
2197 current->signal->leader &&
2198 !current->signal->tty &&
Jann Horn0c5562712015-10-04 19:29:12 +02002199 tty->session == NULL) {
2200 /*
2201 * Don't let a process that only has write access to the tty
2202 * obtain the privileges associated with having a tty as
2203 * controlling terminal (being able to reopen it with full
2204 * access through /dev/tty, being able to perform pushback).
2205 * Many distributions set the group of all ttys to "tty" and
2206 * grant write-only access to all terminals for setgid tty
2207 * binaries, which should not imply full privileges on all ttys.
2208 *
2209 * This could theoretically break old code that performs open()
2210 * on a write-only file descriptor. In that case, it might be
2211 * necessary to also permit this if
2212 * inode_permission(inode, MAY_READ) == 0.
2213 */
2214 if (filp->f_mode & FMODE_READ)
2215 __proc_set_tty(tty);
2216 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002217 spin_unlock_irq(&current->sighand->siglock);
Peter Hurley2c411c12014-10-16 14:59:47 -04002218 read_unlock(&tasklist_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01002219 tty_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 return 0;
2221}
2222
Jonathan Corbet39d95b92008-05-16 09:10:50 -06002223
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224
Alan Coxaf9b8972006-08-27 01:24:01 -07002225/**
2226 * tty_poll - check tty status
2227 * @filp: file being polled
2228 * @wait: poll wait structures to update
2229 *
2230 * Call the line discipline polling method to obtain the poll
2231 * status of the device.
2232 *
2233 * Locking: locks called line discipline but ldisc poll method
2234 * may be re-entered freely by other callers.
2235 */
2236
Alan Cox37bdfb02008-02-08 04:18:47 -08002237static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238{
Nick Piggind996b622010-08-18 04:37:36 +10002239 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 struct tty_ldisc *ld;
2241 int ret = 0;
2242
Al Viro6131ffa2013-02-27 16:59:05 -05002243 if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002245
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002247 if (!ld)
2248 return hung_up_tty_poll(filp, wait);
Alan Coxa352def2008-07-16 21:53:12 +01002249 if (ld->ops->poll)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002250 ret = ld->ops->poll(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 tty_ldisc_deref(ld);
2252 return ret;
2253}
2254
Arnd Bergmannec79d602010-06-01 22:53:01 +02002255static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256{
Nick Piggind996b622010-08-18 04:37:36 +10002257 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07002258 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002259 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260
Al Viro6131ffa2013-02-27 16:59:05 -05002261 if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002262 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08002263
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 retval = fasync_helper(fd, filp, on, &tty->fasync);
2265 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002266 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267
2268 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002269 enum pid_type type;
2270 struct pid *pid;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002271
Alan Cox47f86832008-04-30 00:53:30 -07002272 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002273 if (tty->pgrp) {
2274 pid = tty->pgrp;
2275 type = PIDTYPE_PGID;
2276 } else {
2277 pid = task_pid(current);
2278 type = PIDTYPE_PID;
2279 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002280 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002281 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002282 __f_setown(filp, pid, type, 0);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002283 put_pid(pid);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002284 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002286out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002287 return retval;
2288}
2289
2290static int tty_fasync(int fd, struct file *filp, int on)
2291{
Alan Cox89c8d912012-08-08 16:30:13 +01002292 struct tty_struct *tty = file_tty(filp);
Peter Hurleya8f3a292016-01-09 21:45:11 -08002293 int retval = -ENOTTY;
Alan Cox89c8d912012-08-08 16:30:13 +01002294
2295 tty_lock(tty);
Peter Hurleya8f3a292016-01-09 21:45:11 -08002296 if (!tty_hung_up_p(filp))
2297 retval = __tty_fasync(fd, filp, on);
Alan Cox89c8d912012-08-08 16:30:13 +01002298 tty_unlock(tty);
2299
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002300 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301}
2302
Alan Coxaf9b8972006-08-27 01:24:01 -07002303/**
2304 * tiocsti - fake input character
2305 * @tty: tty to fake input into
2306 * @p: pointer to character
2307 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002308 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002309 * input management.
2310 *
2311 * FIXME: does not honour flow control ??
2312 *
2313 * Locking:
Peter Hurley137084b2013-06-15 07:04:46 -04002314 * Called functions take tty_ldiscs_lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002315 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002316 *
2317 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002318 */
2319
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320static int tiocsti(struct tty_struct *tty, char __user *p)
2321{
2322 char ch, mbz = 0;
2323 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002324
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2326 return -EPERM;
2327 if (get_user(ch, p))
2328 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002329 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002331 if (!ld)
2332 return -EIO;
Greg Kroah-Hartman0609c032019-01-20 10:46:58 +01002333 if (ld->ops->receive_buf)
2334 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 tty_ldisc_deref(ld);
2336 return 0;
2337}
2338
Alan Coxaf9b8972006-08-27 01:24:01 -07002339/**
2340 * tiocgwinsz - implement window query ioctl
2341 * @tty; tty
2342 * @arg: user buffer for result
2343 *
Alan Cox808a0d32006-09-29 02:00:40 -07002344 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002345 *
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002346 * Locking: tty->winsize_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002347 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002348 */
2349
Alan Cox37bdfb02008-02-08 04:18:47 -08002350static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351{
Alan Cox808a0d32006-09-29 02:00:40 -07002352 int err;
2353
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002354 mutex_lock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002355 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002356 mutex_unlock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002357
2358 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359}
2360
Alan Coxaf9b8972006-08-27 01:24:01 -07002361/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002362 * tty_do_resize - resize event
2363 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002364 * @rows: rows (character)
2365 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002366 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002367 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002368 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002369 */
2370
Alan Coxfc6f6232009-01-02 13:43:17 +00002371int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372{
Alan Coxfc6f6232009-01-02 13:43:17 +00002373 struct pid *pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374
Alan Coxfc6f6232009-01-02 13:43:17 +00002375 /* Lock the tty */
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002376 mutex_lock(&tty->winsize_mutex);
Alan Coxfc6f6232009-01-02 13:43:17 +00002377 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002378 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002379
Peter Hurley5b239542014-10-16 14:59:45 -04002380 /* Signal the foreground process group */
2381 pgrp = tty_get_pgrp(tty);
Alan Cox47f86832008-04-30 00:53:30 -07002382 if (pgrp)
2383 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002384 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002385
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002386 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002387done:
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002388 mutex_unlock(&tty->winsize_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 return 0;
2390}
Martin Schwidefsky4d334fd2013-01-04 14:55:13 +01002391EXPORT_SYMBOL(tty_do_resize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392
Alan Coxaf9b8972006-08-27 01:24:01 -07002393/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002394 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002395 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002396 * @arg: user buffer for result
2397 *
2398 * Copies the user idea of the window size to the kernel. Traditionally
2399 * this is just advisory information but for the Linux console it
2400 * actually has driver level meaning and triggers a VC resize.
2401 *
2402 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002403 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002404 * tty termios mutex and ctrl_lock. The console takes its own lock
2405 * then calls into the default method.
2406 */
2407
Alan Coxfc6f6232009-01-02 13:43:17 +00002408static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002409{
2410 struct winsize tmp_ws;
2411 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2412 return -EFAULT;
2413
2414 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002415 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002416 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002417 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002418}
2419
2420/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002421 * tioccons - allow admin to move logical console
2422 * @file: the file to become console
2423 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002424 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002425 *
2426 * Locking: uses redirect_lock to guard the redirect information
2427 */
2428
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429static int tioccons(struct file *file)
2430{
2431 if (!capable(CAP_SYS_ADMIN))
2432 return -EPERM;
2433 if (file->f_op->write == redirected_tty_write) {
2434 struct file *f;
2435 spin_lock(&redirect_lock);
2436 f = redirect;
2437 redirect = NULL;
2438 spin_unlock(&redirect_lock);
2439 if (f)
2440 fput(f);
2441 return 0;
2442 }
2443 spin_lock(&redirect_lock);
2444 if (redirect) {
2445 spin_unlock(&redirect_lock);
2446 return -EBUSY;
2447 }
Al Virocb0942b2012-08-27 14:48:26 -04002448 redirect = get_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 spin_unlock(&redirect_lock);
2450 return 0;
2451}
2452
Alan Coxaf9b8972006-08-27 01:24:01 -07002453/**
2454 * fionbio - non blocking ioctl
2455 * @file: file to set blocking value
2456 * @p: user parameter
2457 *
2458 * Historical tty interfaces had a blocking control ioctl before
2459 * the generic functionality existed. This piece of history is preserved
2460 * in the expected tty API of posix OS's.
2461 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002462 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002463 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464
2465static int fionbio(struct file *file, int __user *p)
2466{
2467 int nonblock;
2468
2469 if (get_user(nonblock, p))
2470 return -EFAULT;
2471
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002472 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 if (nonblock)
2474 file->f_flags |= O_NONBLOCK;
2475 else
2476 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002477 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 return 0;
2479}
2480
Alan Coxaf9b8972006-08-27 01:24:01 -07002481/**
2482 * tiocsctty - set controlling tty
2483 * @tty: tty structure
2484 * @arg: user argument
2485 *
2486 * This ioctl is used to manage job control. It permits a session
2487 * leader to set this tty as the controlling tty for the session.
2488 *
2489 * Locking:
Peter Hurleye218eb32014-10-16 14:59:49 -04002490 * Takes tty_lock() to serialize proc_set_tty() for this tty
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002491 * Takes tasklist_lock internally to walk sessions
2492 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002493 */
2494
Jann Horn0c5562712015-10-04 19:29:12 +02002495static int tiocsctty(struct tty_struct *tty, struct file *file, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002497 int ret = 0;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002498
Peter Hurleye218eb32014-10-16 14:59:49 -04002499 tty_lock(tty);
Peter Hurley2c411c12014-10-16 14:59:47 -04002500 read_lock(&tasklist_lock);
2501
2502 if (current->signal->leader && (task_session(current) == tty->session))
2503 goto unlock;
2504
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505 /*
2506 * The process must be a session leader and
2507 * not have a controlling tty already.
2508 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002509 if (!current->signal->leader || current->signal->tty) {
2510 ret = -EPERM;
2511 goto unlock;
2512 }
2513
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002514 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 /*
2516 * This tty is already the controlling
2517 * tty for another session group!
2518 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002519 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 /*
2521 * Steal it away
2522 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002523 session_clear_tty(tty->session);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002524 } else {
2525 ret = -EPERM;
2526 goto unlock;
2527 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 }
Jann Horn0c5562712015-10-04 19:29:12 +02002529
2530 /* See the comment in tty_open(). */
2531 if ((file->f_mode & FMODE_READ) == 0 && !capable(CAP_SYS_ADMIN)) {
2532 ret = -EPERM;
2533 goto unlock;
2534 }
2535
Peter Hurleybce65f12014-10-16 14:59:43 -04002536 proc_set_tty(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002537unlock:
Peter Hurley2c411c12014-10-16 14:59:47 -04002538 read_unlock(&tasklist_lock);
Peter Hurleye218eb32014-10-16 14:59:49 -04002539 tty_unlock(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002540 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541}
2542
Alan Coxaf9b8972006-08-27 01:24:01 -07002543/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002544 * tty_get_pgrp - return a ref counted pgrp pid
2545 * @tty: tty to read
2546 *
2547 * Returns a refcounted instance of the pid struct for the process
2548 * group controlling the tty.
2549 */
2550
2551struct pid *tty_get_pgrp(struct tty_struct *tty)
2552{
2553 unsigned long flags;
2554 struct pid *pgrp;
2555
2556 spin_lock_irqsave(&tty->ctrl_lock, flags);
2557 pgrp = get_pid(tty->pgrp);
2558 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2559
2560 return pgrp;
2561}
2562EXPORT_SYMBOL_GPL(tty_get_pgrp);
2563
Peter Hurleye1c22962014-10-16 14:59:48 -04002564/*
2565 * This checks not only the pgrp, but falls back on the pid if no
2566 * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
2567 * without this...
2568 *
2569 * The caller must hold rcu lock or the tasklist lock.
2570 */
2571static struct pid *session_of_pgrp(struct pid *pgrp)
2572{
2573 struct task_struct *p;
2574 struct pid *sid = NULL;
2575
2576 p = pid_task(pgrp, PIDTYPE_PGID);
2577 if (p == NULL)
2578 p = pid_task(pgrp, PIDTYPE_PID);
2579 if (p != NULL)
2580 sid = task_session(p);
2581
2582 return sid;
2583}
2584
Alan Cox5d0fdf12008-04-30 00:53:31 -07002585/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002586 * tiocgpgrp - get process group
2587 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002588 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002589 * @p: returned pid
2590 *
2591 * Obtain the process group of the tty. If there is no process group
2592 * return an error.
2593 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002594 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002595 */
2596
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2598{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002599 struct pid *pid;
2600 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 /*
2602 * (tty == real_tty) is a cheap way of
2603 * testing if the tty is NOT a master pty.
2604 */
2605 if (tty == real_tty && current->signal->tty != real_tty)
2606 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002607 pid = tty_get_pgrp(real_tty);
2608 ret = put_user(pid_vnr(pid), p);
2609 put_pid(pid);
2610 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611}
2612
Alan Coxaf9b8972006-08-27 01:24:01 -07002613/**
2614 * tiocspgrp - attempt to set process group
2615 * @tty: tty passed by user
2616 * @real_tty: tty side device matching tty passed by user
2617 * @p: pid pointer
2618 *
2619 * Set the process group of the tty to the session passed. Only
2620 * permitted where the tty session is our session.
2621 *
Alan Cox47f86832008-04-30 00:53:30 -07002622 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002623 */
2624
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2626{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002627 struct pid *pgrp;
2628 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 int retval = tty_check_change(real_tty);
2630
2631 if (retval == -EIO)
2632 return -ENOTTY;
2633 if (retval)
2634 return retval;
2635 if (!current->signal->tty ||
2636 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002637 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002639 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002641 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002643 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002644 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002645 retval = -ESRCH;
2646 if (!pgrp)
2647 goto out_unlock;
2648 retval = -EPERM;
2649 if (session_of_pgrp(pgrp) != task_session(current))
2650 goto out_unlock;
2651 retval = 0;
Jann Horn89f64ca2020-12-03 02:25:04 +01002652 spin_lock_irq(&real_tty->ctrl_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002653 put_pid(real_tty->pgrp);
2654 real_tty->pgrp = get_pid(pgrp);
Jann Horn89f64ca2020-12-03 02:25:04 +01002655 spin_unlock_irq(&real_tty->ctrl_lock);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002656out_unlock:
2657 rcu_read_unlock();
2658 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659}
2660
Alan Coxaf9b8972006-08-27 01:24:01 -07002661/**
2662 * tiocgsid - get session id
2663 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002664 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002665 * @p: pointer to returned session id
2666 *
2667 * Obtain the session id of the tty. If there is no session
2668 * return an error.
2669 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002670 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002671 */
2672
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2674{
2675 /*
2676 * (tty == real_tty) is a cheap way of
2677 * testing if the tty is NOT a master pty.
2678 */
2679 if (tty == real_tty && current->signal->tty != real_tty)
2680 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002681 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002683 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684}
2685
Alan Coxaf9b8972006-08-27 01:24:01 -07002686/**
2687 * tiocsetd - set line discipline
2688 * @tty: tty device
2689 * @p: pointer to user data
2690 *
2691 * Set the line discipline according to user request.
2692 *
2693 * Locking: see tty_set_ldisc, this function is just a helper
2694 */
2695
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696static int tiocsetd(struct tty_struct *tty, int __user *p)
2697{
Peter Hurleyc12da962016-01-10 22:41:04 -08002698 int disc;
Alan Cox04f378b2008-04-30 00:53:29 -07002699 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700
Peter Hurleyc12da962016-01-10 22:41:04 -08002701 if (get_user(disc, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002703
Peter Hurleyc12da962016-01-10 22:41:04 -08002704 ret = tty_set_ldisc(tty, disc);
Alan Cox04f378b2008-04-30 00:53:29 -07002705
2706 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707}
2708
Alan Coxaf9b8972006-08-27 01:24:01 -07002709/**
Peter Hurley5c17c862016-01-10 22:40:55 -08002710 * tiocgetd - get line discipline
2711 * @tty: tty device
2712 * @p: pointer to user data
2713 *
2714 * Retrieves the line discipline id directly from the ldisc.
2715 *
2716 * Locking: waits for ldisc reference (in case the line discipline
2717 * is changing or the tty is being hungup)
2718 */
2719
2720static int tiocgetd(struct tty_struct *tty, int __user *p)
2721{
2722 struct tty_ldisc *ld;
2723 int ret;
2724
2725 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002726 if (!ld)
2727 return -EIO;
Peter Hurley5c17c862016-01-10 22:40:55 -08002728 ret = put_user(ld->ops->num, p);
2729 tty_ldisc_deref(ld);
2730 return ret;
2731}
2732
2733/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002734 * send_break - performed time break
2735 * @tty: device to break on
2736 * @duration: timeout in mS
2737 *
2738 * Perform a timed break on hardware that lacks its own driver level
2739 * timed break functionality.
2740 *
2741 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002742 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002743 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002744 */
2745
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002746static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747{
Alan Cox9e989662008-07-22 11:18:03 +01002748 int retval;
2749
2750 if (tty->ops->break_ctl == NULL)
2751 return 0;
2752
2753 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2754 retval = tty->ops->break_ctl(tty, duration);
2755 else {
2756 /* Do the work ourselves */
2757 if (tty_write_lock(tty, 0) < 0)
2758 return -EINTR;
2759 retval = tty->ops->break_ctl(tty, -1);
2760 if (retval)
2761 goto out;
2762 if (!signal_pending(current))
2763 msleep_interruptible(duration);
2764 retval = tty->ops->break_ctl(tty, 0);
2765out:
2766 tty_write_unlock(tty);
2767 if (signal_pending(current))
2768 retval = -EINTR;
2769 }
2770 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771}
2772
Alan Coxaf9b8972006-08-27 01:24:01 -07002773/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002774 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002775 * @tty: tty device
2776 * @file: user file pointer
2777 * @p: pointer to result
2778 *
2779 * Obtain the modem status bits from the tty driver if the feature
2780 * is supported. Return -EINVAL if it is not available.
2781 *
2782 * Locking: none (up to the driver)
2783 */
2784
Alan Cox60b33c12011-02-14 16:26:14 +00002785static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786{
2787 int retval = -EINVAL;
2788
Alan Coxf34d7a52008-04-30 00:54:13 -07002789 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002790 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791
2792 if (retval >= 0)
2793 retval = put_user(retval, p);
2794 }
2795 return retval;
2796}
2797
Alan Coxaf9b8972006-08-27 01:24:01 -07002798/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002799 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002800 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002801 * @cmd: command - clear bits, set bits or set all
2802 * @p: pointer to desired bits
2803 *
2804 * Set the modem status bits from the tty driver if the feature
2805 * is supported. Return -EINVAL if it is not available.
2806 *
2807 * Locking: none (up to the driver)
2808 */
2809
Alan Cox20b9d172011-02-14 16:26:50 +00002810static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 unsigned __user *p)
2812{
Alan Coxae677512008-07-16 21:56:54 +01002813 int retval;
2814 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815
Alan Coxae677512008-07-16 21:56:54 +01002816 if (tty->ops->tiocmset == NULL)
2817 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818
Alan Coxae677512008-07-16 21:56:54 +01002819 retval = get_user(val, p);
2820 if (retval)
2821 return retval;
2822 set = clear = 0;
2823 switch (cmd) {
2824 case TIOCMBIS:
2825 set = val;
2826 break;
2827 case TIOCMBIC:
2828 clear = val;
2829 break;
2830 case TIOCMSET:
2831 set = val;
2832 clear = ~val;
2833 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 }
Alan Coxae677512008-07-16 21:56:54 +01002835 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2836 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002837 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838}
2839
Alan Coxd281da72010-09-16 18:21:24 +01002840static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2841{
2842 int retval = -EINVAL;
2843 struct serial_icounter_struct icount;
2844 memset(&icount, 0, sizeof(icount));
2845 if (tty->ops->get_icount)
2846 retval = tty->ops->get_icount(tty, &icount);
2847 if (retval != 0)
2848 return retval;
2849 if (copy_to_user(arg, &icount, sizeof(icount)))
2850 return -EFAULT;
2851 return 0;
2852}
2853
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002854static void tty_warn_deprecated_flags(struct serial_struct __user *ss)
2855{
2856 static DEFINE_RATELIMIT_STATE(depr_flags,
2857 DEFAULT_RATELIMIT_INTERVAL,
2858 DEFAULT_RATELIMIT_BURST);
2859 char comm[TASK_COMM_LEN];
2860 int flags;
2861
2862 if (get_user(flags, &ss->flags))
2863 return;
2864
2865 flags &= ASYNC_DEPRECATED;
2866
2867 if (flags && __ratelimit(&depr_flags))
2868 pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2869 __func__, get_task_comm(comm, current), flags);
2870}
2871
Peter Hurley8f166e02014-10-16 14:59:41 -04002872/*
2873 * if pty, return the slave side (real_tty)
2874 * otherwise, return self
2875 */
2876static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
Alan Coxe8b70e72009-06-11 12:48:02 +01002877{
2878 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2879 tty->driver->subtype == PTY_TYPE_MASTER)
2880 tty = tty->link;
2881 return tty;
2882}
Alan Coxe8b70e72009-06-11 12:48:02 +01002883
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884/*
2885 * Split this up, as gcc can choke on it otherwise..
2886 */
Alan Cox04f378b2008-04-30 00:53:29 -07002887long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888{
Nick Piggind996b622010-08-18 04:37:36 +10002889 struct tty_struct *tty = file_tty(file);
2890 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 void __user *p = (void __user *)arg;
2892 int retval;
2893 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002894
Al Viro6131ffa2013-02-27 16:59:05 -05002895 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 return -EINVAL;
2897
Alan Coxe8b70e72009-06-11 12:48:02 +01002898 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899
2900 /*
2901 * Factor out some common prep work
2902 */
2903 switch (cmd) {
2904 case TIOCSETD:
2905 case TIOCSBRK:
2906 case TIOCCBRK:
2907 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002908 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909 retval = tty_check_change(tty);
2910 if (retval)
2911 return retval;
2912 if (cmd != TIOCCBRK) {
2913 tty_wait_until_sent(tty, 0);
2914 if (signal_pending(current))
2915 return -EINTR;
2916 }
2917 break;
2918 }
2919
Alan Cox9e989662008-07-22 11:18:03 +01002920 /*
2921 * Now do the stuff.
2922 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002924 case TIOCSTI:
2925 return tiocsti(tty, p);
2926 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002927 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002928 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002929 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002930 case TIOCCONS:
2931 return real_tty != tty ? -EINVAL : tioccons(file);
2932 case FIONBIO:
2933 return fionbio(file, p);
2934 case TIOCEXCL:
2935 set_bit(TTY_EXCLUSIVE, &tty->flags);
2936 return 0;
2937 case TIOCNXCL:
2938 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2939 return 0;
Cyrill Gorcunov84fd7bd2012-10-24 23:43:22 +04002940 case TIOCGEXCL:
2941 {
2942 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2943 return put_user(excl, (int __user *)p);
2944 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002945 case TIOCNOTTY:
2946 if (current->signal->tty != tty)
2947 return -ENOTTY;
2948 no_tty();
2949 return 0;
2950 case TIOCSCTTY:
Peter Hurleyd1d3a0f2015-11-08 09:06:05 -05002951 return tiocsctty(real_tty, file, arg);
Alan Cox37bdfb02008-02-08 04:18:47 -08002952 case TIOCGPGRP:
2953 return tiocgpgrp(tty, real_tty, p);
2954 case TIOCSPGRP:
2955 return tiocspgrp(tty, real_tty, p);
2956 case TIOCGSID:
2957 return tiocgsid(tty, real_tty, p);
2958 case TIOCGETD:
Peter Hurley5c17c862016-01-10 22:40:55 -08002959 return tiocgetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002960 case TIOCSETD:
2961 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002962 case TIOCVHANGUP:
2963 if (!capable(CAP_SYS_ADMIN))
2964 return -EPERM;
2965 tty_vhangup(tty);
2966 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002967 case TIOCGDEV:
2968 {
2969 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2970 return put_user(ret, (unsigned int __user *)p);
2971 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002972 /*
2973 * Break handling
2974 */
2975 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002976 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002977 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002978 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002979 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002980 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002981 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002982 return 0;
2983 case TCSBRK: /* SVID version: non-zero arg --> no break */
2984 /* non-zero arg means wait for all output data
2985 * to be sent (performed above) but don't send break.
2986 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002988 if (!arg)
2989 return send_break(tty, 250);
2990 return 0;
2991 case TCSBRKP: /* support for POSIX tcsendbreak() */
2992 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993
Alan Cox37bdfb02008-02-08 04:18:47 -08002994 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002995 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002996 case TIOCMSET:
2997 case TIOCMBIC:
2998 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002999 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01003000 case TIOCGICOUNT:
3001 retval = tty_tiocgicount(tty, p);
3002 /* For the moment allow fall through to the old method */
3003 if (retval != -EINVAL)
3004 return retval;
3005 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08003006 case TCFLSH:
3007 switch (arg) {
3008 case TCIFLUSH:
3009 case TCIOFLUSH:
3010 /* flush tty buffer and allow ldisc to process ioctl */
Peter Hurley86c80a82014-11-05 12:13:09 -05003011 tty_buffer_flush(tty, NULL);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07003012 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08003013 }
3014 break;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01003015 case TIOCSSERIAL:
3016 tty_warn_deprecated_flags(p);
3017 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018 }
Alan Coxf34d7a52008-04-30 00:54:13 -07003019 if (tty->ops->ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05003020 retval = tty->ops->ioctl(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 if (retval != -ENOIOCTLCMD)
3022 return retval;
3023 }
3024 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08003025 if (!ld)
3026 return hung_up_tty_ioctl(file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01003028 if (ld->ops->ioctl) {
3029 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 if (retval == -ENOIOCTLCMD)
Wanlong Gaobbb63c52012-08-27 15:23:12 +08003031 retval = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 }
3033 tty_ldisc_deref(ld);
3034 return retval;
3035}
3036
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003037#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08003038static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003039 unsigned long arg)
3040{
Nick Piggind996b622010-08-18 04:37:36 +10003041 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003042 struct tty_ldisc *ld;
3043 int retval = -ENOIOCTLCMD;
3044
Al Viro6131ffa2013-02-27 16:59:05 -05003045 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003046 return -EINVAL;
3047
Alan Coxf34d7a52008-04-30 00:54:13 -07003048 if (tty->ops->compat_ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05003049 retval = tty->ops->compat_ioctl(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003050 if (retval != -ENOIOCTLCMD)
3051 return retval;
3052 }
3053
3054 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08003055 if (!ld)
3056 return hung_up_tty_compat_ioctl(file, cmd, arg);
Alan Coxa352def2008-07-16 21:53:12 +01003057 if (ld->ops->compat_ioctl)
3058 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Thomas Meyer8193c422011-10-05 23:13:13 +02003059 else
3060 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07003061 tty_ldisc_deref(ld);
3062
3063 return retval;
3064}
3065#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066
Al Viroc3c073f2012-08-21 22:32:06 -04003067static int this_tty(const void *t, struct file *file, unsigned fd)
3068{
3069 if (likely(file->f_op->read != tty_read))
3070 return 0;
3071 return file_tty(file) != t ? 0 : fd + 1;
3072}
3073
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074/*
3075 * This implements the "Secure Attention Key" --- the idea is to
3076 * prevent trojan horses by killing all processes associated with this
3077 * tty when the user hits the "Secure Attention Key". Required for
3078 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08003079 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080 * This code could be nicer; ideally it should send a HUP, wait a few
3081 * seconds, then send a INT, and then a KILL signal. But you then
3082 * have to coordinate with the init process, since all processes associated
3083 * with the current tty must be dead before the new getty is allowed
3084 * to spawn.
3085 *
3086 * Now, if it would be correct ;-/ The current code has a nasty hole -
3087 * it doesn't catch files in flight. We may send the descriptor to ourselves
3088 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3089 *
3090 * Nasty bug: do_SAK is being called in interrupt context. This can
3091 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3092 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08003093void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094{
3095#ifdef TTY_SOFT_SAK
3096 tty_hangup(tty);
3097#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08003098 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003099 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -08003101
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102 if (!tty)
3103 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003104 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08003105
Dan Carpenterb3f13de2006-12-13 00:35:09 -08003106 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107
Alan Coxf34d7a52008-04-30 00:54:13 -07003108 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08003109
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003111 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003112 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05003113 tty_notice(tty, "SAK: killed process %d (%s): by session\n",
3114 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003115 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003116 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Hurley9b42bb72015-11-08 13:01:14 -05003117
3118 /* Now kill any processes that happen to have the tty open */
Eric W. Biederman652486f2006-03-28 16:11:02 -08003119 do_each_thread(g, p) {
3120 if (p->signal->tty == tty) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05003121 tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n",
3122 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 send_sig(SIGKILL, p, 1);
3124 continue;
3125 }
3126 task_lock(p);
Al Viroc3c073f2012-08-21 22:32:06 -04003127 i = iterate_fd(p->files, 0, this_tty, tty);
3128 if (i != 0) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05003129 tty_notice(tty, "SAK: killed process %d (%s): by fd#%d\n",
3130 task_pid_nr(p), p->comm, i - 1);
Al Viroc3c073f2012-08-21 22:32:06 -04003131 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003132 }
3133 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08003134 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135 read_unlock(&tasklist_lock);
3136#endif
3137}
3138
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08003139static void do_SAK_work(struct work_struct *work)
3140{
3141 struct tty_struct *tty =
3142 container_of(work, struct tty_struct, SAK_work);
3143 __do_SAK(tty);
3144}
3145
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146/*
3147 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3148 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3149 * the values which we write to it will be identical to the values which it
3150 * already has. --akpm
3151 */
3152void do_SAK(struct tty_struct *tty)
3153{
3154 if (!tty)
3155 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156 schedule_work(&tty->SAK_work);
3157}
3158
3159EXPORT_SYMBOL(do_SAK);
3160
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08003161static int dev_match_devt(struct device *dev, const void *data)
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003162{
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08003163 const dev_t *devt = data;
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003164 return dev->devt == *devt;
3165}
3166
3167/* Must put_device() after it's unused! */
3168static struct device *tty_get_device(struct tty_struct *tty)
3169{
3170 dev_t devt = tty_devnum(tty);
3171 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
3172}
3173
3174
Alan Coxaf9b8972006-08-27 01:24:01 -07003175/**
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003176 * alloc_tty_struct
Alan Coxaf9b8972006-08-27 01:24:01 -07003177 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003178 * This subroutine allocates and initializes a tty structure.
Alan Coxaf9b8972006-08-27 01:24:01 -07003179 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003180 * Locking: none - tty in question is not exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003182
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003183struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184{
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003185 struct tty_struct *tty;
3186
3187 tty = kzalloc(sizeof(*tty), GFP_KERNEL);
3188 if (!tty)
3189 return NULL;
3190
Alan Cox9c9f4de2008-10-13 10:37:26 +01003191 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003192 tty->magic = TTY_MAGIC;
Tetsuo Handa6a506d42018-04-05 19:40:16 +09003193 if (tty_ldisc_init(tty)) {
3194 kfree(tty);
3195 return NULL;
3196 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003197 tty->session = NULL;
3198 tty->pgrp = NULL;
Alan Cox89c8d912012-08-08 16:30:13 +01003199 mutex_init(&tty->legacy_mutex);
Peter Hurleyd8c1f922013-06-15 09:14:31 -04003200 mutex_init(&tty->throttle_mutex);
Peter Hurley6a1c0682013-06-15 09:14:23 -04003201 init_rwsem(&tty->termios_rwsem);
Peter Hurleydee4a0b2013-07-24 16:43:51 -04003202 mutex_init(&tty->winsize_mutex);
Peter Hurley36697522013-06-15 07:04:48 -04003203 init_ldsem(&tty->ldisc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204 init_waitqueue_head(&tty->write_wait);
3205 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00003206 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08003207 mutex_init(&tty->atomic_write_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07003208 spin_lock_init(&tty->ctrl_lock);
Peter Hurleyf9e053d2014-09-10 15:06:31 -04003209 spin_lock_init(&tty->flow_lock);
Peter Hurley4a510962016-01-09 21:35:23 -08003210 spin_lock_init(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07003212 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01003213
3214 tty->driver = driver;
3215 tty->ops = driver->ops;
3216 tty->index = idx;
3217 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003218 tty->dev = tty_get_device(tty);
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003219
3220 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221}
3222
Alan Coxf34d7a52008-04-30 00:54:13 -07003223/**
3224 * tty_put_char - write one character to a tty
3225 * @tty: tty
3226 * @ch: character
3227 *
3228 * Write one byte to the tty using the provided put_char method
3229 * if present. Returns the number of characters successfully output.
3230 *
3231 * Note: the specific put_char operation in the driver layer may go
3232 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003234
Alan Coxf34d7a52008-04-30 00:54:13 -07003235int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236{
Alan Coxf34d7a52008-04-30 00:54:13 -07003237 if (tty->ops->put_char)
3238 return tty->ops->put_char(tty, ch);
3239 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240}
Alan Coxf34d7a52008-04-30 00:54:13 -07003241EXPORT_SYMBOL_GPL(tty_put_char);
3242
Alan Coxd81ed102008-10-13 10:41:42 +01003243struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003245static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3246 unsigned int index, unsigned int count)
3247{
Leon Yuc1a752b2015-09-07 13:08:37 +00003248 int err;
3249
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003250 /* init here, since reused cdevs cause crashes */
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003251 driver->cdevs[index] = cdev_alloc();
3252 if (!driver->cdevs[index])
3253 return -ENOMEM;
Leon Yuc1a752b2015-09-07 13:08:37 +00003254 driver->cdevs[index]->ops = &tty_fops;
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003255 driver->cdevs[index]->owner = driver->owner;
Leon Yuc1a752b2015-09-07 13:08:37 +00003256 err = cdev_add(driver->cdevs[index], dev, count);
3257 if (err)
3258 kobject_put(&driver->cdevs[index]->kobj);
3259 return err;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003260}
3261
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003263 * tty_register_device - register a tty device
3264 * @driver: the tty driver that describes the tty device
3265 * @index: the index in the tty driver for this tty device
3266 * @device: a struct device that is associated with this tty device.
3267 * This field is optional, if there is no known struct device
3268 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003269 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003270 * Returns a pointer to the struct device for this tty device
3271 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003272 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003273 * This call is required to be made to register an individual tty device
3274 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3275 * that bit is not set, this function should not be called by a tty
3276 * driver.
3277 *
3278 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003280
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003281struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3282 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003283{
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003284 return tty_register_device_attr(driver, index, device, NULL, NULL);
3285}
3286EXPORT_SYMBOL(tty_register_device);
3287
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003288static void tty_device_create_release(struct device *dev)
3289{
Peter Hurley83db1df2015-11-08 13:01:21 -05003290 dev_dbg(dev, "releasing...\n");
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003291 kfree(dev);
3292}
3293
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003294/**
3295 * tty_register_device_attr - register a tty device
3296 * @driver: the tty driver that describes the tty device
3297 * @index: the index in the tty driver for this tty device
3298 * @device: a struct device that is associated with this tty device.
3299 * This field is optional, if there is no known struct device
3300 * for this tty device it can be set to NULL safely.
3301 * @drvdata: Driver data to be set to device.
3302 * @attr_grp: Attribute group to be set on device.
3303 *
3304 * Returns a pointer to the struct device for this tty device
3305 * (or ERR_PTR(-EFOO) on error).
3306 *
3307 * This call is required to be made to register an individual tty device
3308 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3309 * that bit is not set, this function should not be called by a tty
3310 * driver.
3311 *
3312 * Locking: ??
3313 */
3314struct device *tty_register_device_attr(struct tty_driver *driver,
3315 unsigned index, struct device *device,
3316 void *drvdata,
3317 const struct attribute_group **attr_grp)
3318{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319 char name[64];
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003320 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3321 struct device *dev = NULL;
3322 int retval = -ENODEV;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003323 bool cdev = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324
3325 if (index >= driver->num) {
Peter Hurley656fb862015-11-08 13:01:15 -05003326 pr_err("%s: Attempt to register invalid tty line number (%d)\n",
3327 driver->name, index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003328 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003329 }
3330
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331 if (driver->type == TTY_DRIVER_TYPE_PTY)
3332 pty_line_name(driver, index, name);
3333 else
3334 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003335
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003336 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003337 retval = tty_cdev_add(driver, devt, index, 1);
3338 if (retval)
3339 goto error;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003340 cdev = true;
3341 }
3342
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003343 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3344 if (!dev) {
3345 retval = -ENOMEM;
3346 goto error;
3347 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003348
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003349 dev->devt = devt;
3350 dev->class = tty_class;
3351 dev->parent = device;
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003352 dev->release = tty_device_create_release;
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003353 dev_set_name(dev, "%s", name);
3354 dev->groups = attr_grp;
3355 dev_set_drvdata(dev, drvdata);
3356
3357 retval = device_register(dev);
3358 if (retval)
3359 goto error;
3360
3361 return dev;
3362
3363error:
3364 put_device(dev);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003365 if (cdev) {
3366 cdev_del(driver->cdevs[index]);
3367 driver->cdevs[index] = NULL;
3368 }
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003369 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370}
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003371EXPORT_SYMBOL_GPL(tty_register_device_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003372
3373/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003374 * tty_unregister_device - unregister a tty device
3375 * @driver: the tty driver that describes the tty device
3376 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003378 * If a tty device is registered with a call to tty_register_device() then
3379 * this function must be called when the tty device is gone.
3380 *
3381 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003383
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384void tty_unregister_device(struct tty_driver *driver, unsigned index)
3385{
Alan Cox37bdfb02008-02-08 04:18:47 -08003386 device_destroy(tty_class,
3387 MKDEV(driver->major, driver->minor_start) + index);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003388 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3389 cdev_del(driver->cdevs[index]);
3390 driver->cdevs[index] = NULL;
3391 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393EXPORT_SYMBOL(tty_unregister_device);
3394
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003395/**
3396 * __tty_alloc_driver -- allocate tty driver
3397 * @lines: count of lines this driver can handle at most
3398 * @owner: module which is repsonsible for this driver
3399 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3400 *
3401 * This should not be called directly, some of the provided macros should be
3402 * used instead. Use IS_ERR and friends on @retval.
3403 */
3404struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3405 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406{
3407 struct tty_driver *driver;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003408 unsigned int cdevs = 1;
Jiri Slaby16a02082012-08-08 22:26:42 +02003409 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003410
Jiri Slaby0019b402012-08-08 22:26:43 +02003411 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003412 return ERR_PTR(-EINVAL);
3413
Jean Delvare506eb992007-07-15 23:40:14 -07003414 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003415 if (!driver)
3416 return ERR_PTR(-ENOMEM);
3417
3418 kref_init(&driver->kref);
3419 driver->magic = TTY_DRIVER_MAGIC;
3420 driver->num = lines;
3421 driver->owner = owner;
3422 driver->flags = flags;
Jiri Slaby16a02082012-08-08 22:26:42 +02003423
3424 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3425 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3426 GFP_KERNEL);
3427 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3428 GFP_KERNEL);
3429 if (!driver->ttys || !driver->termios) {
3430 err = -ENOMEM;
3431 goto err_free_all;
3432 }
3433 }
3434
3435 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3436 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3437 GFP_KERNEL);
3438 if (!driver->ports) {
3439 err = -ENOMEM;
3440 goto err_free_all;
3441 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003442 cdevs = lines;
3443 }
3444
3445 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3446 if (!driver->cdevs) {
3447 err = -ENOMEM;
3448 goto err_free_all;
Jiri Slaby16a02082012-08-08 22:26:42 +02003449 }
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003450
Linus Torvalds1da177e2005-04-16 15:20:36 -07003451 return driver;
Jiri Slaby16a02082012-08-08 22:26:42 +02003452err_free_all:
3453 kfree(driver->ports);
3454 kfree(driver->ttys);
3455 kfree(driver->termios);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003456 kfree(driver->cdevs);
Jiri Slaby16a02082012-08-08 22:26:42 +02003457 kfree(driver);
3458 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459}
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003460EXPORT_SYMBOL(__tty_alloc_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461
Alan Cox7d7b93c2008-10-13 10:42:09 +01003462static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003464 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3465 int i;
3466 struct ktermios *tp;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003467
3468 if (driver->flags & TTY_DRIVER_INSTALLED) {
3469 /*
3470 * Free the termios and termios_locked structures because
3471 * we don't want to get memory leaks when modular tty
3472 * drivers are removed from the kernel.
3473 */
3474 for (i = 0; i < driver->num; i++) {
3475 tp = driver->termios[i];
3476 if (tp) {
3477 driver->termios[i] = NULL;
3478 kfree(tp);
3479 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003480 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3481 tty_unregister_device(driver, i);
3482 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003483 proc_tty_unregister_driver(driver);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003484 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003485 cdev_del(driver->cdevs[0]);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003486 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003487 kfree(driver->cdevs);
Jiri Slaby04831dc2012-06-04 13:35:36 +02003488 kfree(driver->ports);
Jiri Slaby16a02082012-08-08 22:26:42 +02003489 kfree(driver->termios);
3490 kfree(driver->ttys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491 kfree(driver);
3492}
3493
Alan Cox7d7b93c2008-10-13 10:42:09 +01003494void tty_driver_kref_put(struct tty_driver *driver)
3495{
3496 kref_put(&driver->kref, destruct_tty_driver);
3497}
3498EXPORT_SYMBOL(tty_driver_kref_put);
3499
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003500void tty_set_operations(struct tty_driver *driver,
3501 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502{
Alan Coxf34d7a52008-04-30 00:54:13 -07003503 driver->ops = op;
3504};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505EXPORT_SYMBOL(tty_set_operations);
3506
Alan Cox7d7b93c2008-10-13 10:42:09 +01003507void put_tty_driver(struct tty_driver *d)
3508{
3509 tty_driver_kref_put(d);
3510}
3511EXPORT_SYMBOL(put_tty_driver);
3512
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513/*
3514 * Called by a tty driver to register itself.
3515 */
3516int tty_register_driver(struct tty_driver *driver)
3517{
3518 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003519 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 dev_t dev;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003521 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522
Linus Torvalds1da177e2005-04-16 15:20:36 -07003523 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003524 error = alloc_chrdev_region(&dev, driver->minor_start,
3525 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003526 if (!error) {
3527 driver->major = MAJOR(dev);
3528 driver->minor_start = MINOR(dev);
3529 }
3530 } else {
3531 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003532 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003533 }
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003534 if (error < 0)
Jiri Slaby16a02082012-08-08 22:26:42 +02003535 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003537 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3538 error = tty_cdev_add(driver, dev, 0, driver->num);
3539 if (error)
3540 goto err_unreg_char;
3541 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003542
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003543 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003545 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003546
3547 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003548 for (i = 0; i < driver->num; i++) {
3549 d = tty_register_device(driver, i, NULL);
3550 if (IS_ERR(d)) {
3551 error = PTR_ERR(d);
Jiri Slaby16a02082012-08-08 22:26:42 +02003552 goto err_unreg_devs;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003553 }
3554 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555 }
3556 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003557 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003558 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003559
Jiri Slaby16a02082012-08-08 22:26:42 +02003560err_unreg_devs:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003561 for (i--; i >= 0; i--)
3562 tty_unregister_device(driver, i);
3563
3564 mutex_lock(&tty_mutex);
3565 list_del(&driver->tty_drivers);
3566 mutex_unlock(&tty_mutex);
3567
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003568err_unreg_char:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003569 unregister_chrdev_region(dev, driver->num);
Jiri Slaby16a02082012-08-08 22:26:42 +02003570err:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003571 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573EXPORT_SYMBOL(tty_register_driver);
3574
3575/*
3576 * Called by a tty driver to unregister itself.
3577 */
3578int tty_unregister_driver(struct tty_driver *driver)
3579{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003580#if 0
3581 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 if (driver->refcount)
3583 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003584#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3586 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003587 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003589 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003590 return 0;
3591}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003592
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593EXPORT_SYMBOL(tty_unregister_driver);
3594
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003595dev_t tty_devnum(struct tty_struct *tty)
3596{
3597 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3598}
3599EXPORT_SYMBOL(tty_devnum);
3600
Alan Coxd81ed102008-10-13 10:41:42 +01003601void tty_default_fops(struct file_operations *fops)
3602{
3603 *fops = tty_fops;
3604}
3605
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606/*
3607 * Initialize the console device. This is called *early*, so
3608 * we can't necessarily depend on lots of kernel help here.
3609 * Just do some early initializations, and do the complex setup
3610 * later.
3611 */
3612void __init console_init(void)
3613{
3614 initcall_t *call;
3615
3616 /* Setup the default TTY line discipline. */
Peter Hurley27228732016-01-09 21:35:19 -08003617 n_tty_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003618
3619 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003620 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621 * inform about problems etc..
3622 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623 call = __con_initcall_start;
3624 while (call < __con_initcall_end) {
3625 (*call)();
3626 call++;
3627 }
3628}
3629
Al Viro2c9ede52011-07-23 20:24:48 -04003630static char *tty_devnode(struct device *dev, umode_t *mode)
Kay Sieverse454cea2009-09-18 23:01:12 +02003631{
3632 if (!mode)
3633 return NULL;
3634 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3635 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3636 *mode = 0666;
3637 return NULL;
3638}
3639
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640static int __init tty_class_init(void)
3641{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003642 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643 if (IS_ERR(tty_class))
3644 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003645 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003646 return 0;
3647}
3648
3649postcore_initcall(tty_class_init);
3650
3651/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003652static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003653
Kay Sieversfbc92a32010-12-01 18:51:05 +01003654static ssize_t show_cons_active(struct device *dev,
3655 struct device_attribute *attr, char *buf)
3656{
3657 struct console *cs[16];
3658 int i = 0;
3659 struct console *c;
3660 ssize_t count = 0;
3661
Torben Hohnac751ef2011-01-25 15:07:35 -08003662 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003663 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003664 if (!c->device)
3665 continue;
3666 if (!c->write)
3667 continue;
3668 if ((c->flags & CON_ENABLED) == 0)
3669 continue;
3670 cs[i++] = c;
3671 if (i >= ARRAY_SIZE(cs))
3672 break;
3673 }
Hannes Reinecke723abd82014-02-27 12:30:51 +01003674 while (i--) {
3675 int index = cs[i]->index;
3676 struct tty_driver *drv = cs[i]->device(cs[i], &index);
3677
3678 /* don't resolve tty0 as some programs depend on it */
3679 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
3680 count += tty_line_name(drv, index, buf + count);
3681 else
3682 count += sprintf(buf + count, "%s%d",
3683 cs[i]->name, cs[i]->index);
3684
3685 count += sprintf(buf + count, "%c", i ? ' ':'\n');
3686 }
Torben Hohnac751ef2011-01-25 15:07:35 -08003687 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003688
3689 return count;
3690}
3691static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3692
Takashi Iwai1083a7b2015-02-05 11:07:42 +01003693static struct attribute *cons_dev_attrs[] = {
3694 &dev_attr_active.attr,
3695 NULL
3696};
3697
3698ATTRIBUTE_GROUPS(cons_dev);
3699
Kay Sieversfbc92a32010-12-01 18:51:05 +01003700static struct device *consdev;
3701
3702void console_sysfs_notify(void)
3703{
3704 if (consdev)
3705 sysfs_notify(&consdev->kobj, NULL, "active");
3706}
3707
Linus Torvalds1da177e2005-04-16 15:20:36 -07003708/*
3709 * Ok, now we can initialize the rest of the tty devices and can count
3710 * on memory allocations, interrupts etc..
3711 */
David Howells31d1d482010-08-06 16:34:43 +01003712int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003713{
Greg Kroah-Hartman9b7984e2019-01-21 17:26:42 +01003714 tty_sysctl_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003715 cdev_init(&tty_cdev, &tty_fops);
3716 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3717 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3718 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003719 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003720
3721 cdev_init(&console_cdev, &console_fops);
3722 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3723 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3724 panic("Couldn't register /dev/console driver\n");
Takashi Iwai1083a7b2015-02-05 11:07:42 +01003725 consdev = device_create_with_groups(tty_class, NULL,
3726 MKDEV(TTYAUX_MAJOR, 1), NULL,
3727 cons_dev_groups, "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003728 if (IS_ERR(consdev))
3729 consdev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730
Linus Torvalds1da177e2005-04-16 15:20:36 -07003731#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003732 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003733#endif
3734 return 0;
3735}
David Howells31d1d482010-08-06 16:34:43 +01003736