blob: 566728fbaf3cd4717af9da3380c389592f67ab61 [file] [log] [blame]
Greg Kroah-Hartmane3b3d0f2017-11-06 18:11:51 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Copyright (C) 1991, 1992 Linus Torvalds
4 */
5
6/*
7 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
8 * or rs-channels. It also implements echoing, cooked mode etc.
9 *
10 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
11 *
12 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
13 * tty_struct and tty_queue structures. Previously there was an array
14 * of 256 tty_struct's which was statically allocated, and the
15 * tty_queue structures were allocated at boot time. Both are now
16 * dynamically allocated only when the tty is open.
17 *
18 * Also restructured routines so that there is more of a separation
19 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
20 * the low-level tty routines (serial.c, pty.c, console.c). This
Alan Cox37bdfb02008-02-08 04:18:47 -080021 * makes for cleaner and more compact code. -TYT, 9/17/92
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 *
23 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
24 * which can be dynamically activated and de-activated by the line
25 * discipline handling modules (like SLIP).
26 *
27 * NOTE: pay no attention to the line discipline code (yet); its
28 * interface is still subject to change in this version...
29 * -- TYT, 1/31/92
30 *
31 * Added functionality to the OPOST tty handling. No delays, but all
32 * other bits should be there.
33 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
34 *
35 * Rewrote canonical mode and added more termios flags.
36 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
37 *
38 * Reorganized FASYNC support so mouse code can share it.
39 * -- ctm@ardi.com, 9Sep95
40 *
41 * New TIOCLINUX variants added.
42 * -- mj@k332.feld.cvut.cz, 19-Nov-95
Alan Cox37bdfb02008-02-08 04:18:47 -080043 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 * Restrict vt switching via ioctl()
45 * -- grif@cs.ucr.edu, 5-Dec-95
46 *
47 * Move console and virtual terminal code to more appropriate files,
48 * implement CONFIG_VT and generalize console device interface.
49 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
50 *
Alan Coxd81ed102008-10-13 10:41:42 +010051 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 * -- Bill Hawes <whawes@star.net>, June 97
53 *
54 * Added devfs support.
55 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
56 *
57 * Added support for a Unix98-style ptmx device.
58 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
59 *
60 * Reduced memory usage for older ARM systems
61 * -- Russell King <rmk@arm.linux.org.uk>
62 *
63 * Move do_SAK() into process context. Less stack use in devfs functions.
Alan Cox37bdfb02008-02-08 04:18:47 -080064 * alloc_tty_struct() always uses kmalloc()
65 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 */
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/types.h>
69#include <linux/major.h>
70#include <linux/errno.h>
71#include <linux/signal.h>
72#include <linux/fcntl.h>
Ingo Molnar3f07c012017-02-08 18:51:30 +010073#include <linux/sched/signal.h>
Ingo Molnar29930022017-02-08 18:51:36 +010074#include <linux/sched/task.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#include <linux/interrupt.h>
76#include <linux/tty.h>
77#include <linux/tty_driver.h>
78#include <linux/tty_flip.h>
79#include <linux/devpts_fs.h>
80#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040081#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#include <linux/console.h>
83#include <linux/timer.h>
84#include <linux/ctype.h>
85#include <linux/kd.h>
86#include <linux/mm.h>
87#include <linux/string.h>
88#include <linux/slab.h>
89#include <linux/poll.h>
90#include <linux/proc_fs.h>
91#include <linux/init.h>
92#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070093#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include <linux/wait.h>
95#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070096#include <linux/delay.h>
Alan Coxa352def2008-07-16 21:53:12 +010097#include <linux/seq_file.h>
Alan Coxd281da72010-09-16 18:21:24 +010098#include <linux/serial.h>
Manuel Zerpies5a3c6b2512011-06-16 14:07:22 +020099#include <linux/ratelimit.h>
Al Viroe2112032018-09-11 19:47:09 -0400100#include <linux/compat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Alan Coxa352def2008-07-16 21:53:12 +0100102#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104#include <linux/kbd_kern.h>
105#include <linux/vt_kern.h>
106#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108#include <linux/kmod.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700109#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111#undef TTY_DEBUG_HANGUP
Peter Hurleyaccff792015-07-12 22:49:09 -0400112#ifdef TTY_DEBUG_HANGUP
113# define tty_debug_hangup(tty, f, args...) tty_debug(tty, f, ##args)
114#else
115# define tty_debug_hangup(tty, f, args...) do { } while (0)
116#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118#define TTY_PARANOIA_CHECK 1
119#define CHECK_TTY_COUNT 1
120
Alan Coxedc6afc2006-12-08 02:38:44 -0800121struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 .c_iflag = ICRNL | IXON,
123 .c_oflag = OPOST | ONLCR,
124 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
125 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
126 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800127 .c_cc = INIT_C_CC,
128 .c_ispeed = 38400,
Peter Hurley133b1302016-01-10 22:41:07 -0800129 .c_ospeed = 38400,
130 /* .c_line = N_TTY, */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131};
132
133EXPORT_SYMBOL(tty_std_termios);
134
135/* This list gets poked at by procfs and various bits of boot up code. This
136 could do with some rationalisation such as pulling the tty proc function
137 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139LIST_HEAD(tty_drivers); /* linked list of tty drivers */
140
Peter Hurleyd1d027e2016-01-09 21:35:18 -0800141/* Mutex to protect creating and releasing a tty */
Ingo Molnar70522e12006-03-23 03:00:31 -0800142DEFINE_MUTEX(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
145static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800146ssize_t redirected_tty_write(struct file *, const char __user *,
147 size_t, loff_t *);
Al Viroafc9a422017-07-03 06:39:46 -0400148static __poll_t tty_poll(struct file *, poll_table *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149static int tty_open(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700150long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700151#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800152static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700153 unsigned long arg);
154#else
155#define tty_compat_ioctl NULL
156#endif
Arnd Bergmannec79d602010-06-01 22:53:01 +0200157static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800158static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800159static void release_tty(struct tty_struct *tty, int idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Alan Coxaf9b8972006-08-27 01:24:01 -0700161/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700162 * free_tty_struct - free a disused tty
163 * @tty: tty struct to free
164 *
165 * Free the write buffers, tty queue and tty memory itself.
166 *
167 * Locking: none. Must be called after tty is definitely unused
168 */
169
Peter Hurleya3123fd2016-01-09 21:13:48 -0800170static void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
Peter Hurleyc8b710b2016-01-09 21:13:46 -0800172 tty_ldisc_deinit(tty);
Markus Elfringa211b1a2014-11-21 13:42:29 +0100173 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 kfree(tty->write_buf);
Alan Cox89c8d912012-08-08 16:30:13 +0100175 tty->magic = 0xDEADDEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 kfree(tty);
177}
178
Nick Piggind996b622010-08-18 04:37:36 +1000179static inline struct tty_struct *file_tty(struct file *file)
180{
181 return ((struct tty_file_private *)file->private_data)->tty;
182}
183
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200184int tty_alloc_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000185{
186 struct tty_file_private *priv;
187
Pekka Enbergf573bd12010-08-24 07:48:34 +0300188 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
189 if (!priv)
190 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000191
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200192 file->private_data = priv;
193
194 return 0;
195}
196
197/* Associate a new file with the tty structure */
198void tty_add_file(struct tty_struct *tty, struct file *file)
199{
200 struct tty_file_private *priv = file->private_data;
201
Nick Piggind996b622010-08-18 04:37:36 +1000202 priv->tty = tty;
203 priv->file = file;
Nick Piggind996b622010-08-18 04:37:36 +1000204
Peter Hurley4a510962016-01-09 21:35:23 -0800205 spin_lock(&tty->files_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000206 list_add(&priv->list, &tty->tty_files);
Peter Hurley4a510962016-01-09 21:35:23 -0800207 spin_unlock(&tty->files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200208}
Pekka Enbergf573bd12010-08-24 07:48:34 +0300209
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200210/**
211 * tty_free_file - free file->private_data
212 *
213 * This shall be used only for fail path handling when tty_add_file was not
214 * called yet.
215 */
216void tty_free_file(struct file *file)
217{
218 struct tty_file_private *priv = file->private_data;
219
220 file->private_data = NULL;
221 kfree(priv);
Nick Piggind996b622010-08-18 04:37:36 +1000222}
223
224/* Delete file from its tty */
Josh Triplett2520e272012-11-18 21:27:47 -0800225static void tty_del_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000226{
227 struct tty_file_private *priv = file->private_data;
Peter Hurley4a510962016-01-09 21:35:23 -0800228 struct tty_struct *tty = priv->tty;
Nick Piggind996b622010-08-18 04:37:36 +1000229
Peter Hurley4a510962016-01-09 21:35:23 -0800230 spin_lock(&tty->files_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000231 list_del(&priv->list);
Peter Hurley4a510962016-01-09 21:35:23 -0800232 spin_unlock(&tty->files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200233 tty_free_file(file);
Nick Piggind996b622010-08-18 04:37:36 +1000234}
235
Alan Coxaf9b8972006-08-27 01:24:01 -0700236/**
237 * tty_name - return tty naming
238 * @tty: tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -0700239 *
240 * Convert a tty structure into a name. The name reflects the kernel
241 * naming policy and if udev is in use may not reflect user space
242 *
243 * Locking: none
244 */
245
Rasmus Villemoes429b4742015-03-31 15:55:59 +0200246const char *tty_name(const struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
248 if (!tty) /* Hmm. NULL pointer. That's fun. */
Rasmus Villemoes917162c2015-03-31 15:55:58 +0200249 return "NULL tty";
250 return tty->name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251}
252
253EXPORT_SYMBOL(tty_name);
254
Peter Hurley0a083ed2015-11-08 13:01:12 -0500255const char *tty_driver_name(const struct tty_struct *tty)
256{
257 if (!tty || !tty->driver)
258 return "";
259 return tty->driver->name;
260}
261
Peter Hurley82b8f882015-11-08 13:01:09 -0500262static int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 const char *routine)
264{
265#ifdef TTY_PARANOIA_CHECK
266 if (!tty) {
Peter Hurley89222e62015-11-08 13:01:18 -0500267 pr_warn("(%d:%d): %s: NULL tty\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 imajor(inode), iminor(inode), routine);
269 return 1;
270 }
271 if (tty->magic != TTY_MAGIC) {
Peter Hurley89222e62015-11-08 13:01:18 -0500272 pr_warn("(%d:%d): %s: bad magic number\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 imajor(inode), iminor(inode), routine);
274 return 1;
275 }
276#endif
277 return 0;
278}
279
Peter Hurleydeb287e2014-11-05 12:12:55 -0500280/* Caller must hold tty_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281static int check_tty_count(struct tty_struct *tty, const char *routine)
282{
283#ifdef CHECK_TTY_COUNT
284 struct list_head *p;
Okash Khawajaa09ac392017-07-20 08:22:36 +0100285 int count = 0, kopen_count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800286
Peter Hurley4a510962016-01-09 21:35:23 -0800287 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 list_for_each(p, &tty->tty_files) {
289 count++;
290 }
Peter Hurley4a510962016-01-09 21:35:23 -0800291 spin_unlock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
293 tty->driver->subtype == PTY_TYPE_SLAVE &&
294 tty->link && tty->link->count)
295 count++;
Okash Khawajaa09ac392017-07-20 08:22:36 +0100296 if (tty_port_kopened(tty->port))
297 kopen_count++;
298 if (tty->count != (count + kopen_count)) {
299 tty_warn(tty, "%s: tty->count(%d) != (#fd's(%d) + #kopen's(%d))\n",
300 routine, tty->count, count, kopen_count);
301 return (count + kopen_count);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303#endif
304 return 0;
305}
306
Alan Coxaf9b8972006-08-27 01:24:01 -0700307/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700308 * get_tty_driver - find device of a tty
309 * @dev_t: device identifier
310 * @index: returns the index of the tty
311 *
312 * This routine returns a tty driver structure, given a device number
313 * and also passes back the index number.
314 *
315 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318static struct tty_driver *get_tty_driver(dev_t device, int *index)
319{
320 struct tty_driver *p;
321
322 list_for_each_entry(p, &tty_drivers, tty_drivers) {
323 dev_t base = MKDEV(p->major, p->minor_start);
324 if (device < base || device >= base + p->num)
325 continue;
326 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100327 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 }
329 return NULL;
330}
331
Okash Khawajafc61ed52017-06-25 19:40:00 +0100332/**
333 * tty_dev_name_to_number - return dev_t for device name
334 * @name: user space name of device under /dev
335 * @number: pointer to dev_t that this function will populate
336 *
337 * This function converts device names like ttyS0 or ttyUSB1 into dev_t
338 * like (4, 64) or (188, 1). If no corresponding driver is registered then
339 * the function returns -ENODEV.
340 *
341 * Locking: this acquires tty_mutex to protect the tty_drivers list from
342 * being modified while we are traversing it, and makes sure to
343 * release it before exiting.
344 */
345int tty_dev_name_to_number(const char *name, dev_t *number)
346{
347 struct tty_driver *p;
348 int ret;
349 int index, prefix_length = 0;
350 const char *str;
351
352 for (str = name; *str && !isdigit(*str); str++)
353 ;
354
355 if (!*str)
356 return -EINVAL;
357
358 ret = kstrtoint(str, 10, &index);
359 if (ret)
360 return ret;
361
362 prefix_length = str - name;
363 mutex_lock(&tty_mutex);
364
365 list_for_each_entry(p, &tty_drivers, tty_drivers)
366 if (prefix_length == strlen(p->name) && strncmp(name,
367 p->name, prefix_length) == 0) {
368 if (index < p->num) {
369 *number = MKDEV(p->major, p->minor_start + index);
370 goto out;
371 }
372 }
373
374 /* if here then driver wasn't found */
375 ret = -ENODEV;
376out:
377 mutex_unlock(&tty_mutex);
378 return ret;
379}
380EXPORT_SYMBOL_GPL(tty_dev_name_to_number);
381
Jason Wesself2d937f2008-04-17 20:05:37 +0200382#ifdef CONFIG_CONSOLE_POLL
383
384/**
385 * tty_find_polling_driver - find device of a polled tty
386 * @name: name string to match
387 * @line: pointer to resulting tty line nr
388 *
389 * This routine returns a tty driver structure, given a name
390 * and the condition that the tty driver is capable of polled
391 * operation.
392 */
393struct tty_driver *tty_find_polling_driver(char *name, int *line)
394{
395 struct tty_driver *p, *res = NULL;
396 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500397 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100398 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200399
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500400 for (str = name; *str; str++)
401 if ((*str >= '0' && *str <= '9') || *str == ',')
402 break;
403 if (!*str)
404 return NULL;
405
406 len = str - name;
407 tty_line = simple_strtoul(str, &str, 10);
408
Jason Wesself2d937f2008-04-17 20:05:37 +0200409 mutex_lock(&tty_mutex);
410 /* Search through the tty devices to look for a match */
411 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Miles Chen33a1a7b2018-10-08 10:39:17 +0800412 if (!len || strncmp(name, p->name, len) != 0)
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500413 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100414 stp = str;
415 if (*stp == ',')
416 stp++;
417 if (*stp == '\0')
418 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200419
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200420 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100421 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100422 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200423 *line = tty_line;
424 break;
425 }
426 }
427 mutex_unlock(&tty_mutex);
428
429 return res;
430}
431EXPORT_SYMBOL_GPL(tty_find_polling_driver);
432#endif
433
Alan Cox37bdfb02008-02-08 04:18:47 -0800434static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 size_t count, loff_t *ppos)
436{
437 return 0;
438}
439
Alan Cox37bdfb02008-02-08 04:18:47 -0800440static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 size_t count, loff_t *ppos)
442{
443 return -EIO;
444}
445
446/* No kernel lock held - none needed ;) */
Al Viroafc9a422017-07-03 06:39:46 -0400447static __poll_t hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800449 return EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP | EPOLLRDNORM | EPOLLWRNORM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450}
451
Alan Cox04f378b2008-04-30 00:53:29 -0700452static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
453 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700454{
455 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
456}
457
Alan Cox37bdfb02008-02-08 04:18:47 -0800458static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700459 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
461 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
462}
463
Peter Hurleyf5574742016-01-09 21:45:10 -0800464static int hung_up_tty_fasync(int fd, struct file *file, int on)
465{
466 return -ENOTTY;
467}
468
Masatake YAMATOd01c3282017-07-18 06:27:59 +0900469static void tty_show_fdinfo(struct seq_file *m, struct file *file)
470{
471 struct tty_struct *tty = file_tty(file);
472
473 if (tty && tty->ops && tty->ops->show_fdinfo)
474 tty->ops->show_fdinfo(tty, m);
475}
476
Arjan van de Ven62322d22006-07-03 00:24:21 -0700477static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 .llseek = no_llseek,
479 .read = tty_read,
480 .write = tty_write,
481 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700482 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700483 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 .open = tty_open,
485 .release = tty_release,
486 .fasync = tty_fasync,
Masatake YAMATOd01c3282017-07-18 06:27:59 +0900487 .show_fdinfo = tty_show_fdinfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488};
489
Arjan van de Ven62322d22006-07-03 00:24:21 -0700490static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 .llseek = no_llseek,
492 .read = tty_read,
493 .write = redirected_tty_write,
494 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700495 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700496 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 .open = tty_open,
498 .release = tty_release,
499 .fasync = tty_fasync,
500};
501
Arjan van de Ven62322d22006-07-03 00:24:21 -0700502static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 .llseek = no_llseek,
504 .read = hung_up_tty_read,
505 .write = hung_up_tty_write,
506 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700507 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700508 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 .release = tty_release,
Peter Hurleyf5574742016-01-09 21:45:10 -0800510 .fasync = hung_up_tty_fasync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511};
512
513static DEFINE_SPINLOCK(redirect_lock);
514static struct file *redirect;
515
Greg Kroah-Hartman7c0cca72019-01-21 17:26:42 +0100516extern void tty_sysctl_init(void);
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518/**
519 * tty_wakeup - request more data
520 * @tty: terminal
521 *
522 * Internal and external helper for wakeups of tty. This function
523 * informs the line discipline if present that the driver is ready
524 * to receive more output data.
525 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527void tty_wakeup(struct tty_struct *tty)
528{
529 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
532 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800533 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100534 if (ld->ops->write_wakeup)
535 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 tty_ldisc_deref(ld);
537 }
538 }
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800539 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540}
541
542EXPORT_SYMBOL_GPL(tty_wakeup);
543
544/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200545 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000546 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700547 *
Kevin Cernekeeef4f5272012-12-26 20:43:41 -0800548 * This can be called by a "kworker" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700549 * synchronous but doesn't hold any locks, so we need to make sure we
550 * have the appropriate locks for what we're doing.
551 *
552 * The hangup event clears any pending redirections onto the hung up
553 * device. It ensures future writes will error and it does the needed
554 * line discipline hangup and signal delivery. The tty object itself
555 * remains intact.
556 *
557 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200558 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800559 * redirect lock for undoing redirection
560 * file list lock for manipulating list of ttys
Peter Hurley137084b2013-06-15 07:04:46 -0400561 * tty_ldiscs_lock from called functions
Peter Hurley6a1c0682013-06-15 09:14:23 -0400562 * termios_rwsem resetting termios data
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800563 * tasklist_lock to walk task list for hangup event
564 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 */
Peter Hurleyf91e2592013-03-06 07:20:56 -0500566static void __tty_hangup(struct tty_struct *tty, int exit_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
Alan Cox37bdfb02008-02-08 04:18:47 -0800568 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 struct file *filp, *f = NULL;
Nick Piggind996b622010-08-18 04:37:36 +1000570 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 int closecount = 0, n;
Peter Hurleyea648a42013-03-06 07:20:53 -0500572 int refs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
574 if (!tty)
575 return;
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000579 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 f = redirect;
581 redirect = NULL;
582 }
583 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800584
Alan Cox89c8d912012-08-08 16:30:13 +0100585 tty_lock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200586
Peter Hurleycb50e522013-07-31 14:05:45 -0400587 if (test_bit(TTY_HUPPED, &tty->flags)) {
588 tty_unlock(tty);
589 return;
590 }
591
Tejun Heo28b0f8a2018-02-13 07:38:08 -0800592 /*
593 * Some console devices aren't actually hung up for technical and
594 * historical reasons, which can lead to indefinite interruptible
595 * sleep in n_tty_read(). The following explicitly tells
596 * n_tty_read() to abort readers.
597 */
598 set_bit(TTY_HUPPING, &tty->flags);
599
Arnd Bergmannec79d602010-06-01 22:53:01 +0200600 /* inuse_filps is protected by the single tty lock,
601 this really needs to change if we want to flush the
602 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200603 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000604
Peter Hurley4a510962016-01-09 21:35:23 -0800605 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000607 list_for_each_entry(priv, &tty->tty_files, list) {
608 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 if (filp->f_op->write == redirected_tty_write)
610 cons_filp = filp;
611 if (filp->f_op->write != tty_write)
612 continue;
613 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200614 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 filp->f_op = &hung_up_tty_fops;
616 }
Peter Hurley4a510962016-01-09 21:35:23 -0800617 spin_unlock(&tty->files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800618
Peter Hurley25fdf242013-03-06 07:20:57 -0500619 refs = tty_signal_session_leader(tty, exit_session);
620 /* Account for the p->signal references we killed */
621 while (refs--)
622 tty_kref_put(tty);
623
Peter Hurley892d1fa2016-01-10 22:41:06 -0800624 tty_ldisc_hangup(tty, cons_filp != NULL);
Alan Cox37bdfb02008-02-08 04:18:47 -0800625
Peter Hurley20cc2252013-03-06 07:20:54 -0500626 spin_lock_irq(&tty->ctrl_lock);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100627 clear_bit(TTY_THROTTLED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100628 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600629 put_pid(tty->session);
630 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800631 tty->session = NULL;
632 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 tty->ctrl_status = 0;
Peter Hurley20cc2252013-03-06 07:20:54 -0500634 spin_unlock_irq(&tty->ctrl_lock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100635
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800637 * If one of the devices matches a console pointer, we
638 * cannot just call hangup() because that will cause
639 * tty->count and state->count to go out of sync.
640 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 */
642 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700643 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700645 tty->ops->close(tty, cons_filp);
646 } else if (tty->ops->hangup)
Peter Hurley7c6d3402014-06-16 09:17:08 -0400647 tty->ops->hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800648 /*
Peter Hurley892d1fa2016-01-10 22:41:06 -0800649 * We don't want to have driver/ldisc interactions beyond the ones
650 * we did here. The driver layer expects no calls after ->hangup()
651 * from the ldisc side, which is now guaranteed.
Alan Cox37bdfb02008-02-08 04:18:47 -0800652 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 set_bit(TTY_HUPPED, &tty->flags);
Tejun Heo28b0f8a2018-02-13 07:38:08 -0800654 clear_bit(TTY_HUPPING, &tty->flags);
Alan Cox89c8d912012-08-08 16:30:13 +0100655 tty_unlock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (f)
658 fput(f);
659}
660
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200661static void do_tty_hangup(struct work_struct *work)
662{
663 struct tty_struct *tty =
664 container_of(work, struct tty_struct, hangup_work);
665
Peter Hurleyf91e2592013-03-06 07:20:56 -0500666 __tty_hangup(tty, 0);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200667}
668
Alan Coxaf9b8972006-08-27 01:24:01 -0700669/**
670 * tty_hangup - trigger a hangup event
671 * @tty: tty to hangup
672 *
673 * A carrier loss (virtual or otherwise) has occurred on this like
674 * schedule a hangup sequence to run after this event.
675 */
676
Alan Cox37bdfb02008-02-08 04:18:47 -0800677void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500679 tty_debug_hangup(tty, "hangup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 schedule_work(&tty->hangup_work);
681}
682
683EXPORT_SYMBOL(tty_hangup);
684
Alan Coxaf9b8972006-08-27 01:24:01 -0700685/**
686 * tty_vhangup - process vhangup
687 * @tty: tty to hangup
688 *
689 * The user has asked via system call for the terminal to be hung up.
690 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200691 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700692 */
693
Alan Cox37bdfb02008-02-08 04:18:47 -0800694void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500696 tty_debug_hangup(tty, "vhangup\n");
Peter Hurleyf91e2592013-03-06 07:20:56 -0500697 __tty_hangup(tty, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698}
Alan Cox37bdfb02008-02-08 04:18:47 -0800699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700EXPORT_SYMBOL(tty_vhangup);
701
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200702
Alan Coxaf9b8972006-08-27 01:24:01 -0700703/**
Alan Cox2cb59982008-10-13 10:40:30 +0100704 * tty_vhangup_self - process vhangup for own ctty
705 *
706 * Perform a vhangup on the current controlling tty
707 */
708
709void tty_vhangup_self(void)
710{
711 struct tty_struct *tty;
712
Alan Cox2cb59982008-10-13 10:40:30 +0100713 tty = get_current_tty();
714 if (tty) {
715 tty_vhangup(tty);
716 tty_kref_put(tty);
717 }
Alan Cox2cb59982008-10-13 10:40:30 +0100718}
719
720/**
Peter Hurleyf91e2592013-03-06 07:20:56 -0500721 * tty_vhangup_session - hangup session leader exit
722 * @tty: tty to hangup
723 *
724 * The session leader is exiting and hanging up its controlling terminal.
725 * Every process in the foreground process group is signalled SIGHUP.
726 *
727 * We do this synchronously so that when the syscall returns the process
728 * is complete. That guarantee is necessary for security reasons.
729 */
730
Nicolas Pitrea1235b32017-04-12 18:37:16 -0400731void tty_vhangup_session(struct tty_struct *tty)
Peter Hurleyf91e2592013-03-06 07:20:56 -0500732{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500733 tty_debug_hangup(tty, "session hangup\n");
Peter Hurleyf91e2592013-03-06 07:20:56 -0500734 __tty_hangup(tty, 1);
735}
736
737/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700738 * tty_hung_up_p - was tty hung up
739 * @filp: file pointer of tty
740 *
741 * Return true if the tty has been subject to a vhangup or a carrier
742 * loss
743 */
744
Alan Cox37bdfb02008-02-08 04:18:47 -0800745int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Alan Coxed3f0af2017-01-16 16:54:29 -0600747 return (filp && filp->f_op == &hung_up_tty_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748}
749
750EXPORT_SYMBOL(tty_hung_up_p);
751
Alan Coxaf9b8972006-08-27 01:24:01 -0700752/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200753 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700754 * @tty: tty to stop
755 *
Peter Hurley01adc802014-09-10 15:06:32 -0400756 * Perform flow control to the driver. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700757 * on an already stopped device and will not re-call the driver
758 * method.
759 *
760 * This functionality is used by both the line disciplines for
761 * halting incoming flow and by the driver. It may therefore be
762 * called from any context, may be under the tty atomic_write_lock
763 * but not always.
764 *
765 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400766 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700767 */
768
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400769void __stop_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770{
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400771 if (tty->stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 return;
773 tty->stopped = 1;
Alan Coxf34d7a52008-04-30 00:54:13 -0700774 if (tty->ops->stop)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500775 tty->ops->stop(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776}
777
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400778void stop_tty(struct tty_struct *tty)
779{
780 unsigned long flags;
781
782 spin_lock_irqsave(&tty->flow_lock, flags);
783 __stop_tty(tty);
784 spin_unlock_irqrestore(&tty->flow_lock, flags);
785}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786EXPORT_SYMBOL(stop_tty);
787
Alan Coxaf9b8972006-08-27 01:24:01 -0700788/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200789 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700790 * @tty: tty to start
791 *
Peter Hurley01adc802014-09-10 15:06:32 -0400792 * Start a tty that has been stopped if at all possible. If this
793 * tty was previous stopped and is now being started, the driver
794 * start method is invoked and the line discipline woken.
Alan Coxaf9b8972006-08-27 01:24:01 -0700795 *
796 * Locking:
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400797 * flow_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700798 */
799
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400800void __start_tty(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400802 if (!tty->stopped || tty->flow_stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 return;
804 tty->stopped = 0;
Alan Coxf34d7a52008-04-30 00:54:13 -0700805 if (tty->ops->start)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500806 tty->ops->start(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808}
809
Peter Hurleyf9e053d2014-09-10 15:06:31 -0400810void start_tty(struct tty_struct *tty)
811{
812 unsigned long flags;
813
814 spin_lock_irqsave(&tty->flow_lock, flags);
815 __start_tty(tty);
816 spin_unlock_irqrestore(&tty->flow_lock, flags);
817}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818EXPORT_SYMBOL(start_tty);
819
Arnd Bergmannc884f872018-06-18 16:16:26 +0200820static void tty_update_time(struct timespec64 *time)
Jiri Slaby37b7f3c2013-04-26 13:48:53 +0200821{
Arnd Bergmannc884f872018-06-18 16:16:26 +0200822 time64_t sec = ktime_get_real_seconds();
Greg Kroah-Hartmanfbf47632015-03-26 23:10:27 +0100823
824 /*
825 * We only care if the two values differ in anything other than the
826 * lower three bits (i.e every 8 seconds). If so, then we can update
827 * the time of the tty device, otherwise it could be construded as a
828 * security leak to let userspace know the exact timing of the tty.
829 */
830 if ((sec ^ time->tv_sec) & ~7)
Jiri Slaby37b7f3c2013-04-26 13:48:53 +0200831 time->tv_sec = sec;
832}
833
Alan Coxaf9b8972006-08-27 01:24:01 -0700834/**
835 * tty_read - read method for tty device files
836 * @file: pointer to tty file
837 * @buf: user buffer
838 * @count: size of user buffer
839 * @ppos: unused
840 *
841 * Perform the read system call function on this terminal device. Checks
842 * for hung up devices before calling the line discipline method.
843 *
844 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700845 * Locks the line discipline internally while needed. Multiple
846 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700847 */
848
Alan Cox37bdfb02008-02-08 04:18:47 -0800849static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 loff_t *ppos)
851{
852 int i;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +0200853 struct inode *inode = file_inode(file);
Nick Piggind996b622010-08-18 04:37:36 +1000854 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 struct tty_ldisc *ld;
856
Jiri Slaby37b7f3c2013-04-26 13:48:53 +0200857 if (tty_paranoia_check(tty, inode, "tty_read"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 return -EIO;
Peter Hurley18900ca2016-04-09 17:06:48 -0700859 if (!tty || tty_io_error(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 return -EIO;
861
862 /* We want to wait for the line discipline to sort out in this
863 situation */
864 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -0800865 if (!ld)
866 return hung_up_tty_read(file, buf, count, ppos);
Alan Coxa352def2008-07-16 21:53:12 +0100867 if (ld->ops->read)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500868 i = ld->ops->read(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 else
870 i = -EIO;
871 tty_ldisc_deref(ld);
Jiri Slabyb0de59b2013-02-15 15:25:05 +0100872
Arnd Bergmannc884f872018-06-18 16:16:26 +0200873 if (i > 0)
874 tty_update_time(&inode->i_atime);
Jiri Slaby37b7f3c2013-04-26 13:48:53 +0200875
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return i;
877}
878
Peter Hurley136d5252014-09-10 15:06:34 -0400879static void tty_write_unlock(struct tty_struct *tty)
Alan Cox9c1729d2007-07-15 23:39:43 -0700880{
881 mutex_unlock(&tty->atomic_write_lock);
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800882 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700883}
884
Peter Hurley136d5252014-09-10 15:06:34 -0400885static int tty_write_lock(struct tty_struct *tty, int ndelay)
Alan Cox9c1729d2007-07-15 23:39:43 -0700886{
887 if (!mutex_trylock(&tty->atomic_write_lock)) {
888 if (ndelay)
889 return -EAGAIN;
890 if (mutex_lock_interruptible(&tty->atomic_write_lock))
891 return -ERESTARTSYS;
892 }
893 return 0;
894}
895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896/*
897 * Split writes up in sane blocksizes to avoid
898 * denial-of-service type attacks
899 */
900static inline ssize_t do_tty_write(
901 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
902 struct tty_struct *tty,
903 struct file *file,
904 const char __user *buf,
905 size_t count)
906{
Alan Cox9c1729d2007-07-15 23:39:43 -0700907 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -0800909
Alan Cox9c1729d2007-07-15 23:39:43 -0700910 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
911 if (ret < 0)
912 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
914 /*
915 * We chunk up writes into a temporary buffer. This
916 * simplifies low-level drivers immensely, since they
917 * don't have locking issues and user mode accesses.
918 *
919 * But if TTY_NO_WRITE_SPLIT is set, we should use a
920 * big chunk-size..
921 *
922 * The default chunk-size is 2kB, because the NTTY
923 * layer has problems with bigger chunks. It will
924 * claim to be able to handle more characters than
925 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -0700926 *
927 * FIXME: This can probably go away now except that 64K chunks
928 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 */
930 chunk = 2048;
931 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
932 chunk = 65536;
933 if (count < chunk)
934 chunk = count;
935
Ingo Molnar70522e12006-03-23 03:00:31 -0800936 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +0100938 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
940 if (chunk < 1024)
941 chunk = 1024;
942
Jason Wessel402fda92008-10-13 10:45:36 +0100943 buf_chunk = kmalloc(chunk, GFP_KERNEL);
944 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -0700945 ret = -ENOMEM;
946 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 }
948 kfree(tty->write_buf);
949 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +0100950 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 }
952
953 /* Do the write .. */
954 for (;;) {
955 size_t size = count;
956 if (size > chunk)
957 size = chunk;
958 ret = -EFAULT;
959 if (copy_from_user(tty->write_buf, buf, size))
960 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 if (ret <= 0)
963 break;
964 written += ret;
965 buf += ret;
966 count -= ret;
967 if (!count)
968 break;
969 ret = -ERESTARTSYS;
970 if (signal_pending(current))
971 break;
972 cond_resched();
973 }
Jiri Slaby37b7f3c2013-04-26 13:48:53 +0200974 if (written) {
Arnd Bergmannc884f872018-06-18 16:16:26 +0200975 tty_update_time(&file_inode(file)->i_mtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 ret = written;
Jiri Slaby37b7f3c2013-04-26 13:48:53 +0200977 }
Alan Cox9c1729d2007-07-15 23:39:43 -0700978out:
979 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 return ret;
981}
982
Alan Cox95f9bfc62008-10-13 10:39:23 +0100983/**
984 * tty_write_message - write a message to a certain tty, not just the console.
985 * @tty: the destination tty_struct
986 * @msg: the message to write
987 *
988 * This is used for messages that need to be redirected to a specific tty.
989 * We don't put it into the syslog queue right now maybe in the future if
990 * really needed.
991 *
Arnd Bergmannec79d602010-06-01 22:53:01 +0200992 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc62008-10-13 10:39:23 +0100993 */
994
995void tty_write_message(struct tty_struct *tty, char *msg)
996{
Alan Cox95f9bfc62008-10-13 10:39:23 +0100997 if (tty) {
998 mutex_lock(&tty->atomic_write_lock);
Alan Cox89c8d912012-08-08 16:30:13 +0100999 tty_lock(tty);
Peter Hurley4b41b952015-10-10 20:28:44 -04001000 if (tty->ops->write && tty->count > 0)
Alan Cox95f9bfc62008-10-13 10:39:23 +01001001 tty->ops->write(tty, msg, strlen(msg));
Peter Hurley4b41b952015-10-10 20:28:44 -04001002 tty_unlock(tty);
Alan Cox95f9bfc62008-10-13 10:39:23 +01001003 tty_write_unlock(tty);
1004 }
Alan Cox95f9bfc62008-10-13 10:39:23 +01001005 return;
1006}
1007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Alan Coxaf9b8972006-08-27 01:24:01 -07001009/**
1010 * tty_write - write method for tty device file
1011 * @file: tty file pointer
1012 * @buf: user data to write
1013 * @count: bytes to write
1014 * @ppos: unused
1015 *
1016 * Write data to a tty device via the line discipline.
1017 *
1018 * Locking:
1019 * Locks the line discipline as required
1020 * Writes to the tty driver are serialized by the atomic_write_lock
1021 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001022 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001023 */
1024
Alan Cox37bdfb02008-02-08 04:18:47 -08001025static ssize_t tty_write(struct file *file, const char __user *buf,
1026 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027{
Nick Piggind996b622010-08-18 04:37:36 +10001028 struct tty_struct *tty = file_tty(file);
1029 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001031
Al Viro6131ffa2013-02-27 16:59:05 -05001032 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 return -EIO;
Peter Hurley18900ca2016-04-09 17:06:48 -07001034 if (!tty || !tty->ops->write || tty_io_error(tty))
Alan Cox37bdfb02008-02-08 04:18:47 -08001035 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001036 /* Short term debug to catch buggy drivers */
1037 if (tty->ops->write_room == NULL)
Peter Hurley339f36b2015-11-08 13:01:13 -05001038 tty_err(tty, "missing write_room method\n");
Alan Cox37bdfb02008-02-08 04:18:47 -08001039 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08001040 if (!ld)
1041 return hung_up_tty_write(file, buf, count, ppos);
Alan Coxa352def2008-07-16 21:53:12 +01001042 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 ret = -EIO;
1044 else
Alan Coxa352def2008-07-16 21:53:12 +01001045 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 tty_ldisc_deref(ld);
1047 return ret;
1048}
1049
Alan Cox37bdfb02008-02-08 04:18:47 -08001050ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1051 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052{
1053 struct file *p = NULL;
1054
1055 spin_lock(&redirect_lock);
Al Virocb0942b2012-08-27 14:48:26 -04001056 if (redirect)
1057 p = get_file(redirect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 spin_unlock(&redirect_lock);
1059
1060 if (p) {
1061 ssize_t res;
1062 res = vfs_write(p, buf, count, &p->f_pos);
1063 fput(p);
1064 return res;
1065 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 return tty_write(file, buf, count, ppos);
1067}
1068
Peter Hurley136d5252014-09-10 15:06:34 -04001069/**
1070 * tty_send_xchar - send priority character
1071 *
1072 * Send a high priority character to the tty even if stopped
1073 *
1074 * Locking: none for xchar method, write ordering for write method.
1075 */
1076
1077int tty_send_xchar(struct tty_struct *tty, char ch)
1078{
1079 int was_stopped = tty->stopped;
1080
1081 if (tty->ops->send_xchar) {
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001082 down_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001083 tty->ops->send_xchar(tty, ch);
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001084 up_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001085 return 0;
1086 }
1087
1088 if (tty_write_lock(tty, 0) < 0)
1089 return -ERESTARTSYS;
1090
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001091 down_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001092 if (was_stopped)
1093 start_tty(tty);
1094 tty->ops->write(tty, &ch, 1);
1095 if (was_stopped)
1096 stop_tty(tty);
Peter Hurleyee0c1a62015-11-11 08:03:54 -05001097 up_read(&tty->termios_rwsem);
Peter Hurley136d5252014-09-10 15:06:34 -04001098 tty_write_unlock(tty);
1099 return 0;
1100}
1101
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102static char ptychar[] = "pqrstuvwxyzabcde";
1103
Alan Coxaf9b8972006-08-27 01:24:01 -07001104/**
1105 * pty_line_name - generate name for a pty
1106 * @driver: the tty driver in use
1107 * @index: the minor number
1108 * @p: output buffer of at least 6 bytes
1109 *
1110 * Generate a name from a driver reference and write it to the output
1111 * buffer.
1112 *
1113 * Locking: None
1114 */
1115static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116{
1117 int i = index + driver->name_base;
1118 /* ->name is initialized to "ttyp", but "tty" is expected */
1119 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001120 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1121 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122}
1123
Alan Coxaf9b8972006-08-27 01:24:01 -07001124/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001125 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001126 * @driver: the tty driver in use
1127 * @index: the minor number
1128 * @p: output buffer of at least 7 bytes
1129 *
1130 * Generate a name from a driver reference and write it to the output
Greg Kroah-Hartman5c0a2452014-02-22 14:31:04 -08001131 * buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07001132 *
1133 * Locking: None
1134 */
Hannes Reinecke723abd82014-02-27 12:30:51 +01001135static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136{
Jiri Slaby0019b402012-08-08 22:26:43 +02001137 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
Hannes Reinecke723abd82014-02-27 12:30:51 +01001138 return sprintf(p, "%s", driver->name);
Jiri Slaby0019b402012-08-08 22:26:43 +02001139 else
Hannes Reinecke723abd82014-02-27 12:30:51 +01001140 return sprintf(p, "%s%d", driver->name,
1141 index + driver->name_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142}
1143
Alan Cox99f1fe12008-10-13 10:42:00 +01001144/**
1145 * tty_driver_lookup_tty() - find an existing tty, if any
1146 * @driver: the driver for the tty
1147 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001148 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001149 * Return the tty, if found. If not found, return NULL or ERR_PTR() if the
1150 * driver lookup() method returns an error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001151 *
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001152 * Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001153 */
Jason Wessela47d5452009-01-02 13:43:04 +00001154static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07001155 struct file *file, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001156{
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001157 struct tty_struct *tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001158
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001159 if (driver->ops->lookup)
Okash Khawaja12e84c72017-05-15 18:45:32 +01001160 if (!file)
1161 tty = ERR_PTR(-EIO);
1162 else
1163 tty = driver->ops->lookup(driver, file, idx);
Peter Hurleyaa3cb812014-11-05 12:12:51 -05001164 else
1165 tty = driver->ttys[idx];
1166
1167 if (!IS_ERR(tty))
1168 tty_kref_get(tty);
1169 return tty;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001170}
1171
Alan Cox99f1fe12008-10-13 10:42:00 +01001172/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001173 * tty_init_termios - helper for termios setup
1174 * @tty: the tty to set up
1175 *
Johan Hovold8daa89e2019-04-18 18:05:54 +02001176 * Initialise the termios structure for this tty. This runs under
Alan Coxbf970ee2008-10-13 10:42:39 +01001177 * the tty_mutex currently so we can be relaxed about ordering.
1178 */
1179
Peter Hurleya3123fd2016-01-09 21:13:48 -08001180void tty_init_termios(struct tty_struct *tty)
Alan Coxbf970ee2008-10-13 10:42:39 +01001181{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001182 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001183 int idx = tty->index;
1184
Alan Cox36b3c072012-07-17 17:06:57 +01001185 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1186 tty->termios = tty->driver->init_termios;
1187 else {
1188 /* Check for lazy saved data */
1189 tp = tty->driver->termios[idx];
Peter Hurleyece53402016-01-10 22:40:57 -08001190 if (tp != NULL) {
Alan Cox36b3c072012-07-17 17:06:57 +01001191 tty->termios = *tp;
Peter Hurleyece53402016-01-10 22:40:57 -08001192 tty->termios.c_line = tty->driver->init_termios.c_line;
1193 } else
Alan Cox36b3c072012-07-17 17:06:57 +01001194 tty->termios = tty->driver->init_termios;
Alan Coxbf970ee2008-10-13 10:42:39 +01001195 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001196 /* Compatibility until drivers always set this */
Alan Coxadc8d742012-07-14 15:31:47 +01001197 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1198 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001199}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001200EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001201
Jiri Slaby66d450e2012-01-30 21:14:28 +01001202int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1203{
Peter Hurleya3123fd2016-01-09 21:13:48 -08001204 tty_init_termios(tty);
Jiri Slaby66d450e2012-01-30 21:14:28 +01001205 tty_driver_kref_get(driver);
1206 tty->count++;
1207 driver->ttys[tty->index] = tty;
1208 return 0;
1209}
1210EXPORT_SYMBOL_GPL(tty_standard_install);
1211
Alan Coxbf970ee2008-10-13 10:42:39 +01001212/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001213 * tty_driver_install_tty() - install a tty entry in the driver
1214 * @driver: the driver for the tty
1215 * @tty: the tty
1216 *
1217 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001218 * will be set by the time this is called. This method is responsible
1219 * for ensuring any need additional structures are allocated and
1220 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001221 *
1222 * Locking: tty_mutex for now
1223 */
1224static int tty_driver_install_tty(struct tty_driver *driver,
1225 struct tty_struct *tty)
1226{
Jiri Slaby66d450e2012-01-30 21:14:28 +01001227 return driver->ops->install ? driver->ops->install(driver, tty) :
1228 tty_standard_install(driver, tty);
Alan Cox8b0a88d2008-10-13 10:42:19 +01001229}
1230
1231/**
1232 * tty_driver_remove_tty() - remove a tty from the driver tables
1233 * @driver: the driver for the tty
1234 * @idx: the minor number
1235 *
1236 * Remvoe a tty object from the driver tables. The tty->index field
1237 * will be set by the time this is called.
1238 *
1239 * Locking: tty_mutex for now
1240 */
Peter Hurley05de87ed2016-01-09 21:13:49 -08001241static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +01001242{
1243 if (driver->ops->remove)
1244 driver->ops->remove(driver, tty);
1245 else
1246 driver->ttys[tty->index] = NULL;
1247}
1248
1249/*
1250 * tty_reopen() - fast re-open of an open tty
1251 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001252 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001253 * Return 0 on success, -errno on error.
Peter Hurley5d93e742014-11-05 12:12:47 -05001254 * Re-opens on master ptys are not allowed and return -EIO.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001255 *
Peter Hurley5d93e742014-11-05 12:12:47 -05001256 * Locking: Caller must hold tty_lock
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001257 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001258static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001259{
1260 struct tty_driver *driver = tty->driver;
Dmitry Safonovd3736d82019-01-09 01:17:40 +00001261 struct tty_ldisc *ld;
1262 int retval = 0;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001263
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001264 if (driver->type == TTY_DRIVER_TYPE_PTY &&
Peter Hurley5d93e742014-11-05 12:12:47 -05001265 driver->subtype == PTY_TYPE_MASTER)
1266 return -EIO;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001267
Peter Hurley7f22f6c92016-01-09 21:13:45 -08001268 if (!tty->count)
1269 return -EAGAIN;
1270
Peter Hurley86f2c002014-12-30 10:39:25 -05001271 if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1272 return -EBUSY;
1273
Dmitry Safonovd3736d82019-01-09 01:17:40 +00001274 ld = tty_ldisc_ref_wait(tty);
1275 if (ld) {
1276 tty_ldisc_deref(ld);
1277 } else {
1278 retval = tty_ldisc_lock(tty, 5 * HZ);
1279 if (retval)
1280 return retval;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001281
Dmitry Safonovd3736d82019-01-09 01:17:40 +00001282 if (!tty->ldisc)
1283 retval = tty_ldisc_reinit(tty, tty->termios.c_line);
1284 tty_ldisc_unlock(tty);
1285 }
Dmitry Safonovcf62a1a2018-11-01 00:24:49 +00001286
1287 if (retval == 0)
1288 tty->count++;
1289
Dmitry Safonovfe324162018-09-18 00:52:52 +01001290 return retval;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001291}
1292
Alan Coxaf9b8972006-08-27 01:24:01 -07001293/**
Alan Coxd81ed102008-10-13 10:41:42 +01001294 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001295 * @driver: tty driver we are opening a device on
1296 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001297 * @ret_tty: returned tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -07001298 *
1299 * Prepare a tty device. This may not be a "new" clean device but
1300 * could also be an active device. The pty drivers require special
1301 * handling because of this.
1302 *
1303 * Locking:
1304 * The function is called under the tty_mutex, which
1305 * protects us from the tty struct or driver itself going away.
1306 *
1307 * On exit the tty device has the line discipline attached and
1308 * a reference count of 1. If a pair was created for pty/tty use
1309 * and the other was a pty master then it too has a reference count of 1.
1310 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001312 * failed open. The new code protects the open with a mutex, so it's
1313 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 * relaxed for the (most common) case of reopening a tty.
1315 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001316
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001317struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
Alan Coxbf970ee2008-10-13 10:42:39 +01001319 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001320 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 /*
1323 * First time open is complex, especially for PTY devices.
1324 * This code guarantees that either everything succeeds and the
1325 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001326 * and the allocated memory released. (Except that the termios
Johan Hovold16b00ae2017-03-30 15:39:35 +02001327 * may be retained.)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 */
1329
Alan Cox73ec06f2008-10-13 10:42:29 +01001330 if (!try_module_get(driver->owner))
1331 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02001333 tty = alloc_tty_struct(driver, idx);
Jiri Slabyd5543502011-03-23 10:48:32 +01001334 if (!tty) {
1335 retval = -ENOMEM;
1336 goto err_module_put;
1337 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
Alan Cox89c8d912012-08-08 16:30:13 +01001339 tty_lock(tty);
Alan Cox73ec06f2008-10-13 10:42:29 +01001340 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001341 if (retval < 0)
Peter Hurleyc8b710b2016-01-09 21:13:46 -08001342 goto err_free_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001343
Jiri Slaby04831dc2012-06-04 13:35:36 +02001344 if (!tty->port)
1345 tty->port = driver->ports[idx];
1346
Jiri Slaby5d4121c2012-08-17 14:27:52 +02001347 WARN_RATELIMIT(!tty->port,
1348 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1349 __func__, tty->driver->name);
1350
Gaurav Kohlib027e222018-01-23 13:16:34 +05301351 retval = tty_ldisc_lock(tty, 5 * HZ);
1352 if (retval)
1353 goto err_release_lock;
Jiri Slaby967fab62012-10-18 22:26:46 +02001354 tty->port->itty = tty;
1355
Alan Cox37bdfb02008-02-08 04:18:47 -08001356 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001358 * If we fail here just call release_tty to clean up. No need
1359 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001361 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001362 if (retval)
Jiri Slabyd5543502011-03-23 10:48:32 +01001363 goto err_release_tty;
Gaurav Kohlib027e222018-01-23 13:16:34 +05301364 tty_ldisc_unlock(tty);
Alan Cox89c8d912012-08-08 16:30:13 +01001365 /* Return the tty locked so that it cannot vanish under the caller */
Alan Cox73ec06f2008-10-13 10:42:29 +01001366 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
Peter Hurleyc8b710b2016-01-09 21:13:46 -08001368err_free_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001369 tty_unlock(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001370 free_tty_struct(tty);
1371err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001373 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001375 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001376err_release_tty:
Gaurav Kohlib027e222018-01-23 13:16:34 +05301377 tty_ldisc_unlock(tty);
Peter Hurley339f36b2015-11-08 13:01:13 -05001378 tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
1379 retval, idx);
Gaurav Kohlib027e222018-01-23 13:16:34 +05301380err_release_lock:
1381 tty_unlock(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001382 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001383 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384}
1385
Johan Hovoldf51ccf42018-12-04 17:00:36 +01001386/**
1387 * tty_save_termios() - save tty termios data in driver table
1388 * @tty: tty whose termios data to save
1389 *
1390 * Locking: Caller guarantees serialisation with tty_init_termios().
1391 */
1392void tty_save_termios(struct tty_struct *tty)
Alan Coxfeebed62008-10-13 10:41:30 +01001393{
1394 struct ktermios *tp;
1395 int idx = tty->index;
Alan Cox36b3c072012-07-17 17:06:57 +01001396
1397 /* If the port is going to reset then it has no termios to save */
1398 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1399 return;
1400
1401 /* Stash the termios data */
1402 tp = tty->driver->termios[idx];
1403 if (tp == NULL) {
1404 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
Peter Hurley25080652015-11-08 13:01:11 -05001405 if (tp == NULL)
Alan Cox36b3c072012-07-17 17:06:57 +01001406 return;
Dan Carpenter4ac5d702012-07-24 12:51:52 +01001407 tty->driver->termios[idx] = tp;
Alan Coxfeebed62008-10-13 10:41:30 +01001408 }
Alan Cox36b3c072012-07-17 17:06:57 +01001409 *tp = tty->termios;
Alan Coxfeebed62008-10-13 10:41:30 +01001410}
Johan Hovoldf51ccf42018-12-04 17:00:36 +01001411EXPORT_SYMBOL_GPL(tty_save_termios);
Alan Coxfeebed62008-10-13 10:41:30 +01001412
Peter Hurleya2965b72013-03-11 16:44:35 -04001413/**
Peter Hurley949aa642014-11-05 12:12:57 -05001414 * tty_flush_works - flush all works of a tty/pty pair
1415 * @tty: tty device to flush works for (or either end of a pty pair)
Peter Hurleya2965b72013-03-11 16:44:35 -04001416 *
Peter Hurley949aa642014-11-05 12:12:57 -05001417 * Sync flush all works belonging to @tty (and the 'other' tty).
Peter Hurleya2965b72013-03-11 16:44:35 -04001418 */
1419static void tty_flush_works(struct tty_struct *tty)
1420{
1421 flush_work(&tty->SAK_work);
1422 flush_work(&tty->hangup_work);
Peter Hurley949aa642014-11-05 12:12:57 -05001423 if (tty->link) {
1424 flush_work(&tty->link->SAK_work);
1425 flush_work(&tty->link->hangup_work);
1426 }
Peter Hurleya2965b72013-03-11 16:44:35 -04001427}
Alan Coxfeebed62008-10-13 10:41:30 +01001428
Alan Coxaf9b8972006-08-27 01:24:01 -07001429/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001430 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001431 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001432 *
1433 * Releases memory associated with a tty structure, and clears out the
1434 * driver table slots. This function is called when a device is no longer
1435 * in use. It also gets called when setup of a device fails.
1436 *
1437 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -07001438 * takes the file list lock internally when working on the list
1439 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001440 *
1441 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001442 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 */
Alan Coxb50989d2009-09-19 13:13:22 -07001444static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445{
Alan Coxb50989d2009-09-19 13:13:22 -07001446 struct tty_struct *tty =
1447 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001448 struct tty_driver *driver = tty->driver;
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001449 struct module *owner = driver->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450
Dave Youngf278a2f2009-09-27 16:00:42 +00001451 if (tty->ops->cleanup)
1452 tty->ops->cleanup(tty);
1453
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001455 tty_driver_kref_put(driver);
Cyrill Gorcunovb216df52014-08-08 00:26:15 +04001456 module_put(owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001457
Peter Hurley4a510962016-01-09 21:35:23 -08001458 spin_lock(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 list_del_init(&tty->tty_files);
Peter Hurley4a510962016-01-09 21:35:23 -08001460 spin_unlock(&tty->files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001461
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001462 put_pid(tty->pgrp);
1463 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 free_tty_struct(tty);
1465}
1466
Alan Coxb50989d2009-09-19 13:13:22 -07001467static void queue_release_one_tty(struct kref *kref)
1468{
1469 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001470
Alan Coxb50989d2009-09-19 13:13:22 -07001471 /* The hangup queue is now free so we can reuse it rather than
1472 waste a chunk of memory for each port */
1473 INIT_WORK(&tty->hangup_work, release_one_tty);
1474 schedule_work(&tty->hangup_work);
1475}
1476
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001477/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001478 * tty_kref_put - release a tty kref
1479 * @tty: tty device
1480 *
1481 * Release a reference to a tty device and if need be let the kref
1482 * layer destruct the object for us
1483 */
1484
1485void tty_kref_put(struct tty_struct *tty)
1486{
1487 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001488 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001489}
1490EXPORT_SYMBOL(tty_kref_put);
1491
1492/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001493 * release_tty - release tty structure memory
1494 *
1495 * Release both @tty and a possible linked partner (think pty pair),
1496 * and decrement the refcount of the backing module.
1497 *
1498 * Locking:
Alan Coxd1552552012-07-27 18:02:54 +01001499 * tty_mutex
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001500 * takes the file list lock internally when working on the list
1501 * of ttys that the driver keeps.
Alan Cox9c9f4de2008-10-13 10:37:26 +01001502 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001503 */
1504static void release_tty(struct tty_struct *tty, int idx)
1505{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001506 /* This should always be true but check for the moment */
1507 WARN_ON(tty->index != idx);
Alan Coxd1552552012-07-27 18:02:54 +01001508 WARN_ON(!mutex_is_locked(&tty_mutex));
Alan Cox36b3c072012-07-17 17:06:57 +01001509 if (tty->ops->shutdown)
1510 tty->ops->shutdown(tty);
Johan Hovoldf51ccf42018-12-04 17:00:36 +01001511 tty_save_termios(tty);
Alan Cox36b3c072012-07-17 17:06:57 +01001512 tty_driver_remove_tty(tty->driver, tty);
Jiri Slaby967fab62012-10-18 22:26:46 +02001513 tty->port->itty = NULL;
Peter Hurley64e377d2013-06-15 09:01:00 -04001514 if (tty->link)
1515 tty->link->port->itty = NULL;
Peter Hurleye1760582015-10-17 16:36:23 -04001516 tty_buffer_cancel_work(tty->port);
Sahara2b022ab2017-12-13 09:10:48 +04001517 if (tty->link)
1518 tty_buffer_cancel_work(tty->link->port);
Alan Cox36b3c072012-07-17 17:06:57 +01001519
Markus Elfringa211b1a2014-11-21 13:42:29 +01001520 tty_kref_put(tty->link);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001521 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001522}
1523
Alan Coxeeb89d92009-11-30 13:18:29 +00001524/**
Jiri Slaby955787ca2011-11-11 10:47:23 +01001525 * tty_release_checks - check a tty before real release
1526 * @tty: tty to check
1527 * @o_tty: link of @tty (if any)
1528 * @idx: index of the tty
1529 *
1530 * Performs some paranoid checking before true release of the @tty.
1531 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1532 */
Peter Hurley359b9fb2014-11-05 12:12:59 -05001533static int tty_release_checks(struct tty_struct *tty, int idx)
Jiri Slaby955787ca2011-11-11 10:47:23 +01001534{
1535#ifdef TTY_PARANOIA_CHECK
1536 if (idx < 0 || idx >= tty->driver->num) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001537 tty_debug(tty, "bad idx %d\n", idx);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001538 return -1;
1539 }
1540
1541 /* not much to check for devpts */
1542 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1543 return 0;
1544
1545 if (tty != tty->driver->ttys[idx]) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001546 tty_debug(tty, "bad driver table[%d] = %p\n",
1547 idx, tty->driver->ttys[idx]);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001548 return -1;
1549 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001550 if (tty->driver->other) {
Peter Hurley359b9fb2014-11-05 12:12:59 -05001551 struct tty_struct *o_tty = tty->link;
1552
Jiri Slaby955787ca2011-11-11 10:47:23 +01001553 if (o_tty != tty->driver->other->ttys[idx]) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001554 tty_debug(tty, "bad other table[%d] = %p\n",
1555 idx, tty->driver->other->ttys[idx]);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001556 return -1;
1557 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001558 if (o_tty->link != tty) {
Peter Hurleye2dfa3d2015-07-12 22:49:08 -04001559 tty_debug(tty, "bad link = %p\n", o_tty->link);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001560 return -1;
1561 }
1562 }
1563#endif
1564 return 0;
1565}
1566
1567/**
Okash Khawajaa09ac392017-07-20 08:22:36 +01001568 * tty_kclose - closes tty opened by tty_kopen
1569 * @tty: tty device
1570 *
1571 * Performs the final steps to release and free a tty device. It is the
1572 * same as tty_release_struct except that it also resets TTY_PORT_KOPENED
1573 * flag on tty->port.
1574 */
1575void tty_kclose(struct tty_struct *tty)
1576{
1577 /*
1578 * Ask the line discipline code to release its structures
1579 */
1580 tty_ldisc_release(tty);
1581
1582 /* Wait for pending work before tty destruction commmences */
1583 tty_flush_works(tty);
1584
1585 tty_debug_hangup(tty, "freeing structure\n");
1586 /*
1587 * The release_tty function takes care of the details of clearing
1588 * the slots and preserving the termios structure. The tty_unlock_pair
1589 * should be safe as we keep a kref while the tty is locked (so the
1590 * unlock never unlocks a freed tty).
1591 */
1592 mutex_lock(&tty_mutex);
1593 tty_port_set_kopened(tty->port, 0);
1594 release_tty(tty, tty->index);
1595 mutex_unlock(&tty_mutex);
1596}
1597EXPORT_SYMBOL_GPL(tty_kclose);
1598
1599/**
Rob Herring9ed90d22017-01-16 16:54:28 -06001600 * tty_release_struct - release a tty struct
1601 * @tty: tty device
1602 * @idx: index of the tty
1603 *
1604 * Performs the final steps to release and free a tty device. It is
1605 * roughly the reverse of tty_init_dev.
1606 */
1607void tty_release_struct(struct tty_struct *tty, int idx)
1608{
1609 /*
1610 * Ask the line discipline code to release its structures
1611 */
1612 tty_ldisc_release(tty);
1613
1614 /* Wait for pending work before tty destruction commmences */
1615 tty_flush_works(tty);
1616
1617 tty_debug_hangup(tty, "freeing structure\n");
1618 /*
1619 * The release_tty function takes care of the details of clearing
1620 * the slots and preserving the termios structure. The tty_unlock_pair
1621 * should be safe as we keep a kref while the tty is locked (so the
1622 * unlock never unlocks a freed tty).
1623 */
1624 mutex_lock(&tty_mutex);
1625 release_tty(tty, idx);
1626 mutex_unlock(&tty_mutex);
1627}
1628EXPORT_SYMBOL_GPL(tty_release_struct);
1629
1630/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001631 * tty_release - vfs callback for close
1632 * @inode: inode of tty
1633 * @filp: file pointer for handle to tty
1634 *
1635 * Called the last time each file handle is closed that references
1636 * this tty. There may however be several such references.
1637 *
1638 * Locking:
1639 * Takes bkl. See tty_release_dev
1640 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 * Even releasing the tty structures is a tricky business.. We have
1642 * to be very careful that the structures are all released at the
1643 * same time, as interrupts might otherwise get the wrong pointers.
1644 *
1645 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1646 * lead to double frees or releasing memory still in use.
1647 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001648
1649int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650{
Nick Piggind996b622010-08-18 04:37:36 +10001651 struct tty_struct *tty = file_tty(filp);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001652 struct tty_struct *o_tty = NULL;
1653 int do_sleep, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 int idx;
Peter Hurley37b16452014-10-16 13:51:30 -04001655 long timeout = 0;
Peter Hurley494c1ea2014-10-16 13:54:36 -04001656 int once = 1;
Alan Cox37bdfb02008-02-08 04:18:47 -08001657
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001658 if (tty_paranoia_check(tty, inode, __func__))
Alan Coxeeb89d92009-11-30 13:18:29 +00001659 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Alan Cox89c8d912012-08-08 16:30:13 +01001661 tty_lock(tty);
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001662 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Arnd Bergmannec79d602010-06-01 22:53:01 +02001664 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 idx = tty->index;
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001667 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1668 tty->driver->subtype == PTY_TYPE_MASTER)
1669 o_tty = tty->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
Peter Hurley359b9fb2014-11-05 12:12:59 -05001671 if (tty_release_checks(tty, idx)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001672 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001673 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675
Peter Hurleyd435cef2015-11-08 13:01:19 -05001676 tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
Alan Coxf34d7a52008-04-30 00:54:13 -07001678 if (tty->ops->close)
1679 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
Peter Hurley2aff5e22014-11-05 12:13:01 -05001681 /* If tty is pty master, lock the slave pty (stable lock order) */
1682 tty_lock_slave(o_tty);
1683
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 /*
1685 * Sanity check: if tty->count is going to zero, there shouldn't be
1686 * any waiters on tty->read_wait or tty->write_wait. We test the
1687 * wait queues and kick everyone out _before_ actually starting to
1688 * close. This ensures that we won't block while releasing the tty
1689 * structure.
1690 *
1691 * The test for the o_tty closing is necessary, since the master and
1692 * slave sides may close in any order. If the slave side closes out
1693 * first, its count will be one, since the master side holds an open.
Peter Hurley324c1652014-11-05 12:12:56 -05001694 * Thus this test wouldn't be triggered at the time the slave closed,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 * so we do it now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 */
1697 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 do_sleep = 0;
1699
Peter Hurley324c1652014-11-05 12:12:56 -05001700 if (tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 if (waitqueue_active(&tty->read_wait)) {
Linus Torvaldsa9a08842018-02-11 14:34:03 -08001702 wake_up_poll(&tty->read_wait, EPOLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 do_sleep++;
1704 }
1705 if (waitqueue_active(&tty->write_wait)) {
Linus Torvaldsa9a08842018-02-11 14:34:03 -08001706 wake_up_poll(&tty->write_wait, EPOLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 do_sleep++;
1708 }
1709 }
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001710 if (o_tty && o_tty->count <= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 if (waitqueue_active(&o_tty->read_wait)) {
Linus Torvaldsa9a08842018-02-11 14:34:03 -08001712 wake_up_poll(&o_tty->read_wait, EPOLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 do_sleep++;
1714 }
1715 if (waitqueue_active(&o_tty->write_wait)) {
Linus Torvaldsa9a08842018-02-11 14:34:03 -08001716 wake_up_poll(&o_tty->write_wait, EPOLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 do_sleep++;
1718 }
1719 }
1720 if (!do_sleep)
1721 break;
1722
Peter Hurley494c1ea2014-10-16 13:54:36 -04001723 if (once) {
1724 once = 0;
Peter Hurley339f36b2015-11-08 13:01:13 -05001725 tty_warn(tty, "read/write wait queue active!\n");
Peter Hurley494c1ea2014-10-16 13:54:36 -04001726 }
Peter Hurley37b16452014-10-16 13:51:30 -04001727 schedule_timeout_killable(timeout);
1728 if (timeout < 120 * HZ)
1729 timeout = 2 * timeout + 1;
1730 else
1731 timeout = MAX_SCHEDULE_TIMEOUT;
Alan Cox37bdfb02008-02-08 04:18:47 -08001732 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001734 if (o_tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 if (--o_tty->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -05001736 tty_warn(tty, "bad slave count (%d)\n", o_tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 o_tty->count = 0;
1738 }
1739 }
1740 if (--tty->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -05001741 tty_warn(tty, "bad tty->count (%d)\n", tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 tty->count = 0;
1743 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001744
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 /*
1746 * We've decremented tty->count, so we need to remove this file
1747 * descriptor off the tty->tty_files list; this serves two
1748 * purposes:
1749 * - check_tty_count sees the correct number of file descriptors
1750 * associated with this tty.
1751 * - do_tty_hangup no longer sees this file descriptor as
1752 * something that needs to be handled for hangups.
1753 */
Nick Piggind996b622010-08-18 04:37:36 +10001754 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755
1756 /*
1757 * Perform some housekeeping before deciding whether to return.
1758 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 * If _either_ side is closing, make sure there aren't any
1760 * processes that still think tty or o_tty is their controlling
1761 * tty.
1762 */
Peter Hurley324c1652014-11-05 12:12:56 -05001763 if (!tty->count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001765 session_clear_tty(tty->session);
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001766 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001767 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 read_unlock(&tasklist_lock);
1769 }
1770
Peter Hurley324c1652014-11-05 12:12:56 -05001771 /* check whether both sides are closing ... */
Peter Hurley7ffb6da2014-11-05 12:13:00 -05001772 final = !tty->count && !(o_tty && o_tty->count);
Peter Hurley324c1652014-11-05 12:12:56 -05001773
Peter Hurley2aff5e22014-11-05 12:13:01 -05001774 tty_unlock_slave(o_tty);
1775 tty_unlock(tty);
1776
Peter Hurley04980702014-11-05 12:12:52 -05001777 /* At this point, the tty->count == 0 should ensure a dead tty
Alan Coxd1552552012-07-27 18:02:54 +01001778 cannot be re-opened by a racing opener */
Paul Fulghumda965822006-02-14 13:53:00 -08001779
Peter Hurley324c1652014-11-05 12:12:56 -05001780 if (!final)
Alan Coxeeb89d92009-11-30 13:18:29 +00001781 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001782
Peter Hurleyaccff792015-07-12 22:49:09 -04001783 tty_debug_hangup(tty, "final close\n");
Peter Hurleya2965b72013-03-11 16:44:35 -04001784
Rob Herring9ed90d22017-01-16 16:54:28 -06001785 tty_release_struct(tty, idx);
Alan Coxeeb89d92009-11-30 13:18:29 +00001786 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787}
1788
Alan Coxaf9b8972006-08-27 01:24:01 -07001789/**
Peter Hurley52494ee2014-11-05 12:12:50 -05001790 * tty_open_current_tty - get locked tty of current task
Jiri Slabyb82154a2011-11-09 21:33:19 +01001791 * @device: device number
1792 * @filp: file pointer to tty
Peter Hurley52494ee2014-11-05 12:12:50 -05001793 * @return: locked tty of the current task iff @device is /dev/tty
1794 *
1795 * Performs a re-open of the current task's controlling tty.
Jiri Slabyb82154a2011-11-09 21:33:19 +01001796 *
1797 * We cannot return driver and index like for the other nodes because
1798 * devpts will not work then. It expects inodes to be from devpts FS.
1799 */
1800static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1801{
1802 struct tty_struct *tty;
Peter Hurley52494ee2014-11-05 12:12:50 -05001803 int retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01001804
1805 if (device != MKDEV(TTYAUX_MAJOR, 0))
1806 return NULL;
1807
1808 tty = get_current_tty();
1809 if (!tty)
1810 return ERR_PTR(-ENXIO);
1811
1812 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1813 /* noctty = 1; */
Peter Hurley52494ee2014-11-05 12:12:50 -05001814 tty_lock(tty);
1815 tty_kref_put(tty); /* safe to drop the kref now */
1816
1817 retval = tty_reopen(tty);
1818 if (retval < 0) {
1819 tty_unlock(tty);
1820 tty = ERR_PTR(retval);
1821 }
Jiri Slabyb82154a2011-11-09 21:33:19 +01001822 return tty;
1823}
1824
1825/**
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001826 * tty_lookup_driver - lookup a tty driver for a given device file
1827 * @device: device number
1828 * @filp: file pointer to tty
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001829 * @index: index for the device in the @return driver
1830 * @return: driver for this inode (with increased refcount)
1831 *
1832 * If @return is not erroneous, the caller is responsible to decrement the
1833 * refcount by tty_driver_kref_put.
1834 *
1835 * Locking: tty_mutex protects get_tty_driver
1836 */
1837static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
Peter Hurley11e1d4a2016-01-09 21:13:52 -08001838 int *index)
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001839{
Lin Yi8c8af412019-05-10 12:22:57 +08001840 struct tty_driver *driver = NULL;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001841
Jiri Slaby2cd00502011-11-09 21:33:22 +01001842 switch (device) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001843#ifdef CONFIG_VT
Jiri Slaby2cd00502011-11-09 21:33:22 +01001844 case MKDEV(TTY_MAJOR, 0): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001845 extern struct tty_driver *console_driver;
1846 driver = tty_driver_kref_get(console_driver);
1847 *index = fg_console;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001848 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001849 }
1850#endif
Jiri Slaby2cd00502011-11-09 21:33:22 +01001851 case MKDEV(TTYAUX_MAJOR, 1): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001852 struct tty_driver *console_driver = console_device(index);
1853 if (console_driver) {
1854 driver = tty_driver_kref_get(console_driver);
Okash Khawaja12e84c72017-05-15 18:45:32 +01001855 if (driver && filp) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001856 /* Don't let /dev/console block */
1857 filp->f_flags |= O_NONBLOCK;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001858 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001859 }
1860 }
Lin Yi8c8af412019-05-10 12:22:57 +08001861 if (driver)
1862 tty_driver_kref_put(driver);
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001863 return ERR_PTR(-ENODEV);
1864 }
Jiri Slaby2cd00502011-11-09 21:33:22 +01001865 default:
1866 driver = get_tty_driver(device, index);
1867 if (!driver)
1868 return ERR_PTR(-ENODEV);
1869 break;
1870 }
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001871 return driver;
1872}
1873
1874/**
Okash Khawajaa09ac392017-07-20 08:22:36 +01001875 * tty_kopen - open a tty device for kernel
1876 * @device: dev_t of device to open
1877 *
1878 * Opens tty exclusively for kernel. Performs the driver lookup,
1879 * makes sure it's not already opened and performs the first-time
1880 * tty initialization.
1881 *
1882 * Returns the locked initialized &tty_struct
1883 *
1884 * Claims the global tty_mutex to serialize:
1885 * - concurrent first-time tty initialization
1886 * - concurrent tty driver removal w/ lookup
1887 * - concurrent tty removal from driver table
1888 */
1889struct tty_struct *tty_kopen(dev_t device)
1890{
1891 struct tty_struct *tty;
1892 struct tty_driver *driver = NULL;
1893 int index = -1;
1894
1895 mutex_lock(&tty_mutex);
1896 driver = tty_lookup_driver(device, NULL, &index);
1897 if (IS_ERR(driver)) {
1898 mutex_unlock(&tty_mutex);
1899 return ERR_CAST(driver);
1900 }
1901
1902 /* check whether we're reopening an existing tty */
1903 tty = tty_driver_lookup_tty(driver, NULL, index);
1904 if (IS_ERR(tty))
1905 goto out;
1906
1907 if (tty) {
1908 /* drop kref from tty_driver_lookup_tty() */
1909 tty_kref_put(tty);
1910 tty = ERR_PTR(-EBUSY);
1911 } else { /* tty_init_dev returns tty with the tty_lock held */
1912 tty = tty_init_dev(driver, index);
1913 if (IS_ERR(tty))
1914 goto out;
1915 tty_port_set_kopened(tty->port, 1);
1916 }
1917out:
1918 mutex_unlock(&tty_mutex);
1919 tty_driver_kref_put(driver);
1920 return tty;
1921}
1922EXPORT_SYMBOL_GPL(tty_kopen);
1923
1924/**
Peter Hurleyd6203d02016-01-09 21:13:53 -08001925 * tty_open_by_driver - open a tty device
1926 * @device: dev_t of device to open
1927 * @inode: inode of device file
1928 * @filp: file pointer to tty
1929 *
1930 * Performs the driver lookup, checks for a reopen, or otherwise
1931 * performs the first-time tty initialization.
1932 *
1933 * Returns the locked initialized or re-opened &tty_struct
1934 *
1935 * Claims the global tty_mutex to serialize:
1936 * - concurrent first-time tty initialization
1937 * - concurrent tty driver removal w/ lookup
1938 * - concurrent tty removal from driver table
1939 */
Okash Khawajaa033c3b2017-07-20 08:22:38 +01001940static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
Peter Hurleyd6203d02016-01-09 21:13:53 -08001941 struct file *filp)
1942{
1943 struct tty_struct *tty;
1944 struct tty_driver *driver = NULL;
1945 int index = -1;
1946 int retval;
1947
1948 mutex_lock(&tty_mutex);
1949 driver = tty_lookup_driver(device, filp, &index);
1950 if (IS_ERR(driver)) {
1951 mutex_unlock(&tty_mutex);
1952 return ERR_CAST(driver);
1953 }
1954
1955 /* check whether we're reopening an existing tty */
Linus Torvalds8ead9dd2016-04-25 20:04:08 -07001956 tty = tty_driver_lookup_tty(driver, filp, index);
Peter Hurleyd6203d02016-01-09 21:13:53 -08001957 if (IS_ERR(tty)) {
1958 mutex_unlock(&tty_mutex);
1959 goto out;
1960 }
1961
1962 if (tty) {
Okash Khawajaa09ac392017-07-20 08:22:36 +01001963 if (tty_port_kopened(tty->port)) {
1964 tty_kref_put(tty);
1965 mutex_unlock(&tty_mutex);
1966 tty = ERR_PTR(-EBUSY);
1967 goto out;
1968 }
Peter Hurleyd6203d02016-01-09 21:13:53 -08001969 mutex_unlock(&tty_mutex);
1970 retval = tty_lock_interruptible(tty);
Peter Hurley5e00bbfb2016-03-31 17:47:07 -07001971 tty_kref_put(tty); /* drop kref from tty_driver_lookup_tty() */
Peter Hurleyd6203d02016-01-09 21:13:53 -08001972 if (retval) {
1973 if (retval == -EINTR)
1974 retval = -ERESTARTSYS;
1975 tty = ERR_PTR(retval);
1976 goto out;
1977 }
Peter Hurleyd6203d02016-01-09 21:13:53 -08001978 retval = tty_reopen(tty);
1979 if (retval < 0) {
1980 tty_unlock(tty);
1981 tty = ERR_PTR(retval);
1982 }
1983 } else { /* Returns with the tty_lock held for now */
1984 tty = tty_init_dev(driver, index);
1985 mutex_unlock(&tty_mutex);
1986 }
1987out:
1988 tty_driver_kref_put(driver);
1989 return tty;
1990}
1991
1992/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001993 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001994 * @inode: inode of device file
1995 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001997 * tty_open and tty_release keep up the tty count that contains the
1998 * number of opens done on a tty. We cannot use the inode-count, as
1999 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002001 * Open-counting is needed for pty masters, as well as for keeping
2002 * track of serial lines: DTR is dropped when the last close happens.
2003 * (This is not done solely through tty->count, now. - Ted 1/27/92)
2004 *
2005 * The termios state of a pty is reset on first open so that
2006 * settings don't persist across reuse.
2007 *
Jiri Slaby5b5e7042011-11-09 21:33:20 +01002008 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002009 * tty->count should protect the rest.
2010 * ->siglock protects ->signal/->sighand
Alan Cox89c8d912012-08-08 16:30:13 +01002011 *
2012 * Note: the tty_unlock/lock cases without a ref are only safe due to
2013 * tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002015
Alan Coxeeb89d92009-11-30 13:18:29 +00002016static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017{
Jiri Slabyb82154a2011-11-09 21:33:19 +01002018 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 int noctty, retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07002021 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022
2023 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08002024
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025retry_open:
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002026 retval = tty_alloc_file(filp);
2027 if (retval)
2028 return -ENOMEM;
2029
Jiri Slabyb82154a2011-11-09 21:33:19 +01002030 tty = tty_open_current_tty(device, filp);
Peter Hurleyd6203d02016-01-09 21:13:53 -08002031 if (!tty)
2032 tty = tty_open_by_driver(device, inode, filp);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01002033
Alan Coxeeb89d92009-11-30 13:18:29 +00002034 if (IS_ERR(tty)) {
Peter Hurleyd6203d02016-01-09 21:13:53 -08002035 tty_free_file(filp);
Jiri Slabyba5db442011-11-09 21:33:21 +01002036 retval = PTR_ERR(tty);
Peter Hurley7f22f6c92016-01-09 21:13:45 -08002037 if (retval != -EAGAIN || signal_pending(current))
Peter Hurleyd6203d02016-01-09 21:13:53 -08002038 return retval;
Peter Hurley7f22f6c92016-01-09 21:13:45 -08002039 schedule();
2040 goto retry_open;
Alan Coxeeb89d92009-11-30 13:18:29 +00002041 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02002043 tty_add_file(tty, filp);
Nick Piggind996b622010-08-18 04:37:36 +10002044
Jiri Slaby9de44bd2011-11-09 21:33:24 +01002045 check_tty_count(tty, __func__);
Peter Hurleyd435cef2015-11-08 13:01:19 -05002046 tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
Peter Hurleyaccff792015-07-12 22:49:09 -04002047
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03002048 if (tty->ops->open)
2049 retval = tty->ops->open(tty, filp);
2050 else
2051 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 filp->f_flags = saved_flags;
2053
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 if (retval) {
Peter Hurleyd435cef2015-11-08 13:01:19 -05002055 tty_debug_hangup(tty, "open error %d, releasing\n", retval);
Peter Hurleyaccff792015-07-12 22:49:09 -04002056
Alan Cox89c8d912012-08-08 16:30:13 +01002057 tty_unlock(tty); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00002058 tty_release(inode, filp);
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002059 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 return retval;
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002061
2062 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 return retval;
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +02002064
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 schedule();
2066 /*
2067 * Need to reset f_op in case a hangup happened.
2068 */
Peter Hurley12569372014-11-05 12:26:24 -05002069 if (tty_hung_up_p(filp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 filp->f_op = &tty_fops;
2071 goto retry_open;
2072 }
Peter Hurleyd4855e12013-11-19 08:46:27 -05002073 clear_bit(TTY_HUPPED, &tty->flags);
Alan Coxeeb89d92009-11-30 13:18:29 +00002074
Peter Hurley11e1d4a2016-01-09 21:13:52 -08002075 noctty = (filp->f_flags & O_NOCTTY) ||
Nicolas Pitrea1235b32017-04-12 18:37:16 -04002076 (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
2077 device == MKDEV(TTYAUX_MAJOR, 1) ||
2078 (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2079 tty->driver->subtype == PTY_TYPE_MASTER);
2080 if (!noctty)
2081 tty_open_proc_set_tty(filp, tty);
Alan Cox89c8d912012-08-08 16:30:13 +01002082 tty_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 return 0;
2084}
2085
Jonathan Corbet39d95b92008-05-16 09:10:50 -06002086
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087
Alan Coxaf9b8972006-08-27 01:24:01 -07002088/**
2089 * tty_poll - check tty status
2090 * @filp: file being polled
2091 * @wait: poll wait structures to update
2092 *
2093 * Call the line discipline polling method to obtain the poll
2094 * status of the device.
2095 *
2096 * Locking: locks called line discipline but ldisc poll method
2097 * may be re-entered freely by other callers.
2098 */
2099
Al Viroafc9a422017-07-03 06:39:46 -04002100static __poll_t tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101{
Nick Piggind996b622010-08-18 04:37:36 +10002102 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 struct tty_ldisc *ld;
Al Viroe6c8adc2017-07-03 22:25:56 -04002104 __poll_t ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105
Al Viro6131ffa2013-02-27 16:59:05 -05002106 if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002108
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002110 if (!ld)
2111 return hung_up_tty_poll(filp, wait);
Alan Coxa352def2008-07-16 21:53:12 +01002112 if (ld->ops->poll)
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002113 ret = ld->ops->poll(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 tty_ldisc_deref(ld);
2115 return ret;
2116}
2117
Arnd Bergmannec79d602010-06-01 22:53:01 +02002118static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119{
Nick Piggind996b622010-08-18 04:37:36 +10002120 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07002121 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002122 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123
Al Viro6131ffa2013-02-27 16:59:05 -05002124 if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002125 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08002126
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 retval = fasync_helper(fd, filp, on, &tty->fasync);
2128 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002129 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130
2131 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002132 enum pid_type type;
2133 struct pid *pid;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002134
Alan Cox47f86832008-04-30 00:53:30 -07002135 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002136 if (tty->pgrp) {
2137 pid = tty->pgrp;
2138 type = PIDTYPE_PGID;
2139 } else {
2140 pid = task_pid(current);
Eric W. Biederman01919132017-07-16 22:05:57 -05002141 type = PIDTYPE_TGID;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002142 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002143 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002144 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002145 __f_setown(filp, pid, type, 0);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002146 put_pid(pid);
Jeff Laytone0b93ed2014-08-22 11:27:32 -04002147 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002149out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002150 return retval;
2151}
2152
2153static int tty_fasync(int fd, struct file *filp, int on)
2154{
Alan Cox89c8d912012-08-08 16:30:13 +01002155 struct tty_struct *tty = file_tty(filp);
Peter Hurleya8f3a292016-01-09 21:45:11 -08002156 int retval = -ENOTTY;
Alan Cox89c8d912012-08-08 16:30:13 +01002157
2158 tty_lock(tty);
Peter Hurleya8f3a292016-01-09 21:45:11 -08002159 if (!tty_hung_up_p(filp))
2160 retval = __tty_fasync(fd, filp, on);
Alan Cox89c8d912012-08-08 16:30:13 +01002161 tty_unlock(tty);
2162
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002163 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164}
2165
Alan Coxaf9b8972006-08-27 01:24:01 -07002166/**
2167 * tiocsti - fake input character
2168 * @tty: tty to fake input into
2169 * @p: pointer to character
2170 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002171 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002172 * input management.
2173 *
2174 * FIXME: does not honour flow control ??
2175 *
2176 * Locking:
Peter Hurley137084b2013-06-15 07:04:46 -04002177 * Called functions take tty_ldiscs_lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002178 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002179 *
2180 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002181 */
2182
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183static int tiocsti(struct tty_struct *tty, char __user *p)
2184{
2185 char ch, mbz = 0;
2186 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002187
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2189 return -EPERM;
2190 if (get_user(ch, p))
2191 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002192 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002194 if (!ld)
2195 return -EIO;
Greg Kroah-Hartman27cfb3a2019-01-20 10:46:58 +01002196 if (ld->ops->receive_buf)
2197 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 tty_ldisc_deref(ld);
2199 return 0;
2200}
2201
Alan Coxaf9b8972006-08-27 01:24:01 -07002202/**
2203 * tiocgwinsz - implement window query ioctl
2204 * @tty; tty
2205 * @arg: user buffer for result
2206 *
Alan Cox808a0d32006-09-29 02:00:40 -07002207 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002208 *
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002209 * Locking: tty->winsize_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002210 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002211 */
2212
Alan Cox37bdfb02008-02-08 04:18:47 -08002213static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214{
Alan Cox808a0d32006-09-29 02:00:40 -07002215 int err;
2216
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002217 mutex_lock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002218 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002219 mutex_unlock(&tty->winsize_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002220
2221 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222}
2223
Alan Coxaf9b8972006-08-27 01:24:01 -07002224/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002225 * tty_do_resize - resize event
2226 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002227 * @rows: rows (character)
2228 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002229 *
Daniel Mack3ad2f3fb2010-02-03 08:01:28 +08002230 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002231 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002232 */
2233
Alan Coxfc6f6232009-01-02 13:43:17 +00002234int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235{
Alan Coxfc6f6232009-01-02 13:43:17 +00002236 struct pid *pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
Alan Coxfc6f6232009-01-02 13:43:17 +00002238 /* Lock the tty */
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002239 mutex_lock(&tty->winsize_mutex);
Alan Coxfc6f6232009-01-02 13:43:17 +00002240 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002241 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002242
Peter Hurley5b239542014-10-16 14:59:45 -04002243 /* Signal the foreground process group */
2244 pgrp = tty_get_pgrp(tty);
Alan Cox47f86832008-04-30 00:53:30 -07002245 if (pgrp)
2246 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002247 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002248
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002249 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002250done:
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002251 mutex_unlock(&tty->winsize_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 return 0;
2253}
Martin Schwidefsky4d334fd2013-01-04 14:55:13 +01002254EXPORT_SYMBOL(tty_do_resize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255
Alan Coxaf9b8972006-08-27 01:24:01 -07002256/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002257 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002258 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002259 * @arg: user buffer for result
2260 *
2261 * Copies the user idea of the window size to the kernel. Traditionally
2262 * this is just advisory information but for the Linux console it
2263 * actually has driver level meaning and triggers a VC resize.
2264 *
2265 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002266 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002267 * tty termios mutex and ctrl_lock. The console takes its own lock
2268 * then calls into the default method.
2269 */
2270
Alan Coxfc6f6232009-01-02 13:43:17 +00002271static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002272{
2273 struct winsize tmp_ws;
2274 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2275 return -EFAULT;
2276
2277 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002278 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002279 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002280 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002281}
2282
2283/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002284 * tioccons - allow admin to move logical console
2285 * @file: the file to become console
2286 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002287 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002288 *
2289 * Locking: uses redirect_lock to guard the redirect information
2290 */
2291
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292static int tioccons(struct file *file)
2293{
2294 if (!capable(CAP_SYS_ADMIN))
2295 return -EPERM;
2296 if (file->f_op->write == redirected_tty_write) {
2297 struct file *f;
2298 spin_lock(&redirect_lock);
2299 f = redirect;
2300 redirect = NULL;
2301 spin_unlock(&redirect_lock);
2302 if (f)
2303 fput(f);
2304 return 0;
2305 }
2306 spin_lock(&redirect_lock);
2307 if (redirect) {
2308 spin_unlock(&redirect_lock);
2309 return -EBUSY;
2310 }
Al Virocb0942b2012-08-27 14:48:26 -04002311 redirect = get_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 spin_unlock(&redirect_lock);
2313 return 0;
2314}
2315
Alan Coxaf9b8972006-08-27 01:24:01 -07002316/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002317 * tiocsetd - set line discipline
2318 * @tty: tty device
2319 * @p: pointer to user data
2320 *
2321 * Set the line discipline according to user request.
2322 *
2323 * Locking: see tty_set_ldisc, this function is just a helper
2324 */
2325
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326static int tiocsetd(struct tty_struct *tty, int __user *p)
2327{
Peter Hurleyc12da962016-01-10 22:41:04 -08002328 int disc;
Alan Cox04f378b2008-04-30 00:53:29 -07002329 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330
Peter Hurleyc12da962016-01-10 22:41:04 -08002331 if (get_user(disc, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002333
Peter Hurleyc12da962016-01-10 22:41:04 -08002334 ret = tty_set_ldisc(tty, disc);
Alan Cox04f378b2008-04-30 00:53:29 -07002335
2336 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337}
2338
Alan Coxaf9b8972006-08-27 01:24:01 -07002339/**
Peter Hurley5c17c862016-01-10 22:40:55 -08002340 * tiocgetd - get line discipline
2341 * @tty: tty device
2342 * @p: pointer to user data
2343 *
2344 * Retrieves the line discipline id directly from the ldisc.
2345 *
2346 * Locking: waits for ldisc reference (in case the line discipline
2347 * is changing or the tty is being hungup)
2348 */
2349
2350static int tiocgetd(struct tty_struct *tty, int __user *p)
2351{
2352 struct tty_ldisc *ld;
2353 int ret;
2354
2355 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002356 if (!ld)
2357 return -EIO;
Peter Hurley5c17c862016-01-10 22:40:55 -08002358 ret = put_user(ld->ops->num, p);
2359 tty_ldisc_deref(ld);
2360 return ret;
2361}
2362
2363/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002364 * send_break - performed time break
2365 * @tty: device to break on
2366 * @duration: timeout in mS
2367 *
2368 * Perform a timed break on hardware that lacks its own driver level
2369 * timed break functionality.
2370 *
2371 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002372 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002373 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002374 */
2375
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002376static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377{
Alan Cox9e98966c2008-07-22 11:18:03 +01002378 int retval;
2379
2380 if (tty->ops->break_ctl == NULL)
2381 return 0;
2382
2383 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2384 retval = tty->ops->break_ctl(tty, duration);
2385 else {
2386 /* Do the work ourselves */
2387 if (tty_write_lock(tty, 0) < 0)
2388 return -EINTR;
2389 retval = tty->ops->break_ctl(tty, -1);
2390 if (retval)
2391 goto out;
2392 if (!signal_pending(current))
2393 msleep_interruptible(duration);
2394 retval = tty->ops->break_ctl(tty, 0);
2395out:
2396 tty_write_unlock(tty);
2397 if (signal_pending(current))
2398 retval = -EINTR;
2399 }
2400 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401}
2402
Alan Coxaf9b8972006-08-27 01:24:01 -07002403/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002404 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002405 * @tty: tty device
2406 * @file: user file pointer
2407 * @p: pointer to result
2408 *
2409 * Obtain the modem status bits from the tty driver if the feature
2410 * is supported. Return -EINVAL if it is not available.
2411 *
2412 * Locking: none (up to the driver)
2413 */
2414
Alan Cox60b33c12011-02-14 16:26:14 +00002415static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416{
2417 int retval = -EINVAL;
2418
Alan Coxf34d7a52008-04-30 00:54:13 -07002419 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002420 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421
2422 if (retval >= 0)
2423 retval = put_user(retval, p);
2424 }
2425 return retval;
2426}
2427
Alan Coxaf9b8972006-08-27 01:24:01 -07002428/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002429 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002430 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002431 * @cmd: command - clear bits, set bits or set all
2432 * @p: pointer to desired bits
2433 *
2434 * Set the modem status bits from the tty driver if the feature
2435 * is supported. Return -EINVAL if it is not available.
2436 *
2437 * Locking: none (up to the driver)
2438 */
2439
Alan Cox20b9d172011-02-14 16:26:50 +00002440static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 unsigned __user *p)
2442{
Alan Coxae677512008-07-16 21:56:54 +01002443 int retval;
2444 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445
Alan Coxae677512008-07-16 21:56:54 +01002446 if (tty->ops->tiocmset == NULL)
2447 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448
Alan Coxae677512008-07-16 21:56:54 +01002449 retval = get_user(val, p);
2450 if (retval)
2451 return retval;
2452 set = clear = 0;
2453 switch (cmd) {
2454 case TIOCMBIS:
2455 set = val;
2456 break;
2457 case TIOCMBIC:
2458 clear = val;
2459 break;
2460 case TIOCMSET:
2461 set = val;
2462 clear = ~val;
2463 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 }
Alan Coxae677512008-07-16 21:56:54 +01002465 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2466 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002467 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468}
2469
Alan Coxd281da72010-09-16 18:21:24 +01002470static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2471{
2472 int retval = -EINVAL;
2473 struct serial_icounter_struct icount;
2474 memset(&icount, 0, sizeof(icount));
2475 if (tty->ops->get_icount)
2476 retval = tty->ops->get_icount(tty, &icount);
2477 if (retval != 0)
2478 return retval;
2479 if (copy_to_user(arg, &icount, sizeof(icount)))
2480 return -EFAULT;
2481 return 0;
2482}
2483
Al Viro2f46a2c2018-09-11 21:53:32 -04002484static int tty_tiocsserial(struct tty_struct *tty, struct serial_struct __user *ss)
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002485{
2486 static DEFINE_RATELIMIT_STATE(depr_flags,
2487 DEFAULT_RATELIMIT_INTERVAL,
2488 DEFAULT_RATELIMIT_BURST);
2489 char comm[TASK_COMM_LEN];
Al Viro2f46a2c2018-09-11 21:53:32 -04002490 struct serial_struct v;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002491 int flags;
2492
Al Viro2f46a2c2018-09-11 21:53:32 -04002493 if (copy_from_user(&v, ss, sizeof(struct serial_struct)))
2494 return -EFAULT;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002495
Al Viro2f46a2c2018-09-11 21:53:32 -04002496 flags = v.flags & ASYNC_DEPRECATED;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002497
2498 if (flags && __ratelimit(&depr_flags))
Joe Perchesd437fa92017-02-16 23:11:44 -08002499 pr_warn("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2500 __func__, get_task_comm(comm, current), flags);
Al Viro2f46a2c2018-09-11 21:53:32 -04002501 if (!tty->ops->set_serial)
Al Viro930236a2018-09-12 07:46:51 -04002502 return -ENOTTY;
Al Viro2f46a2c2018-09-11 21:53:32 -04002503 return tty->ops->set_serial(tty, &v);
2504}
2505
2506static int tty_tiocgserial(struct tty_struct *tty, struct serial_struct __user *ss)
2507{
2508 struct serial_struct v;
2509 int err;
2510
2511 memset(&v, 0, sizeof(struct serial_struct));
2512 if (!tty->ops->get_serial)
Al Viro930236a2018-09-12 07:46:51 -04002513 return -ENOTTY;
Al Viro2f46a2c2018-09-11 21:53:32 -04002514 err = tty->ops->get_serial(tty, &v);
2515 if (!err && copy_to_user(ss, &v, sizeof(struct serial_struct)))
2516 err = -EFAULT;
2517 return err;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002518}
2519
Peter Hurley8f166e02014-10-16 14:59:41 -04002520/*
2521 * if pty, return the slave side (real_tty)
2522 * otherwise, return self
2523 */
2524static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
Alan Coxe8b70e72009-06-11 12:48:02 +01002525{
2526 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2527 tty->driver->subtype == PTY_TYPE_MASTER)
2528 tty = tty->link;
2529 return tty;
2530}
Alan Coxe8b70e72009-06-11 12:48:02 +01002531
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532/*
2533 * Split this up, as gcc can choke on it otherwise..
2534 */
Alan Cox04f378b2008-04-30 00:53:29 -07002535long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536{
Nick Piggind996b622010-08-18 04:37:36 +10002537 struct tty_struct *tty = file_tty(file);
2538 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 void __user *p = (void __user *)arg;
2540 int retval;
2541 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002542
Al Viro6131ffa2013-02-27 16:59:05 -05002543 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 return -EINVAL;
2545
Alan Coxe8b70e72009-06-11 12:48:02 +01002546 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547
2548 /*
2549 * Factor out some common prep work
2550 */
2551 switch (cmd) {
2552 case TIOCSETD:
2553 case TIOCSBRK:
2554 case TIOCCBRK:
2555 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002556 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 retval = tty_check_change(tty);
2558 if (retval)
2559 return retval;
2560 if (cmd != TIOCCBRK) {
2561 tty_wait_until_sent(tty, 0);
2562 if (signal_pending(current))
2563 return -EINTR;
2564 }
2565 break;
2566 }
2567
Alan Cox9e98966c2008-07-22 11:18:03 +01002568 /*
2569 * Now do the stuff.
2570 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002572 case TIOCSTI:
2573 return tiocsti(tty, p);
2574 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002575 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002576 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002577 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002578 case TIOCCONS:
2579 return real_tty != tty ? -EINVAL : tioccons(file);
Alan Cox37bdfb02008-02-08 04:18:47 -08002580 case TIOCEXCL:
2581 set_bit(TTY_EXCLUSIVE, &tty->flags);
2582 return 0;
2583 case TIOCNXCL:
2584 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2585 return 0;
Cyrill Gorcunov84fd7bd2012-10-24 23:43:22 +04002586 case TIOCGEXCL:
2587 {
2588 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2589 return put_user(excl, (int __user *)p);
2590 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002591 case TIOCGETD:
Peter Hurley5c17c862016-01-10 22:40:55 -08002592 return tiocgetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002593 case TIOCSETD:
2594 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002595 case TIOCVHANGUP:
2596 if (!capable(CAP_SYS_ADMIN))
2597 return -EPERM;
2598 tty_vhangup(tty);
2599 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002600 case TIOCGDEV:
2601 {
2602 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2603 return put_user(ret, (unsigned int __user *)p);
2604 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002605 /*
2606 * Break handling
2607 */
2608 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002609 if (tty->ops->break_ctl)
Alan Cox9e98966c2008-07-22 11:18:03 +01002610 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002611 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002612 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002613 if (tty->ops->break_ctl)
Alan Cox9e98966c2008-07-22 11:18:03 +01002614 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002615 return 0;
2616 case TCSBRK: /* SVID version: non-zero arg --> no break */
2617 /* non-zero arg means wait for all output data
2618 * to be sent (performed above) but don't send break.
2619 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002621 if (!arg)
2622 return send_break(tty, 250);
2623 return 0;
2624 case TCSBRKP: /* support for POSIX tcsendbreak() */
2625 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626
Alan Cox37bdfb02008-02-08 04:18:47 -08002627 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002628 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002629 case TIOCMSET:
2630 case TIOCMBIC:
2631 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002632 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002633 case TIOCGICOUNT:
Al Viroa3096192018-09-12 18:37:18 -04002634 return tty_tiocgicount(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002635 case TCFLSH:
2636 switch (arg) {
2637 case TCIFLUSH:
2638 case TCIOFLUSH:
2639 /* flush tty buffer and allow ldisc to process ioctl */
Peter Hurley86c80a82014-11-05 12:13:09 -05002640 tty_buffer_flush(tty, NULL);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002641 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002642 }
2643 break;
Jiri Slaby8a8ae622014-11-06 16:56:33 +01002644 case TIOCSSERIAL:
Al Viro930236a2018-09-12 07:46:51 -04002645 return tty_tiocsserial(tty, p);
Al Viro2f46a2c2018-09-11 21:53:32 -04002646 case TIOCGSERIAL:
Al Viro930236a2018-09-12 07:46:51 -04002647 return tty_tiocgserial(tty, p);
Eric W. Biederman311fc652017-08-24 15:13:29 -05002648 case TIOCGPTPEER:
2649 /* Special because the struct file is needed */
2650 return ptm_open_peer(file, tty, (int)arg);
Nicolas Pitrea1235b32017-04-12 18:37:16 -04002651 default:
2652 retval = tty_jobctrl_ioctl(tty, real_tty, file, cmd, arg);
2653 if (retval != -ENOIOCTLCMD)
2654 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002656 if (tty->ops->ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002657 retval = tty->ops->ioctl(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 if (retval != -ENOIOCTLCMD)
2659 return retval;
2660 }
2661 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002662 if (!ld)
2663 return hung_up_tty_ioctl(file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002665 if (ld->ops->ioctl) {
2666 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 if (retval == -ENOIOCTLCMD)
Wanlong Gaobbb63c52012-08-27 15:23:12 +08002668 retval = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 }
2670 tty_ldisc_deref(ld);
2671 return retval;
2672}
2673
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002674#ifdef CONFIG_COMPAT
Al Viro77654352018-09-12 11:28:34 -04002675
2676struct serial_struct32 {
2677 compat_int_t type;
2678 compat_int_t line;
2679 compat_uint_t port;
2680 compat_int_t irq;
2681 compat_int_t flags;
2682 compat_int_t xmit_fifo_size;
2683 compat_int_t custom_divisor;
2684 compat_int_t baud_base;
2685 unsigned short close_delay;
2686 char io_type;
2687 char reserved_char[1];
2688 compat_int_t hub6;
2689 unsigned short closing_wait; /* time to wait before closing */
2690 unsigned short closing_wait2; /* no longer used... */
2691 compat_uint_t iomem_base;
2692 unsigned short iomem_reg_shift;
2693 unsigned int port_high;
2694 /* compat_ulong_t iomap_base FIXME */
2695 compat_int_t reserved[1];
2696};
2697
2698static int compat_tty_tiocsserial(struct tty_struct *tty,
2699 struct serial_struct32 __user *ss)
2700{
2701 static DEFINE_RATELIMIT_STATE(depr_flags,
2702 DEFAULT_RATELIMIT_INTERVAL,
2703 DEFAULT_RATELIMIT_BURST);
2704 char comm[TASK_COMM_LEN];
2705 struct serial_struct32 v32;
2706 struct serial_struct v;
2707 int flags;
2708
2709 if (copy_from_user(&v32, ss, sizeof(struct serial_struct32)))
2710 return -EFAULT;
2711
2712 memcpy(&v, &v32, offsetof(struct serial_struct32, iomem_base));
2713 v.iomem_base = compat_ptr(v32.iomem_base);
2714 v.iomem_reg_shift = v32.iomem_reg_shift;
2715 v.port_high = v32.port_high;
2716 v.iomap_base = 0;
2717
2718 flags = v.flags & ASYNC_DEPRECATED;
2719
2720 if (flags && __ratelimit(&depr_flags))
2721 pr_warn("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2722 __func__, get_task_comm(comm, current), flags);
2723 if (!tty->ops->set_serial)
2724 return -ENOTTY;
2725 return tty->ops->set_serial(tty, &v);
2726}
2727
2728static int compat_tty_tiocgserial(struct tty_struct *tty,
2729 struct serial_struct32 __user *ss)
2730{
2731 struct serial_struct32 v32;
2732 struct serial_struct v;
2733 int err;
2734 memset(&v, 0, sizeof(struct serial_struct));
2735
2736 if (!tty->ops->set_serial)
2737 return -ENOTTY;
2738 err = tty->ops->get_serial(tty, &v);
2739 if (!err) {
2740 memcpy(&v32, &v, offsetof(struct serial_struct32, iomem_base));
2741 v32.iomem_base = (unsigned long)v.iomem_base >> 32 ?
2742 0xfffffff : ptr_to_compat(v.iomem_base);
2743 v32.iomem_reg_shift = v.iomem_reg_shift;
2744 v32.port_high = v.port_high;
2745 if (copy_to_user(ss, &v32, sizeof(struct serial_struct32)))
2746 err = -EFAULT;
2747 }
2748 return err;
2749}
Alan Cox37bdfb02008-02-08 04:18:47 -08002750static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002751 unsigned long arg)
2752{
Nick Piggind996b622010-08-18 04:37:36 +10002753 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002754 struct tty_ldisc *ld;
2755 int retval = -ENOIOCTLCMD;
2756
Al Viroe2112032018-09-11 19:47:09 -04002757 switch (cmd) {
2758 case TIOCSTI:
2759 case TIOCGWINSZ:
2760 case TIOCSWINSZ:
2761 case TIOCGEXCL:
2762 case TIOCGETD:
2763 case TIOCSETD:
2764 case TIOCGDEV:
2765 case TIOCMGET:
2766 case TIOCMSET:
2767 case TIOCMBIC:
2768 case TIOCMBIS:
2769 case TIOCGICOUNT:
2770 case TIOCGPGRP:
2771 case TIOCSPGRP:
2772 case TIOCGSID:
2773 case TIOCSERGETLSR:
2774 case TIOCGRS485:
2775 case TIOCSRS485:
2776#ifdef TIOCGETP
2777 case TIOCGETP:
2778 case TIOCSETP:
2779 case TIOCSETN:
2780#endif
2781#ifdef TIOCGETC
2782 case TIOCGETC:
2783 case TIOCSETC:
2784#endif
2785#ifdef TIOCGLTC
2786 case TIOCGLTC:
2787 case TIOCSLTC:
2788#endif
2789 case TCSETSF:
2790 case TCSETSW:
2791 case TCSETS:
2792 case TCGETS:
2793#ifdef TCGETS2
2794 case TCGETS2:
2795 case TCSETSF2:
2796 case TCSETSW2:
2797 case TCSETS2:
2798#endif
2799 case TCGETA:
2800 case TCSETAF:
2801 case TCSETAW:
2802 case TCSETA:
2803 case TIOCGLCKTRMIOS:
2804 case TIOCSLCKTRMIOS:
2805#ifdef TCGETX
2806 case TCGETX:
2807 case TCSETX:
2808 case TCSETXW:
2809 case TCSETXF:
2810#endif
2811 case TIOCGSOFTCAR:
2812 case TIOCSSOFTCAR:
2813 return tty_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
2814 case TIOCCONS:
2815 case TIOCEXCL:
2816 case TIOCNXCL:
2817 case TIOCVHANGUP:
2818 case TIOCSBRK:
2819 case TIOCCBRK:
2820 case TCSBRK:
2821 case TCSBRKP:
2822 case TCFLSH:
2823 case TIOCGPTPEER:
2824 case TIOCNOTTY:
2825 case TIOCSCTTY:
2826 case TCXONC:
2827 case TIOCMIWAIT:
2828 case TIOCSERCONFIG:
2829 return tty_ioctl(file, cmd, arg);
2830 }
2831
Al Viro6131ffa2013-02-27 16:59:05 -05002832 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002833 return -EINVAL;
2834
Al Viro77654352018-09-12 11:28:34 -04002835 switch (cmd) {
2836 case TIOCSSERIAL:
2837 return compat_tty_tiocsserial(tty, compat_ptr(arg));
2838 case TIOCGSERIAL:
2839 return compat_tty_tiocgserial(tty, compat_ptr(arg));
2840 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002841 if (tty->ops->compat_ioctl) {
Peter Hurleyc961bfb2014-11-05 12:26:25 -05002842 retval = tty->ops->compat_ioctl(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002843 if (retval != -ENOIOCTLCMD)
2844 return retval;
2845 }
2846
2847 ld = tty_ldisc_ref_wait(tty);
Peter Hurleye55afd12016-01-10 22:41:01 -08002848 if (!ld)
2849 return hung_up_tty_compat_ioctl(file, cmd, arg);
Alan Coxa352def2008-07-16 21:53:12 +01002850 if (ld->ops->compat_ioctl)
2851 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Al Virof0193d32018-09-13 22:12:15 -04002852 if (retval == -ENOIOCTLCMD && ld->ops->ioctl)
2853 retval = ld->ops->ioctl(tty, file,
2854 (unsigned long)compat_ptr(cmd), arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002855 tty_ldisc_deref(ld);
2856
2857 return retval;
2858}
2859#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860
Al Viroc3c073f2012-08-21 22:32:06 -04002861static int this_tty(const void *t, struct file *file, unsigned fd)
2862{
2863 if (likely(file->f_op->read != tty_read))
2864 return 0;
2865 return file_tty(file) != t ? 0 : fd + 1;
2866}
2867
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868/*
2869 * This implements the "Secure Attention Key" --- the idea is to
2870 * prevent trojan horses by killing all processes associated with this
2871 * tty when the user hits the "Secure Attention Key". Required for
2872 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002873 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 * This code could be nicer; ideally it should send a HUP, wait a few
2875 * seconds, then send a INT, and then a KILL signal. But you then
2876 * have to coordinate with the init process, since all processes associated
2877 * with the current tty must be dead before the new getty is allowed
2878 * to spawn.
2879 *
2880 * Now, if it would be correct ;-/ The current code has a nasty hole -
2881 * it doesn't catch files in flight. We may send the descriptor to ourselves
2882 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2883 *
2884 * Nasty bug: do_SAK is being called in interrupt context. This can
2885 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2886 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002887void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888{
2889#ifdef TTY_SOFT_SAK
2890 tty_hangup(tty);
2891#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002892 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002893 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -08002895
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 if (!tty)
2897 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002898 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002899
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002900 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901
Alan Coxf34d7a52008-04-30 00:54:13 -07002902 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002903
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002905 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002906 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05002907 tty_notice(tty, "SAK: killed process %d (%s): by session\n",
2908 task_pid_nr(p), p->comm);
Eric W. Biedermana8ebd172018-07-20 15:59:17 -05002909 group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p, PIDTYPE_SID);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002910 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Hurley9b42bb72015-11-08 13:01:14 -05002911
2912 /* Now kill any processes that happen to have the tty open */
Eric W. Biederman652486f2006-03-28 16:11:02 -08002913 do_each_thread(g, p) {
2914 if (p->signal->tty == tty) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05002915 tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n",
2916 task_pid_nr(p), p->comm);
Eric W. Biedermana8ebd172018-07-20 15:59:17 -05002917 group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p, PIDTYPE_SID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 continue;
2919 }
2920 task_lock(p);
Al Viroc3c073f2012-08-21 22:32:06 -04002921 i = iterate_fd(p->files, 0, this_tty, tty);
2922 if (i != 0) {
Peter Hurley9b42bb72015-11-08 13:01:14 -05002923 tty_notice(tty, "SAK: killed process %d (%s): by fd#%d\n",
2924 task_pid_nr(p), p->comm, i - 1);
Eric W. Biedermana8ebd172018-07-20 15:59:17 -05002925 group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p, PIDTYPE_SID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926 }
2927 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002928 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 read_unlock(&tasklist_lock);
2930#endif
2931}
2932
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002933static void do_SAK_work(struct work_struct *work)
2934{
2935 struct tty_struct *tty =
2936 container_of(work, struct tty_struct, SAK_work);
2937 __do_SAK(tty);
2938}
2939
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940/*
2941 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2942 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2943 * the values which we write to it will be identical to the values which it
2944 * already has. --akpm
2945 */
2946void do_SAK(struct tty_struct *tty)
2947{
2948 if (!tty)
2949 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950 schedule_work(&tty->SAK_work);
2951}
2952
2953EXPORT_SYMBOL(do_SAK);
2954
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08002955static int dev_match_devt(struct device *dev, const void *data)
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002956{
Greg Kroah-Hartman6e9430a2013-02-06 15:59:18 -08002957 const dev_t *devt = data;
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002958 return dev->devt == *devt;
2959}
2960
2961/* Must put_device() after it's unused! */
2962static struct device *tty_get_device(struct tty_struct *tty)
2963{
2964 dev_t devt = tty_devnum(tty);
2965 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2966}
2967
2968
Alan Coxaf9b8972006-08-27 01:24:01 -07002969/**
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02002970 * alloc_tty_struct
Alan Coxaf9b8972006-08-27 01:24:01 -07002971 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02002972 * This subroutine allocates and initializes a tty structure.
Alan Coxaf9b8972006-08-27 01:24:01 -07002973 *
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02002974 * Locking: none - tty in question is not exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002976
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02002977struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978{
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02002979 struct tty_struct *tty;
2980
2981 tty = kzalloc(sizeof(*tty), GFP_KERNEL);
2982 if (!tty)
2983 return NULL;
2984
Alan Cox9c9f4de2008-10-13 10:37:26 +01002985 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 tty->magic = TTY_MAGIC;
Tetsuo Handa903f9db2018-04-05 19:40:16 +09002987 if (tty_ldisc_init(tty)) {
2988 kfree(tty);
2989 return NULL;
2990 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002991 tty->session = NULL;
2992 tty->pgrp = NULL;
Alan Cox89c8d912012-08-08 16:30:13 +01002993 mutex_init(&tty->legacy_mutex);
Peter Hurleyd8c1f922013-06-15 09:14:31 -04002994 mutex_init(&tty->throttle_mutex);
Peter Hurley6a1c0682013-06-15 09:14:23 -04002995 init_rwsem(&tty->termios_rwsem);
Peter Hurleydee4a0b2013-07-24 16:43:51 -04002996 mutex_init(&tty->winsize_mutex);
Peter Hurley36697522013-06-15 07:04:48 -04002997 init_ldsem(&tty->ldisc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998 init_waitqueue_head(&tty->write_wait);
2999 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00003000 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08003001 mutex_init(&tty->atomic_write_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07003002 spin_lock_init(&tty->ctrl_lock);
Peter Hurleyf9e053d2014-09-10 15:06:31 -04003003 spin_lock_init(&tty->flow_lock);
Peter Hurley4a510962016-01-09 21:35:23 -08003004 spin_lock_init(&tty->files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07003006 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01003007
3008 tty->driver = driver;
3009 tty->ops = driver->ops;
3010 tty->index = idx;
3011 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04003012 tty->dev = tty_get_device(tty);
Rasmus Villemoes2c964a22014-07-10 21:01:22 +02003013
3014 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015}
3016
Alan Coxf34d7a52008-04-30 00:54:13 -07003017/**
3018 * tty_put_char - write one character to a tty
3019 * @tty: tty
3020 * @ch: character
3021 *
3022 * Write one byte to the tty using the provided put_char method
3023 * if present. Returns the number of characters successfully output.
3024 *
3025 * Note: the specific put_char operation in the driver layer may go
3026 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003028
Alan Coxf34d7a52008-04-30 00:54:13 -07003029int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030{
Alan Coxf34d7a52008-04-30 00:54:13 -07003031 if (tty->ops->put_char)
3032 return tty->ops->put_char(tty, ch);
3033 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034}
Alan Coxf34d7a52008-04-30 00:54:13 -07003035EXPORT_SYMBOL_GPL(tty_put_char);
3036
Alan Coxd81ed102008-10-13 10:41:42 +01003037struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003039static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3040 unsigned int index, unsigned int count)
3041{
Leon Yuc1a752b2015-09-07 13:08:37 +00003042 int err;
3043
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003044 /* init here, since reused cdevs cause crashes */
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003045 driver->cdevs[index] = cdev_alloc();
3046 if (!driver->cdevs[index])
3047 return -ENOMEM;
Leon Yuc1a752b2015-09-07 13:08:37 +00003048 driver->cdevs[index]->ops = &tty_fops;
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003049 driver->cdevs[index]->owner = driver->owner;
Leon Yuc1a752b2015-09-07 13:08:37 +00003050 err = cdev_add(driver->cdevs[index], dev, count);
3051 if (err)
3052 kobject_put(&driver->cdevs[index]->kobj);
3053 return err;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003054}
3055
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003057 * tty_register_device - register a tty device
3058 * @driver: the tty driver that describes the tty device
3059 * @index: the index in the tty driver for this tty device
3060 * @device: a struct device that is associated with this tty device.
3061 * This field is optional, if there is no known struct device
3062 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003064 * Returns a pointer to the struct device for this tty device
3065 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003066 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003067 * This call is required to be made to register an individual tty device
3068 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3069 * that bit is not set, this function should not be called by a tty
3070 * driver.
3071 *
3072 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003073 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003074
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003075struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3076 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077{
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003078 return tty_register_device_attr(driver, index, device, NULL, NULL);
3079}
3080EXPORT_SYMBOL(tty_register_device);
3081
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003082static void tty_device_create_release(struct device *dev)
3083{
Peter Hurley83db1df42015-11-08 13:01:21 -05003084 dev_dbg(dev, "releasing...\n");
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003085 kfree(dev);
3086}
3087
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003088/**
3089 * tty_register_device_attr - register a tty device
3090 * @driver: the tty driver that describes the tty device
3091 * @index: the index in the tty driver for this tty device
3092 * @device: a struct device that is associated with this tty device.
3093 * This field is optional, if there is no known struct device
3094 * for this tty device it can be set to NULL safely.
3095 * @drvdata: Driver data to be set to device.
3096 * @attr_grp: Attribute group to be set on device.
3097 *
3098 * Returns a pointer to the struct device for this tty device
3099 * (or ERR_PTR(-EFOO) on error).
3100 *
3101 * This call is required to be made to register an individual tty device
3102 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3103 * that bit is not set, this function should not be called by a tty
3104 * driver.
3105 *
3106 * Locking: ??
3107 */
3108struct device *tty_register_device_attr(struct tty_driver *driver,
3109 unsigned index, struct device *device,
3110 void *drvdata,
3111 const struct attribute_group **attr_grp)
3112{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113 char name[64];
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003114 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
Johan Hovold93857ed2017-03-30 15:39:36 +02003115 struct ktermios *tp;
Johan Hovold6a7e6f72017-03-30 15:39:34 +02003116 struct device *dev;
3117 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118
3119 if (index >= driver->num) {
Peter Hurley656fb862015-11-08 13:01:15 -05003120 pr_err("%s: Attempt to register invalid tty line number (%d)\n",
3121 driver->name, index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003122 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 }
3124
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 if (driver->type == TTY_DRIVER_TYPE_PTY)
3126 pty_line_name(driver, index, name);
3127 else
3128 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003129
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003130 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
Johan Hovold6a7e6f72017-03-30 15:39:34 +02003131 if (!dev)
3132 return ERR_PTR(-ENOMEM);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003133
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003134 dev->devt = devt;
3135 dev->class = tty_class;
3136 dev->parent = device;
Tomas Hlavacekb1b79912012-09-06 23:17:47 +02003137 dev->release = tty_device_create_release;
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003138 dev_set_name(dev, "%s", name);
3139 dev->groups = attr_grp;
3140 dev_set_drvdata(dev, drvdata);
3141
Johan Hovold6a7e6f72017-03-30 15:39:34 +02003142 dev_set_uevent_suppress(dev, 1);
3143
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003144 retval = device_register(dev);
3145 if (retval)
Johan Hovold6a7e6f72017-03-30 15:39:34 +02003146 goto err_put;
3147
3148 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
Johan Hovold93857ed2017-03-30 15:39:36 +02003149 /*
3150 * Free any saved termios data so that the termios state is
3151 * reset when reusing a minor number.
3152 */
3153 tp = driver->termios[index];
3154 if (tp) {
3155 driver->termios[index] = NULL;
3156 kfree(tp);
3157 }
3158
Johan Hovold6a7e6f72017-03-30 15:39:34 +02003159 retval = tty_cdev_add(driver, devt, index, 1);
3160 if (retval)
3161 goto err_del;
3162 }
3163
3164 dev_set_uevent_suppress(dev, 0);
3165 kobject_uevent(&dev->kobj, KOBJ_ADD);
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003166
3167 return dev;
3168
Johan Hovold6a7e6f72017-03-30 15:39:34 +02003169err_del:
3170 device_del(dev);
3171err_put:
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003172 put_device(dev);
Johan Hovold6a7e6f72017-03-30 15:39:34 +02003173
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003174 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003175}
Tomas Hlavacek6915c0e2012-09-06 03:17:18 +02003176EXPORT_SYMBOL_GPL(tty_register_device_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177
3178/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003179 * tty_unregister_device - unregister a tty device
3180 * @driver: the tty driver that describes the tty device
3181 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003183 * If a tty device is registered with a call to tty_register_device() then
3184 * this function must be called when the tty device is gone.
3185 *
3186 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003188
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189void tty_unregister_device(struct tty_driver *driver, unsigned index)
3190{
Alan Cox37bdfb02008-02-08 04:18:47 -08003191 device_destroy(tty_class,
3192 MKDEV(driver->major, driver->minor_start) + index);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003193 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3194 cdev_del(driver->cdevs[index]);
3195 driver->cdevs[index] = NULL;
3196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003197}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003198EXPORT_SYMBOL(tty_unregister_device);
3199
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003200/**
3201 * __tty_alloc_driver -- allocate tty driver
3202 * @lines: count of lines this driver can handle at most
Thadeu Lima de Souza Cascardo87838ae2017-04-04 05:56:32 -03003203 * @owner: module which is responsible for this driver
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003204 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3205 *
3206 * This should not be called directly, some of the provided macros should be
3207 * used instead. Use IS_ERR and friends on @retval.
3208 */
3209struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3210 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211{
3212 struct tty_driver *driver;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003213 unsigned int cdevs = 1;
Jiri Slaby16a02082012-08-08 22:26:42 +02003214 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215
Jiri Slaby0019b402012-08-08 22:26:43 +02003216 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003217 return ERR_PTR(-EINVAL);
3218
Jean Delvare506eb992007-07-15 23:40:14 -07003219 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003220 if (!driver)
3221 return ERR_PTR(-ENOMEM);
3222
3223 kref_init(&driver->kref);
3224 driver->magic = TTY_DRIVER_MAGIC;
3225 driver->num = lines;
3226 driver->owner = owner;
3227 driver->flags = flags;
Jiri Slaby16a02082012-08-08 22:26:42 +02003228
3229 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3230 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3231 GFP_KERNEL);
3232 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3233 GFP_KERNEL);
3234 if (!driver->ttys || !driver->termios) {
3235 err = -ENOMEM;
3236 goto err_free_all;
3237 }
3238 }
3239
3240 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3241 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3242 GFP_KERNEL);
3243 if (!driver->ports) {
3244 err = -ENOMEM;
3245 goto err_free_all;
3246 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003247 cdevs = lines;
3248 }
3249
3250 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3251 if (!driver->cdevs) {
3252 err = -ENOMEM;
3253 goto err_free_all;
Jiri Slaby16a02082012-08-08 22:26:42 +02003254 }
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003255
Linus Torvalds1da177e2005-04-16 15:20:36 -07003256 return driver;
Jiri Slaby16a02082012-08-08 22:26:42 +02003257err_free_all:
3258 kfree(driver->ports);
3259 kfree(driver->ttys);
3260 kfree(driver->termios);
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003261 kfree(driver->cdevs);
Jiri Slaby16a02082012-08-08 22:26:42 +02003262 kfree(driver);
3263 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264}
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003265EXPORT_SYMBOL(__tty_alloc_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003266
Alan Cox7d7b93c2008-10-13 10:42:09 +01003267static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003268{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003269 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3270 int i;
3271 struct ktermios *tp;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003272
3273 if (driver->flags & TTY_DRIVER_INSTALLED) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01003274 for (i = 0; i < driver->num; i++) {
3275 tp = driver->termios[i];
3276 if (tp) {
3277 driver->termios[i] = NULL;
3278 kfree(tp);
3279 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003280 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3281 tty_unregister_device(driver, i);
3282 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003283 proc_tty_unregister_driver(driver);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003284 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
Richard Wattsa3a10ce2015-05-19 16:06:53 +01003285 cdev_del(driver->cdevs[0]);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003286 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003287 kfree(driver->cdevs);
Jiri Slaby04831dc2012-06-04 13:35:36 +02003288 kfree(driver->ports);
Jiri Slaby16a02082012-08-08 22:26:42 +02003289 kfree(driver->termios);
3290 kfree(driver->ttys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291 kfree(driver);
3292}
3293
Alan Cox7d7b93c2008-10-13 10:42:09 +01003294void tty_driver_kref_put(struct tty_driver *driver)
3295{
3296 kref_put(&driver->kref, destruct_tty_driver);
3297}
3298EXPORT_SYMBOL(tty_driver_kref_put);
3299
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003300void tty_set_operations(struct tty_driver *driver,
3301 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302{
Alan Coxf34d7a52008-04-30 00:54:13 -07003303 driver->ops = op;
3304};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305EXPORT_SYMBOL(tty_set_operations);
3306
Alan Cox7d7b93c2008-10-13 10:42:09 +01003307void put_tty_driver(struct tty_driver *d)
3308{
3309 tty_driver_kref_put(d);
3310}
3311EXPORT_SYMBOL(put_tty_driver);
3312
Linus Torvalds1da177e2005-04-16 15:20:36 -07003313/*
3314 * Called by a tty driver to register itself.
3315 */
3316int tty_register_driver(struct tty_driver *driver)
3317{
3318 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003319 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 dev_t dev;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003321 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003324 error = alloc_chrdev_region(&dev, driver->minor_start,
3325 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326 if (!error) {
3327 driver->major = MAJOR(dev);
3328 driver->minor_start = MINOR(dev);
3329 }
3330 } else {
3331 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003332 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333 }
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003334 if (error < 0)
Jiri Slaby16a02082012-08-08 22:26:42 +02003335 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003336
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003337 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3338 error = tty_cdev_add(driver, dev, 0, driver->num);
3339 if (error)
3340 goto err_unreg_char;
3341 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003343 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003345 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003346
3347 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003348 for (i = 0; i < driver->num; i++) {
3349 d = tty_register_device(driver, i, NULL);
3350 if (IS_ERR(d)) {
3351 error = PTR_ERR(d);
Jiri Slaby16a02082012-08-08 22:26:42 +02003352 goto err_unreg_devs;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003353 }
3354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355 }
3356 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003357 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003359
Jiri Slaby16a02082012-08-08 22:26:42 +02003360err_unreg_devs:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003361 for (i--; i >= 0; i--)
3362 tty_unregister_device(driver, i);
3363
3364 mutex_lock(&tty_mutex);
3365 list_del(&driver->tty_drivers);
3366 mutex_unlock(&tty_mutex);
3367
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003368err_unreg_char:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003369 unregister_chrdev_region(dev, driver->num);
Jiri Slaby16a02082012-08-08 22:26:42 +02003370err:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003371 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003372}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373EXPORT_SYMBOL(tty_register_driver);
3374
3375/*
3376 * Called by a tty driver to unregister itself.
3377 */
3378int tty_unregister_driver(struct tty_driver *driver)
3379{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003380#if 0
3381 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382 if (driver->refcount)
3383 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003384#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3386 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003387 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003389 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003390 return 0;
3391}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003392
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393EXPORT_SYMBOL(tty_unregister_driver);
3394
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003395dev_t tty_devnum(struct tty_struct *tty)
3396{
3397 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3398}
3399EXPORT_SYMBOL(tty_devnum);
3400
Alan Coxd81ed102008-10-13 10:41:42 +01003401void tty_default_fops(struct file_operations *fops)
3402{
3403 *fops = tty_fops;
3404}
3405
Al Viro2c9ede52011-07-23 20:24:48 -04003406static char *tty_devnode(struct device *dev, umode_t *mode)
Kay Sieverse454cea2009-09-18 23:01:12 +02003407{
3408 if (!mode)
3409 return NULL;
3410 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3411 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3412 *mode = 0666;
3413 return NULL;
3414}
3415
Linus Torvalds1da177e2005-04-16 15:20:36 -07003416static int __init tty_class_init(void)
3417{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003418 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419 if (IS_ERR(tty_class))
3420 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003421 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422 return 0;
3423}
3424
3425postcore_initcall(tty_class_init);
3426
3427/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003429
Kay Sieversfbc92a32010-12-01 18:51:05 +01003430static ssize_t show_cons_active(struct device *dev,
3431 struct device_attribute *attr, char *buf)
3432{
3433 struct console *cs[16];
3434 int i = 0;
3435 struct console *c;
3436 ssize_t count = 0;
3437
Torben Hohnac751ef2011-01-25 15:07:35 -08003438 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003439 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003440 if (!c->device)
3441 continue;
3442 if (!c->write)
3443 continue;
3444 if ((c->flags & CON_ENABLED) == 0)
3445 continue;
3446 cs[i++] = c;
3447 if (i >= ARRAY_SIZE(cs))
3448 break;
3449 }
Hannes Reinecke723abd82014-02-27 12:30:51 +01003450 while (i--) {
3451 int index = cs[i]->index;
3452 struct tty_driver *drv = cs[i]->device(cs[i], &index);
3453
3454 /* don't resolve tty0 as some programs depend on it */
3455 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
3456 count += tty_line_name(drv, index, buf + count);
3457 else
3458 count += sprintf(buf + count, "%s%d",
3459 cs[i]->name, cs[i]->index);
3460
3461 count += sprintf(buf + count, "%c", i ? ' ':'\n');
3462 }
Torben Hohnac751ef2011-01-25 15:07:35 -08003463 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003464
3465 return count;
3466}
3467static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3468
Takashi Iwai1083a7b2015-02-05 11:07:42 +01003469static struct attribute *cons_dev_attrs[] = {
3470 &dev_attr_active.attr,
3471 NULL
3472};
3473
3474ATTRIBUTE_GROUPS(cons_dev);
3475
Kay Sieversfbc92a32010-12-01 18:51:05 +01003476static struct device *consdev;
3477
3478void console_sysfs_notify(void)
3479{
3480 if (consdev)
3481 sysfs_notify(&consdev->kobj, NULL, "active");
3482}
3483
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484/*
3485 * Ok, now we can initialize the rest of the tty devices and can count
3486 * on memory allocations, interrupts etc..
3487 */
David Howells31d1d482010-08-06 16:34:43 +01003488int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489{
Greg Kroah-Hartman7c0cca72019-01-21 17:26:42 +01003490 tty_sysctl_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491 cdev_init(&tty_cdev, &tty_fops);
3492 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3493 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3494 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003495 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496
3497 cdev_init(&console_cdev, &console_fops);
3498 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3499 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3500 panic("Couldn't register /dev/console driver\n");
Takashi Iwai1083a7b2015-02-05 11:07:42 +01003501 consdev = device_create_with_groups(tty_class, NULL,
3502 MKDEV(TTYAUX_MAJOR, 1), NULL,
3503 cons_dev_groups, "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003504 if (IS_ERR(consdev))
3505 consdev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003508 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509#endif
3510 return 0;
3511}
David Howells31d1d482010-08-06 16:34:43 +01003512