tty: use min() in iterate_tty_write()
[linux-2.6-block.git] / drivers / tty / tty_io.c
CommitLineData
e3b3d0f5 1// SPDX-License-Identifier: GPL-2.0
1da177e4 2/*
1da177e4
LT
3 * 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
37bdfb07 21 * makes for cleaner and more compact code. -TYT, 9/17/92
1da177e4
LT
22 *
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.
395e7833 36 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
1da177e4
LT
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
37bdfb07 43 *
1da177e4
LT
44 * 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 *
d81ed103 51 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
1da177e4
LT
52 * -- 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.
37bdfb07
AC
64 * alloc_tty_struct() always uses kmalloc()
65 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
1da177e4
LT
66 */
67
1da177e4
LT
68#include <linux/types.h>
69#include <linux/major.h>
70#include <linux/errno.h>
71#include <linux/signal.h>
72#include <linux/fcntl.h>
3f07c014 73#include <linux/sched/signal.h>
29930025 74#include <linux/sched/task.h>
1da177e4
LT
75#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>
9f3acc31 81#include <linux/fdtable.h>
1da177e4
LT
82#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>
b7aff093 90#include <linux/ppp-ioctl.h>
1da177e4
LT
91#include <linux/proc_fs.h>
92#include <linux/init.h>
93#include <linux/module.h>
1da177e4 94#include <linux/device.h>
1da177e4
LT
95#include <linux/wait.h>
96#include <linux/bitops.h>
b20f3ae5 97#include <linux/delay.h>
a352def2 98#include <linux/seq_file.h>
d281da7f 99#include <linux/serial.h>
5a3c6b25 100#include <linux/ratelimit.h>
e2112038 101#include <linux/compat.h>
a352def2 102#include <linux/uaccess.h>
c9874d3f 103#include <linux/termios_internal.h>
360c11e2 104#include <linux/fs.h>
1da177e4
LT
105
106#include <linux/kbd_kern.h>
107#include <linux/vt_kern.h>
108#include <linux/selection.h>
1da177e4
LT
109
110#include <linux/kmod.h>
b488893a 111#include <linux/nsproxy.h>
98602c01 112#include "tty.h"
1da177e4
LT
113
114#undef TTY_DEBUG_HANGUP
accff793
PH
115#ifdef TTY_DEBUG_HANGUP
116# define tty_debug_hangup(tty, f, args...) tty_debug(tty, f, ##args)
117#else
118# define tty_debug_hangup(tty, f, args...) do { } while (0)
119#endif
1da177e4
LT
120
121#define TTY_PARANOIA_CHECK 1
122#define CHECK_TTY_COUNT 1
123
edc6afc5 124struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
1da177e4
LT
125 .c_iflag = ICRNL | IXON,
126 .c_oflag = OPOST | ONLCR,
127 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
128 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
129 ECHOCTL | ECHOKE | IEXTEN,
edc6afc5
AC
130 .c_cc = INIT_C_CC,
131 .c_ispeed = 38400,
133b1306
PH
132 .c_ospeed = 38400,
133 /* .c_line = N_TTY, */
1da177e4 134};
1da177e4
LT
135EXPORT_SYMBOL(tty_std_termios);
136
137/* This list gets poked at by procfs and various bits of boot up code. This
b426a5b8
XT
138 * could do with some rationalisation such as pulling the tty proc function
139 * into this file.
140 */
37bdfb07 141
1da177e4
LT
142LIST_HEAD(tty_drivers); /* linked list of tty drivers */
143
d1d027ef 144/* Mutex to protect creating and releasing a tty */
70522e12 145DEFINE_MUTEX(tty_mutex);
1da177e4 146
dd78b0c4 147static ssize_t tty_read(struct kiocb *, struct iov_iter *);
9bb48c82 148static ssize_t tty_write(struct kiocb *, struct iov_iter *);
afc9a42b 149static __poll_t tty_poll(struct file *, poll_table *);
1da177e4 150static int tty_open(struct inode *, struct file *);
e10cc1df 151#ifdef CONFIG_COMPAT
37bdfb07 152static long tty_compat_ioctl(struct file *file, unsigned int cmd,
e10cc1df
PF
153 unsigned long arg);
154#else
155#define tty_compat_ioctl NULL
156#endif
ec79d605 157static int __tty_fasync(int fd, struct file *filp, int on);
37bdfb07 158static int tty_fasync(int fd, struct file *filp, int on);
d5698c28 159static void release_tty(struct tty_struct *tty, int idx);
1da177e4 160
af9b897e 161/**
796a75a9
JS
162 * free_tty_struct - free a disused tty
163 * @tty: tty struct to free
af9b897e 164 *
796a75a9 165 * Free the write buffers, tty queue and tty memory itself.
af9b897e 166 *
796a75a9 167 * Locking: none. Must be called after tty is definitely unused
af9b897e 168 */
a3123fd0 169static void free_tty_struct(struct tty_struct *tty)
1da177e4 170{
c8b710b3 171 tty_ldisc_deinit(tty);
a211b1af 172 put_device(tty->dev);
d6d9d17a 173 kvfree(tty->write_buf);
1da177e4
LT
174 kfree(tty);
175}
176
d996b62a
NP
177static inline struct tty_struct *file_tty(struct file *file)
178{
179 return ((struct tty_file_private *)file->private_data)->tty;
180}
181
fa90e1c9 182int tty_alloc_file(struct file *file)
d996b62a
NP
183{
184 struct tty_file_private *priv;
185
f573bd17
PE
186 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
187 if (!priv)
188 return -ENOMEM;
d996b62a 189
fa90e1c9
JS
190 file->private_data = priv;
191
192 return 0;
193}
194
195/* Associate a new file with the tty structure */
196void tty_add_file(struct tty_struct *tty, struct file *file)
197{
198 struct tty_file_private *priv = file->private_data;
199
d996b62a
NP
200 priv->tty = tty;
201 priv->file = file;
d996b62a 202
4a510969 203 spin_lock(&tty->files_lock);
d996b62a 204 list_add(&priv->list, &tty->tty_files);
4a510969 205 spin_unlock(&tty->files_lock);
fa90e1c9 206}
f573bd17 207
796a75a9 208/**
fa90e1c9 209 * tty_free_file - free file->private_data
796a75a9 210 * @file: to free private_data of
fa90e1c9
JS
211 *
212 * This shall be used only for fail path handling when tty_add_file was not
213 * called yet.
214 */
215void tty_free_file(struct file *file)
216{
217 struct tty_file_private *priv = file->private_data;
218
219 file->private_data = NULL;
220 kfree(priv);
d996b62a
NP
221}
222
223/* Delete file from its tty */
2520e274 224static void tty_del_file(struct file *file)
d996b62a
NP
225{
226 struct tty_file_private *priv = file->private_data;
4a510969 227 struct tty_struct *tty = priv->tty;
d996b62a 228
4a510969 229 spin_lock(&tty->files_lock);
d996b62a 230 list_del(&priv->list);
4a510969 231 spin_unlock(&tty->files_lock);
fa90e1c9 232 tty_free_file(file);
d996b62a
NP
233}
234
af9b897e 235/**
796a75a9
JS
236 * tty_name - return tty naming
237 * @tty: tty structure
af9b897e 238 *
796a75a9
JS
239 * Convert a tty structure into a name. The name reflects the kernel naming
240 * policy and if udev is in use may not reflect user space
af9b897e 241 *
796a75a9 242 * Locking: none
af9b897e 243 */
429b4749 244const char *tty_name(const struct tty_struct *tty)
1da177e4
LT
245{
246 if (!tty) /* Hmm. NULL pointer. That's fun. */
917162c9
RV
247 return "NULL tty";
248 return tty->name;
1da177e4 249}
1da177e4
LT
250EXPORT_SYMBOL(tty_name);
251
0a083edd
PH
252const char *tty_driver_name(const struct tty_struct *tty)
253{
254 if (!tty || !tty->driver)
255 return "";
256 return tty->driver->name;
257}
258
82b8f888 259static int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
1da177e4
LT
260 const char *routine)
261{
262#ifdef TTY_PARANOIA_CHECK
263 if (!tty) {
89222e62 264 pr_warn("(%d:%d): %s: NULL tty\n",
1da177e4
LT
265 imajor(inode), iminor(inode), routine);
266 return 1;
267 }
1da177e4
LT
268#endif
269 return 0;
270}
271
deb287e7 272/* Caller must hold tty_lock */
b4940f6c 273static void check_tty_count(struct tty_struct *tty, const char *routine)
1da177e4
LT
274{
275#ifdef CHECK_TTY_COUNT
276 struct list_head *p;
a09ac397 277 int count = 0, kopen_count = 0;
37bdfb07 278
4a510969 279 spin_lock(&tty->files_lock);
1da177e4
LT
280 list_for_each(p, &tty->tty_files) {
281 count++;
282 }
4a510969 283 spin_unlock(&tty->files_lock);
1da177e4
LT
284 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
285 tty->driver->subtype == PTY_TYPE_SLAVE &&
286 tty->link && tty->link->count)
287 count++;
a09ac397
OK
288 if (tty_port_kopened(tty->port))
289 kopen_count++;
290 if (tty->count != (count + kopen_count)) {
291 tty_warn(tty, "%s: tty->count(%d) != (#fd's(%d) + #kopen's(%d))\n",
292 routine, tty->count, count, kopen_count);
24ec839c 293 }
1da177e4 294#endif
1da177e4
LT
295}
296
af9b897e 297/**
796a75a9
JS
298 * get_tty_driver - find device of a tty
299 * @device: device identifier
300 * @index: returns the index of the tty
af9b897e 301 *
796a75a9
JS
302 * This routine returns a tty driver structure, given a device number and also
303 * passes back the index number.
af9b897e 304 *
796a75a9 305 * Locking: caller must hold tty_mutex
1da177e4
LT
306 */
307static struct tty_driver *get_tty_driver(dev_t device, int *index)
308{
309 struct tty_driver *p;
310
311 list_for_each_entry(p, &tty_drivers, tty_drivers) {
312 dev_t base = MKDEV(p->major, p->minor_start);
e73b2407 313
1da177e4
LT
314 if (device < base || device >= base + p->num)
315 continue;
316 *index = device - base;
7d7b93c1 317 return tty_driver_kref_get(p);
1da177e4
LT
318 }
319 return NULL;
320}
321
fc61ed51 322/**
796a75a9
JS
323 * tty_dev_name_to_number - return dev_t for device name
324 * @name: user space name of device under /dev
325 * @number: pointer to dev_t that this function will populate
fc61ed51 326 *
796a75a9
JS
327 * This function converts device names like ttyS0 or ttyUSB1 into dev_t like
328 * (4, 64) or (188, 1). If no corresponding driver is registered then the
329 * function returns -%ENODEV.
fc61ed51 330 *
796a75a9
JS
331 * Locking: this acquires tty_mutex to protect the tty_drivers list from
332 * being modified while we are traversing it, and makes sure to
333 * release it before exiting.
fc61ed51
OK
334 */
335int tty_dev_name_to_number(const char *name, dev_t *number)
336{
337 struct tty_driver *p;
338 int ret;
339 int index, prefix_length = 0;
340 const char *str;
341
342 for (str = name; *str && !isdigit(*str); str++)
343 ;
344
345 if (!*str)
346 return -EINVAL;
347
348 ret = kstrtoint(str, 10, &index);
349 if (ret)
350 return ret;
351
352 prefix_length = str - name;
353 mutex_lock(&tty_mutex);
354
355 list_for_each_entry(p, &tty_drivers, tty_drivers)
356 if (prefix_length == strlen(p->name) && strncmp(name,
357 p->name, prefix_length) == 0) {
358 if (index < p->num) {
359 *number = MKDEV(p->major, p->minor_start + index);
360 goto out;
361 }
362 }
363
364 /* if here then driver wasn't found */
365 ret = -ENODEV;
366out:
367 mutex_unlock(&tty_mutex);
368 return ret;
369}
370EXPORT_SYMBOL_GPL(tty_dev_name_to_number);
371
f2d937f3
JW
372#ifdef CONFIG_CONSOLE_POLL
373
374/**
796a75a9
JS
375 * tty_find_polling_driver - find device of a polled tty
376 * @name: name string to match
377 * @line: pointer to resulting tty line nr
f2d937f3 378 *
796a75a9
JS
379 * This routine returns a tty driver structure, given a name and the condition
380 * that the tty driver is capable of polled operation.
f2d937f3
JW
381 */
382struct tty_driver *tty_find_polling_driver(char *name, int *line)
383{
384 struct tty_driver *p, *res = NULL;
385 int tty_line = 0;
0dca0fd2 386 int len;
5f0878ac 387 char *str, *stp;
f2d937f3 388
0dca0fd2
JW
389 for (str = name; *str; str++)
390 if ((*str >= '0' && *str <= '9') || *str == ',')
391 break;
392 if (!*str)
393 return NULL;
394
395 len = str - name;
396 tty_line = simple_strtoul(str, &str, 10);
397
f2d937f3
JW
398 mutex_lock(&tty_mutex);
399 /* Search through the tty devices to look for a match */
400 list_for_each_entry(p, &tty_drivers, tty_drivers) {
33a1a7be 401 if (!len || strncmp(name, p->name, len) != 0)
0dca0fd2 402 continue;
5f0878ac
AC
403 stp = str;
404 if (*stp == ',')
405 stp++;
406 if (*stp == '\0')
407 stp = NULL;
f2d937f3 408
6eb68d6f 409 if (tty_line >= 0 && tty_line < p->num && p->ops &&
5f0878ac 410 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
7d7b93c1 411 res = tty_driver_kref_get(p);
f2d937f3
JW
412 *line = tty_line;
413 break;
414 }
415 }
416 mutex_unlock(&tty_mutex);
417
418 return res;
419}
420EXPORT_SYMBOL_GPL(tty_find_polling_driver);
421#endif
422
ddc5fda7 423static ssize_t hung_up_tty_read(struct kiocb *iocb, struct iov_iter *to)
1da177e4
LT
424{
425 return 0;
426}
427
17749851 428static ssize_t hung_up_tty_write(struct kiocb *iocb, struct iov_iter *from)
1da177e4
LT
429{
430 return -EIO;
431}
432
433/* No kernel lock held - none needed ;) */
afc9a42b 434static __poll_t hung_up_tty_poll(struct file *filp, poll_table *wait)
1da177e4 435{
a9a08845 436 return EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP | EPOLLRDNORM | EPOLLWRNORM;
1da177e4
LT
437}
438
04f378b1
AC
439static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
440 unsigned long arg)
38ad2ed0
PF
441{
442 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
443}
444
37bdfb07 445static long hung_up_tty_compat_ioctl(struct file *file,
38ad2ed0 446 unsigned int cmd, unsigned long arg)
1da177e4
LT
447{
448 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
449}
450
f557474c
PH
451static int hung_up_tty_fasync(int fd, struct file *file, int on)
452{
453 return -ENOTTY;
454}
455
d01c3289
MY
456static void tty_show_fdinfo(struct seq_file *m, struct file *file)
457{
458 struct tty_struct *tty = file_tty(file);
459
460 if (tty && tty->ops && tty->ops->show_fdinfo)
461 tty->ops->show_fdinfo(tty, m);
462}
463
62322d25 464static const struct file_operations tty_fops = {
1da177e4 465 .llseek = no_llseek,
dd78b0c4 466 .read_iter = tty_read,
9bb48c82 467 .write_iter = tty_write,
b0072734 468 .splice_read = copy_splice_read,
9bb48c82 469 .splice_write = iter_file_splice_write,
1da177e4 470 .poll = tty_poll,
04f378b1 471 .unlocked_ioctl = tty_ioctl,
e10cc1df 472 .compat_ioctl = tty_compat_ioctl,
1da177e4
LT
473 .open = tty_open,
474 .release = tty_release,
475 .fasync = tty_fasync,
d01c3289 476 .show_fdinfo = tty_show_fdinfo,
1da177e4
LT
477};
478
62322d25 479static const struct file_operations console_fops = {
1da177e4 480 .llseek = no_llseek,
dd78b0c4 481 .read_iter = tty_read,
9bb48c82 482 .write_iter = redirected_tty_write,
b0072734 483 .splice_read = copy_splice_read,
9bb48c82 484 .splice_write = iter_file_splice_write,
1da177e4 485 .poll = tty_poll,
04f378b1 486 .unlocked_ioctl = tty_ioctl,
e10cc1df 487 .compat_ioctl = tty_compat_ioctl,
1da177e4
LT
488 .open = tty_open,
489 .release = tty_release,
490 .fasync = tty_fasync,
491};
492
62322d25 493static const struct file_operations hung_up_tty_fops = {
1da177e4 494 .llseek = no_llseek,
ddc5fda7 495 .read_iter = hung_up_tty_read,
17749851 496 .write_iter = hung_up_tty_write,
1da177e4 497 .poll = hung_up_tty_poll,
04f378b1 498 .unlocked_ioctl = hung_up_tty_ioctl,
38ad2ed0 499 .compat_ioctl = hung_up_tty_compat_ioctl,
1da177e4 500 .release = tty_release,
f557474c 501 .fasync = hung_up_tty_fasync,
1da177e4
LT
502};
503
504static DEFINE_SPINLOCK(redirect_lock);
505static struct file *redirect;
506
507/**
796a75a9
JS
508 * tty_wakeup - request more data
509 * @tty: terminal
1da177e4 510 *
796a75a9
JS
511 * Internal and external helper for wakeups of tty. This function informs the
512 * line discipline if present that the driver is ready to receive more output
513 * data.
1da177e4 514 */
1da177e4
LT
515void tty_wakeup(struct tty_struct *tty)
516{
517 struct tty_ldisc *ld;
37bdfb07 518
1da177e4
LT
519 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
520 ld = tty_ldisc_ref(tty);
37bdfb07 521 if (ld) {
a352def2
AC
522 if (ld->ops->write_wakeup)
523 ld->ops->write_wakeup(tty);
1da177e4
LT
524 tty_ldisc_deref(ld);
525 }
526 }
a9a08845 527 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
1da177e4 528}
1da177e4
LT
529EXPORT_SYMBOL_GPL(tty_wakeup);
530
f446776e 531/**
796a75a9
JS
532 * tty_release_redirect - Release a redirect on a pty if present
533 * @tty: tty device
f446776e 534 *
796a75a9
JS
535 * This is available to the pty code so if the master closes, if the slave is a
536 * redirect it can release the redirect.
f446776e 537 */
dd9f6114 538static struct file *tty_release_redirect(struct tty_struct *tty)
f446776e
CM
539{
540 struct file *f = NULL;
541
542 spin_lock(&redirect_lock);
543 if (redirect && file_tty(redirect) == tty) {
544 f = redirect;
545 redirect = NULL;
546 }
547 spin_unlock(&redirect_lock);
548
549 return f;
550}
f446776e 551
af9b897e 552/**
796a75a9
JS
553 * __tty_hangup - actual handler for hangup events
554 * @tty: tty device
555 * @exit_session: if non-zero, signal all foreground group processes
556 *
557 * This can be called by a "kworker" kernel thread. That is process synchronous
558 * but doesn't hold any locks, so we need to make sure we have the appropriate
559 * locks for what we're doing.
560 *
561 * The hangup event clears any pending redirections onto the hung up device. It
562 * ensures future writes will error and it does the needed line discipline
563 * hangup and signal delivery. The tty object itself remains intact.
564 *
565 * Locking:
566 * * BTM
567 *
568 * * redirect lock for undoing redirection
569 * * file list lock for manipulating list of ttys
570 * * tty_ldiscs_lock from called functions
571 * * termios_rwsem resetting termios data
572 * * tasklist_lock to walk task list for hangup event
573 *
574 * * ->siglock to protect ->signal/->sighand
575 *
1da177e4 576 */
f91e2590 577static void __tty_hangup(struct tty_struct *tty, int exit_session)
1da177e4 578{
37bdfb07 579 struct file *cons_filp = NULL;
f446776e 580 struct file *filp, *f;
d996b62a 581 struct tty_file_private *priv;
1da177e4 582 int closecount = 0, n;
ea648a47 583 int refs;
1da177e4
LT
584
585 if (!tty)
586 return;
587
f446776e 588 f = tty_release_redirect(tty);
37bdfb07 589
89c8d91e 590 tty_lock(tty);
11dbf203 591
cb50e523
PH
592 if (test_bit(TTY_HUPPED, &tty->flags)) {
593 tty_unlock(tty);
594 return;
595 }
596
28b0f8a6
TH
597 /*
598 * Some console devices aren't actually hung up for technical and
599 * historical reasons, which can lead to indefinite interruptible
600 * sleep in n_tty_read(). The following explicitly tells
601 * n_tty_read() to abort readers.
602 */
603 set_bit(TTY_HUPPING, &tty->flags);
604
ec79d605 605 /* inuse_filps is protected by the single tty lock,
b426a5b8
XT
606 * this really needs to change if we want to flush the
607 * workqueue with the lock held.
608 */
11dbf203 609 check_tty_count(tty, "tty_hangup");
36ba782e 610
4a510969 611 spin_lock(&tty->files_lock);
1da177e4 612 /* This breaks for file handles being sent over AF_UNIX sockets ? */
d996b62a
NP
613 list_for_each_entry(priv, &tty->tty_files, list) {
614 filp = priv->file;
9bb48c82 615 if (filp->f_op->write_iter == redirected_tty_write)
1da177e4 616 cons_filp = filp;
9bb48c82 617 if (filp->f_op->write_iter != tty_write)
1da177e4
LT
618 continue;
619 closecount++;
ec79d605 620 __tty_fasync(-1, filp, 0); /* can't block */
1da177e4
LT
621 filp->f_op = &hung_up_tty_fops;
622 }
4a510969 623 spin_unlock(&tty->files_lock);
37bdfb07 624
25fdf243
PH
625 refs = tty_signal_session_leader(tty, exit_session);
626 /* Account for the p->signal references we killed */
627 while (refs--)
628 tty_kref_put(tty);
629
892d1fa7 630 tty_ldisc_hangup(tty, cons_filp != NULL);
37bdfb07 631
64d608db 632 spin_lock_irq(&tty->ctrl.lock);
c65c9bc3 633 clear_bit(TTY_THROTTLED, &tty->flags);
c65c9bc3 634 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
64d608db
JS
635 put_pid(tty->ctrl.session);
636 put_pid(tty->ctrl.pgrp);
637 tty->ctrl.session = NULL;
638 tty->ctrl.pgrp = NULL;
639 tty->ctrl.pktstatus = 0;
640 spin_unlock_irq(&tty->ctrl.lock);
9c9f4ded 641
1da177e4 642 /*
37bdfb07
AC
643 * If one of the devices matches a console pointer, we
644 * cannot just call hangup() because that will cause
645 * tty->count and state->count to go out of sync.
646 * So we just call close() the right number of times.
1da177e4
LT
647 */
648 if (cons_filp) {
f34d7a5b 649 if (tty->ops->close)
1da177e4 650 for (n = 0; n < closecount; n++)
f34d7a5b
AC
651 tty->ops->close(tty, cons_filp);
652 } else if (tty->ops->hangup)
7c6d340f 653 tty->ops->hangup(tty);
37bdfb07 654 /*
892d1fa7
PH
655 * We don't want to have driver/ldisc interactions beyond the ones
656 * we did here. The driver layer expects no calls after ->hangup()
657 * from the ldisc side, which is now guaranteed.
37bdfb07 658 */
1da177e4 659 set_bit(TTY_HUPPED, &tty->flags);
28b0f8a6 660 clear_bit(TTY_HUPPING, &tty->flags);
89c8d91e 661 tty_unlock(tty);
11dbf203 662
1da177e4
LT
663 if (f)
664 fput(f);
665}
666
ddcd9fb6
AB
667static void do_tty_hangup(struct work_struct *work)
668{
669 struct tty_struct *tty =
670 container_of(work, struct tty_struct, hangup_work);
671
f91e2590 672 __tty_hangup(tty, 0);
ddcd9fb6
AB
673}
674
af9b897e 675/**
796a75a9
JS
676 * tty_hangup - trigger a hangup event
677 * @tty: tty to hangup
af9b897e 678 *
796a75a9
JS
679 * A carrier loss (virtual or otherwise) has occurred on @tty. Schedule a
680 * hangup sequence to run after this event.
af9b897e 681 */
37bdfb07 682void tty_hangup(struct tty_struct *tty)
1da177e4 683{
d435cefe 684 tty_debug_hangup(tty, "hangup\n");
1da177e4
LT
685 schedule_work(&tty->hangup_work);
686}
1da177e4
LT
687EXPORT_SYMBOL(tty_hangup);
688
af9b897e 689/**
796a75a9
JS
690 * tty_vhangup - process vhangup
691 * @tty: tty to hangup
af9b897e 692 *
796a75a9
JS
693 * The user has asked via system call for the terminal to be hung up. We do
694 * this synchronously so that when the syscall returns the process is complete.
695 * That guarantee is necessary for security reasons.
af9b897e 696 */
37bdfb07 697void tty_vhangup(struct tty_struct *tty)
1da177e4 698{
d435cefe 699 tty_debug_hangup(tty, "vhangup\n");
f91e2590 700 __tty_hangup(tty, 0);
1da177e4
LT
701}
702EXPORT_SYMBOL(tty_vhangup);
703
11dbf203 704
2cb5998b 705/**
796a75a9 706 * tty_vhangup_self - process vhangup for own ctty
2cb5998b 707 *
796a75a9 708 * Perform a vhangup on the current controlling tty
2cb5998b 709 */
2cb5998b
AC
710void tty_vhangup_self(void)
711{
712 struct tty_struct *tty;
713
2cb5998b
AC
714 tty = get_current_tty();
715 if (tty) {
716 tty_vhangup(tty);
717 tty_kref_put(tty);
718 }
2cb5998b
AC
719}
720
f91e2590 721/**
796a75a9
JS
722 * tty_vhangup_session - hangup session leader exit
723 * @tty: tty to hangup
f91e2590 724 *
796a75a9
JS
725 * The session leader is exiting and hanging up its controlling terminal.
726 * Every process in the foreground process group is signalled %SIGHUP.
f91e2590 727 *
796a75a9
JS
728 * We do this synchronously so that when the syscall returns the process is
729 * complete. That guarantee is necessary for security reasons.
f91e2590 730 */
a1235b3e 731void tty_vhangup_session(struct tty_struct *tty)
f91e2590 732{
d435cefe 733 tty_debug_hangup(tty, "session hangup\n");
f91e2590
PH
734 __tty_hangup(tty, 1);
735}
736
af9b897e 737/**
796a75a9
JS
738 * tty_hung_up_p - was tty hung up
739 * @filp: file pointer of tty
af9b897e 740 *
796a75a9 741 * Return: true if the tty has been subject to a vhangup or a carrier loss
af9b897e 742 */
37bdfb07 743int tty_hung_up_p(struct file *filp)
1da177e4 744{
ed3f0af8 745 return (filp && filp->f_op == &hung_up_tty_fops);
1da177e4 746}
1da177e4
LT
747EXPORT_SYMBOL(tty_hung_up_p);
748
d06e256f
JS
749void __stop_tty(struct tty_struct *tty)
750{
751 if (tty->flow.stopped)
752 return;
753 tty->flow.stopped = true;
754 if (tty->ops->stop)
755 tty->ops->stop(tty);
756}
757
af9b897e 758/**
796a75a9
JS
759 * stop_tty - propagate flow control
760 * @tty: tty to stop
af9b897e 761 *
796a75a9
JS
762 * Perform flow control to the driver. May be called on an already stopped
763 * device and will not re-call the &tty_driver->stop() method.
af9b897e 764 *
796a75a9
JS
765 * This functionality is used by both the line disciplines for halting incoming
766 * flow and by the driver. It may therefore be called from any context, may be
767 * under the tty %atomic_write_lock but not always.
af9b897e 768 *
796a75a9
JS
769 * Locking:
770 * flow.lock
af9b897e 771 */
f9e053dc
PH
772void stop_tty(struct tty_struct *tty)
773{
774 unsigned long flags;
775
6e94dbc7 776 spin_lock_irqsave(&tty->flow.lock, flags);
f9e053dc 777 __stop_tty(tty);
6e94dbc7 778 spin_unlock_irqrestore(&tty->flow.lock, flags);
f9e053dc 779}
1da177e4
LT
780EXPORT_SYMBOL(stop_tty);
781
d06e256f
JS
782void __start_tty(struct tty_struct *tty)
783{
784 if (!tty->flow.stopped || tty->flow.tco_stopped)
785 return;
786 tty->flow.stopped = false;
787 if (tty->ops->start)
788 tty->ops->start(tty);
789 tty_wakeup(tty);
790}
791
af9b897e 792/**
796a75a9
JS
793 * start_tty - propagate flow control
794 * @tty: tty to start
af9b897e 795 *
796a75a9
JS
796 * Start a tty that has been stopped if at all possible. If @tty was previously
797 * stopped and is now being started, the &tty_driver->start() method is invoked
798 * and the line discipline woken.
af9b897e 799 *
796a75a9
JS
800 * Locking:
801 * flow.lock
af9b897e 802 */
f9e053dc
PH
803void start_tty(struct tty_struct *tty)
804{
805 unsigned long flags;
806
6e94dbc7 807 spin_lock_irqsave(&tty->flow.lock, flags);
f9e053dc 808 __start_tty(tty);
6e94dbc7 809 spin_unlock_irqrestore(&tty->flow.lock, flags);
f9e053dc 810}
1da177e4
LT
811EXPORT_SYMBOL(start_tty);
812
360c11e2 813static void tty_update_time(struct tty_struct *tty, bool mtime)
37b7f3c7 814{
c884f871 815 time64_t sec = ktime_get_real_seconds();
360c11e2 816 struct tty_file_private *priv;
fbf47635 817
360c11e2
MS
818 spin_lock(&tty->files_lock);
819 list_for_each_entry(priv, &tty->tty_files, list) {
820 struct inode *inode = file_inode(priv->file);
821 struct timespec64 *time = mtime ? &inode->i_mtime : &inode->i_atime;
822
823 /*
824 * We only care if the two values differ in anything other than the
825 * lower three bits (i.e every 8 seconds). If so, then we can update
826 * the time of the tty device, otherwise it could be construded as a
827 * security leak to let userspace know the exact timing of the tty.
828 */
829 if ((sec ^ time->tv_sec) & ~7)
830 time->tv_sec = sec;
831 }
832 spin_unlock(&tty->files_lock);
37b7f3c7
JS
833}
834
3b830a9c
LT
835/*
836 * Iterate on the ldisc ->read() function until we've gotten all
837 * the data the ldisc has for us.
838 *
839 * The "cookie" is something that the ldisc read function can fill
840 * in to let us know that there is more data to be had.
841 *
842 * We promise to continue to call the ldisc until it stops returning
843 * data or clears the cookie. The cookie may be something that the
844 * ldisc maintains state for and needs to free.
845 */
dd78b0c4
LT
846static int iterate_tty_read(struct tty_ldisc *ld, struct tty_struct *tty,
847 struct file *file, struct iov_iter *to)
3b830a9c
LT
848{
849 int retval = 0;
850 void *cookie = NULL;
851 unsigned long offset = 0;
852 char kernel_buf[64];
dd78b0c4 853 size_t count = iov_iter_count(to);
3b830a9c
LT
854
855 do {
dd78b0c4 856 int size, copied;
3b830a9c
LT
857
858 size = count > sizeof(kernel_buf) ? sizeof(kernel_buf) : count;
859 size = ld->ops->read(tty, file, kernel_buf, size, &cookie, offset);
860 if (!size)
861 break;
862
3b830a9c 863 if (size < 0) {
e71a8d5c
LT
864 /* Did we have an earlier error (ie -EFAULT)? */
865 if (retval)
866 break;
867 retval = size;
868
869 /*
870 * -EOVERFLOW means we didn't have enough space
871 * for a whole packet, and we shouldn't return
872 * a partial result.
873 */
874 if (retval == -EOVERFLOW)
875 offset = 0;
876 break;
3b830a9c
LT
877 }
878
dd78b0c4
LT
879 copied = copy_to_iter(kernel_buf, size, to);
880 offset += copied;
881 count -= copied;
3b830a9c
LT
882
883 /*
884 * If the user copy failed, we still need to do another ->read()
885 * call if we had a cookie to let the ldisc clear up.
886 *
887 * But make sure size is zeroed.
888 */
dd78b0c4 889 if (unlikely(copied != size)) {
3b830a9c
LT
890 count = 0;
891 retval = -EFAULT;
892 }
893 } while (cookie);
894
895 /* We always clear tty buffer in case they contained passwords */
896 memzero_explicit(kernel_buf, sizeof(kernel_buf));
897 return offset ? offset : retval;
898}
899
900
af9b897e 901/**
796a75a9
JS
902 * tty_read - read method for tty device files
903 * @iocb: kernel I/O control block
904 * @to: destination for the data read
af9b897e 905 *
796a75a9
JS
906 * Perform the read system call function on this terminal device. Checks
907 * for hung up devices before calling the line discipline method.
af9b897e 908 *
796a75a9
JS
909 * Locking:
910 * Locks the line discipline internally while needed. Multiple read calls
911 * may be outstanding in parallel.
af9b897e 912 */
dd78b0c4 913static ssize_t tty_read(struct kiocb *iocb, struct iov_iter *to)
1da177e4
LT
914{
915 int i;
dd78b0c4 916 struct file *file = iocb->ki_filp;
37b7f3c7 917 struct inode *inode = file_inode(file);
d996b62a 918 struct tty_struct *tty = file_tty(file);
1da177e4
LT
919 struct tty_ldisc *ld;
920
37b7f3c7 921 if (tty_paranoia_check(tty, inode, "tty_read"))
1da177e4 922 return -EIO;
18900ca6 923 if (!tty || tty_io_error(tty))
1da177e4
LT
924 return -EIO;
925
926 /* We want to wait for the line discipline to sort out in this
b426a5b8
XT
927 * situation.
928 */
1da177e4 929 ld = tty_ldisc_ref_wait(tty);
e55afd11 930 if (!ld)
ddc5fda7 931 return hung_up_tty_read(iocb, to);
3b830a9c 932 i = -EIO;
a352def2 933 if (ld->ops->read)
dd78b0c4 934 i = iterate_tty_read(ld, tty, file, to);
1da177e4 935 tty_ldisc_deref(ld);
b0de59b5 936
c884f871 937 if (i > 0)
360c11e2 938 tty_update_time(tty, false);
37b7f3c7 939
1da177e4
LT
940 return i;
941}
942
094fb49a 943void tty_write_unlock(struct tty_struct *tty)
9c1729db
AC
944{
945 mutex_unlock(&tty->atomic_write_lock);
a9a08845 946 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
9c1729db
AC
947}
948
af815336 949int tty_write_lock(struct tty_struct *tty, bool ndelay)
9c1729db
AC
950{
951 if (!mutex_trylock(&tty->atomic_write_lock)) {
952 if (ndelay)
953 return -EAGAIN;
954 if (mutex_lock_interruptible(&tty->atomic_write_lock))
955 return -ERESTARTSYS;
956 }
957 return 0;
958}
959
1da177e4
LT
960/*
961 * Split writes up in sane blocksizes to avoid
962 * denial-of-service type attacks
963 */
a32a672d
JSS
964static ssize_t iterate_tty_write(struct tty_ldisc *ld, struct tty_struct *tty,
965 struct file *file, struct iov_iter *from)
1da177e4 966{
ccc8dc00 967 size_t chunk, count = iov_iter_count(from);
9c1729db 968 ssize_t ret, written = 0;
37bdfb07 969
9c1729db
AC
970 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
971 if (ret < 0)
972 return ret;
1da177e4
LT
973
974 /*
975 * We chunk up writes into a temporary buffer. This
976 * simplifies low-level drivers immensely, since they
977 * don't have locking issues and user mode accesses.
978 *
979 * But if TTY_NO_WRITE_SPLIT is set, we should use a
980 * big chunk-size..
981 *
982 * The default chunk-size is 2kB, because the NTTY
983 * layer has problems with bigger chunks. It will
984 * claim to be able to handle more characters than
985 * it actually does.
986 */
987 chunk = 2048;
988 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
989 chunk = 65536;
990 if (count < chunk)
991 chunk = count;
992
70522e12 993 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1da177e4 994 if (tty->write_cnt < chunk) {
402fda92 995 unsigned char *buf_chunk;
1da177e4
LT
996
997 if (chunk < 1024)
998 chunk = 1024;
999
d6d9d17a 1000 buf_chunk = kvmalloc(chunk, GFP_KERNEL | __GFP_RETRY_MAYFAIL);
402fda92 1001 if (!buf_chunk) {
9c1729db
AC
1002 ret = -ENOMEM;
1003 goto out;
1da177e4 1004 }
d6d9d17a 1005 kvfree(tty->write_buf);
1da177e4 1006 tty->write_cnt = chunk;
402fda92 1007 tty->write_buf = buf_chunk;
1da177e4
LT
1008 }
1009
1010 /* Do the write .. */
1011 for (;;) {
ccc8dc00 1012 size_t size = min(chunk, count);
9bb48c82 1013
1da177e4 1014 ret = -EFAULT;
9bb48c82 1015 if (copy_from_iter(tty->write_buf, size, from) != size)
1da177e4 1016 break;
9bb48c82 1017
f47a4fd6 1018 ret = ld->ops->write(tty, file, tty->write_buf, size);
1da177e4
LT
1019 if (ret <= 0)
1020 break;
9bb48c82 1021
3342ff26
LT
1022 written += ret;
1023 if (ret > size)
1024 break;
1025
9bb48c82
LT
1026 /* FIXME! Have Al check this! */
1027 if (ret != size)
1028 iov_iter_revert(from, size-ret);
1029
1da177e4
LT
1030 count -= ret;
1031 if (!count)
1032 break;
1033 ret = -ERESTARTSYS;
1034 if (signal_pending(current))
1035 break;
1036 cond_resched();
1037 }
37b7f3c7 1038 if (written) {
360c11e2 1039 tty_update_time(tty, true);
1da177e4 1040 ret = written;
37b7f3c7 1041 }
9c1729db
AC
1042out:
1043 tty_write_unlock(tty);
1da177e4
LT
1044 return ret;
1045}
1046
95f9bfc6
AC
1047/**
1048 * tty_write_message - write a message to a certain tty, not just the console.
1049 * @tty: the destination tty_struct
1050 * @msg: the message to write
1051 *
796a75a9
JS
1052 * This is used for messages that need to be redirected to a specific tty. We
1053 * don't put it into the syslog queue right now maybe in the future if really
1054 * needed.
95f9bfc6 1055 *
ec79d605 1056 * We must still hold the BTM and test the CLOSING flag for the moment.
95f9bfc6 1057 */
95f9bfc6
AC
1058void tty_write_message(struct tty_struct *tty, char *msg)
1059{
95f9bfc6
AC
1060 if (tty) {
1061 mutex_lock(&tty->atomic_write_lock);
89c8d91e 1062 tty_lock(tty);
4b41b953 1063 if (tty->ops->write && tty->count > 0)
95f9bfc6 1064 tty->ops->write(tty, msg, strlen(msg));
4b41b953 1065 tty_unlock(tty);
95f9bfc6
AC
1066 tty_write_unlock(tty);
1067 }
95f9bfc6
AC
1068}
1069
a9cbbb80 1070static ssize_t file_tty_write(struct file *file, struct kiocb *iocb, struct iov_iter *from)
1da177e4 1071{
d996b62a 1072 struct tty_struct *tty = file_tty(file);
395e7833 1073 struct tty_ldisc *ld;
1da177e4 1074 ssize_t ret;
37bdfb07 1075
6131ffaa 1076 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
1da177e4 1077 return -EIO;
18900ca6 1078 if (!tty || !tty->ops->write || tty_io_error(tty))
5e4d5ac3 1079 return -EIO;
f34d7a5b
AC
1080 /* Short term debug to catch buggy drivers */
1081 if (tty->ops->write_room == NULL)
339f36ba 1082 tty_err(tty, "missing write_room method\n");
37bdfb07 1083 ld = tty_ldisc_ref_wait(tty);
17749851
LT
1084 if (!ld)
1085 return hung_up_tty_write(iocb, from);
1086 if (!ld->ops->write)
1da177e4
LT
1087 ret = -EIO;
1088 else
a32a672d 1089 ret = iterate_tty_write(ld, tty, file, from);
1da177e4
LT
1090 tty_ldisc_deref(ld);
1091 return ret;
1092}
1093
756a4e4a 1094/**
796a75a9
JS
1095 * tty_write - write method for tty device file
1096 * @iocb: kernel I/O control block
1097 * @from: iov_iter with data to write
756a4e4a 1098 *
796a75a9 1099 * Write data to a tty device via the line discipline.
756a4e4a 1100 *
796a75a9
JS
1101 * Locking:
1102 * Locks the line discipline as required
1103 * Writes to the tty driver are serialized by the atomic_write_lock
1104 * and are then processed in chunks to the device. The line
1105 * discipline write method will not be invoked in parallel for
1106 * each device.
756a4e4a 1107 */
a9cbbb80
LT
1108static ssize_t tty_write(struct kiocb *iocb, struct iov_iter *from)
1109{
1110 return file_tty_write(iocb->ki_filp, iocb, from);
1111}
1112
9bb48c82 1113ssize_t redirected_tty_write(struct kiocb *iocb, struct iov_iter *iter)
1da177e4
LT
1114{
1115 struct file *p = NULL;
1116
1117 spin_lock(&redirect_lock);
cb0942b8
AV
1118 if (redirect)
1119 p = get_file(redirect);
1da177e4
LT
1120 spin_unlock(&redirect_lock);
1121
a9cbbb80 1122 /*
44969f85 1123 * We know the redirected tty is just another tty, we can
a9cbbb80
LT
1124 * call file_tty_write() directly with that file pointer.
1125 */
1da177e4
LT
1126 if (p) {
1127 ssize_t res;
e73b2407 1128
a9cbbb80 1129 res = file_tty_write(p, iocb, iter);
1da177e4
LT
1130 fput(p);
1131 return res;
1132 }
9bb48c82 1133 return tty_write(iocb, iter);
1da177e4
LT
1134}
1135
796a75a9
JS
1136/**
1137 * tty_send_xchar - send priority character
1138 * @tty: the tty to send to
1139 * @ch: xchar to send
136d5258 1140 *
796a75a9 1141 * Send a high priority character to the tty even if stopped.
136d5258 1142 *
796a75a9 1143 * Locking: none for xchar method, write ordering for write method.
136d5258 1144 */
136d5258
PH
1145int tty_send_xchar(struct tty_struct *tty, char ch)
1146{
6e94dbc7 1147 bool was_stopped = tty->flow.stopped;
136d5258
PH
1148
1149 if (tty->ops->send_xchar) {
ee0c1a65 1150 down_read(&tty->termios_rwsem);
136d5258 1151 tty->ops->send_xchar(tty, ch);
ee0c1a65 1152 up_read(&tty->termios_rwsem);
136d5258
PH
1153 return 0;
1154 }
1155
af815336 1156 if (tty_write_lock(tty, false) < 0)
136d5258
PH
1157 return -ERESTARTSYS;
1158
ee0c1a65 1159 down_read(&tty->termios_rwsem);
136d5258
PH
1160 if (was_stopped)
1161 start_tty(tty);
1162 tty->ops->write(tty, &ch, 1);
1163 if (was_stopped)
1164 stop_tty(tty);
ee0c1a65 1165 up_read(&tty->termios_rwsem);
136d5258
PH
1166 tty_write_unlock(tty);
1167 return 0;
1168}
1169
af9b897e 1170/**
796a75a9
JS
1171 * pty_line_name - generate name for a pty
1172 * @driver: the tty driver in use
1173 * @index: the minor number
1174 * @p: output buffer of at least 6 bytes
af9b897e 1175 *
796a75a9
JS
1176 * Generate a name from a @driver reference and write it to the output buffer
1177 * @p.
af9b897e 1178 *
796a75a9 1179 * Locking: None
af9b897e
AC
1180 */
1181static void pty_line_name(struct tty_driver *driver, int index, char *p)
1da177e4 1182{
a846dcf9 1183 static const char ptychar[] = "pqrstuvwxyzabcde";
1da177e4
LT
1184 int i = index + driver->name_base;
1185 /* ->name is initialized to "ttyp", but "tty" is expected */
1186 sprintf(p, "%s%c%x",
37bdfb07
AC
1187 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1188 ptychar[i >> 4 & 0xf], i & 0xf);
1da177e4
LT
1189}
1190
af9b897e 1191/**
796a75a9
JS
1192 * tty_line_name - generate name for a tty
1193 * @driver: the tty driver in use
1194 * @index: the minor number
1195 * @p: output buffer of at least 7 bytes
af9b897e 1196 *
796a75a9
JS
1197 * Generate a name from a @driver reference and write it to the output buffer
1198 * @p.
af9b897e 1199 *
796a75a9 1200 * Locking: None
af9b897e 1201 */
723abd87 1202static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
1da177e4 1203{
0019b408 1204 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
723abd87 1205 return sprintf(p, "%s", driver->name);
0019b408 1206 else
723abd87
HR
1207 return sprintf(p, "%s%d", driver->name,
1208 index + driver->name_base);
1da177e4
LT
1209}
1210
99f1fe18 1211/**
796a75a9
JS
1212 * tty_driver_lookup_tty() - find an existing tty, if any
1213 * @driver: the driver for the tty
1214 * @file: file object
1215 * @idx: the minor number
23499705 1216 *
796a75a9
JS
1217 * Return: the tty, if found. If not found, return %NULL or ERR_PTR() if the
1218 * driver lookup() method returns an error.
23499705 1219 *
796a75a9 1220 * Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
23499705 1221 */
a47d545f 1222static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
8ead9dd5 1223 struct file *file, int idx)
23499705 1224{
aa3cb814
PH
1225 struct tty_struct *tty;
1226
db4df8e9 1227 if (driver->ops->lookup) {
12e84c71
OK
1228 if (!file)
1229 tty = ERR_PTR(-EIO);
1230 else
1231 tty = driver->ops->lookup(driver, file, idx);
db4df8e9
SS
1232 } else {
1233 if (idx >= driver->num)
1234 return ERR_PTR(-EINVAL);
aa3cb814 1235 tty = driver->ttys[idx];
db4df8e9 1236 }
aa3cb814
PH
1237 if (!IS_ERR(tty))
1238 tty_kref_get(tty);
1239 return tty;
23499705
SB
1240}
1241
bf970ee4 1242/**
796a75a9
JS
1243 * tty_init_termios - helper for termios setup
1244 * @tty: the tty to set up
bf970ee4 1245 *
796a75a9
JS
1246 * Initialise the termios structure for this tty. This runs under the
1247 * %tty_mutex currently so we can be relaxed about ordering.
bf970ee4 1248 */
a3123fd0 1249void tty_init_termios(struct tty_struct *tty)
bf970ee4 1250{
fe6e29fd 1251 struct ktermios *tp;
bf970ee4
AC
1252 int idx = tty->index;
1253
36b3c070
AC
1254 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1255 tty->termios = tty->driver->init_termios;
1256 else {
1257 /* Check for lazy saved data */
1258 tp = tty->driver->termios[idx];
ece53405 1259 if (tp != NULL) {
36b3c070 1260 tty->termios = *tp;
ece53405
PH
1261 tty->termios.c_line = tty->driver->init_termios.c_line;
1262 } else
36b3c070 1263 tty->termios = tty->driver->init_termios;
bf970ee4 1264 }
bf970ee4 1265 /* Compatibility until drivers always set this */
adc8d746
AC
1266 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1267 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
bf970ee4 1268}
fe1ae7fd 1269EXPORT_SYMBOL_GPL(tty_init_termios);
bf970ee4 1270
31bc35d3
JS
1271/**
1272 * tty_standard_install - usual tty->ops->install
1273 * @driver: the driver for the tty
1274 * @tty: the tty
1275 *
1276 * If the @driver overrides @tty->ops->install, it still can call this function
1277 * to perform the standard install operations.
1278 */
66d450e8
JS
1279int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1280{
a3123fd0 1281 tty_init_termios(tty);
66d450e8
JS
1282 tty_driver_kref_get(driver);
1283 tty->count++;
1284 driver->ttys[tty->index] = tty;
1285 return 0;
1286}
1287EXPORT_SYMBOL_GPL(tty_standard_install);
1288
99f1fe18 1289/**
796a75a9
JS
1290 * tty_driver_install_tty() - install a tty entry in the driver
1291 * @driver: the driver for the tty
1292 * @tty: the tty
8b0a88d5 1293 *
796a75a9
JS
1294 * Install a tty object into the driver tables. The @tty->index field will be
1295 * set by the time this is called. This method is responsible for ensuring any
1296 * need additional structures are allocated and configured.
8b0a88d5 1297 *
796a75a9 1298 * Locking: tty_mutex for now
8b0a88d5
AC
1299 */
1300static int tty_driver_install_tty(struct tty_driver *driver,
1301 struct tty_struct *tty)
1302{
66d450e8
JS
1303 return driver->ops->install ? driver->ops->install(driver, tty) :
1304 tty_standard_install(driver, tty);
8b0a88d5
AC
1305}
1306
1307/**
796a75a9
JS
1308 * tty_driver_remove_tty() - remove a tty from the driver tables
1309 * @driver: the driver for the tty
1310 * @tty: tty to remove
8b0a88d5 1311 *
796a75a9
JS
1312 * Remove a tty object from the driver tables. The tty->index field will be set
1313 * by the time this is called.
8b0a88d5 1314 *
796a75a9 1315 * Locking: tty_mutex for now
8b0a88d5 1316 */
05de87ed 1317static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
8b0a88d5
AC
1318{
1319 if (driver->ops->remove)
1320 driver->ops->remove(driver, tty);
1321 else
1322 driver->ttys[tty->index] = NULL;
1323}
1324
fa441954 1325/**
796a75a9
JS
1326 * tty_reopen() - fast re-open of an open tty
1327 * @tty: the tty to open
23499705 1328 *
796a75a9 1329 * Re-opens on master ptys are not allowed and return -%EIO.
23499705 1330 *
796a75a9
JS
1331 * Locking: Caller must hold tty_lock
1332 * Return: 0 on success, -errno on error.
23499705 1333 */
99f1fe18 1334static int tty_reopen(struct tty_struct *tty)
23499705
SB
1335{
1336 struct tty_driver *driver = tty->driver;
d3736d82
DS
1337 struct tty_ldisc *ld;
1338 int retval = 0;
23499705 1339
23499705 1340 if (driver->type == TTY_DRIVER_TYPE_PTY &&
5d93e748
PH
1341 driver->subtype == PTY_TYPE_MASTER)
1342 return -EIO;
23499705 1343
7f22f6c9
PH
1344 if (!tty->count)
1345 return -EAGAIN;
1346
86f2c00f
PH
1347 if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1348 return -EBUSY;
1349
d3736d82
DS
1350 ld = tty_ldisc_ref_wait(tty);
1351 if (ld) {
1352 tty_ldisc_deref(ld);
1353 } else {
1354 retval = tty_ldisc_lock(tty, 5 * HZ);
1355 if (retval)
1356 return retval;
1357
1358 if (!tty->ldisc)
1359 retval = tty_ldisc_reinit(tty, tty->termios.c_line);
1360 tty_ldisc_unlock(tty);
1361 }
23499705 1362
cf62a1a1
DS
1363 if (retval == 0)
1364 tty->count++;
fe324167
DS
1365
1366 return retval;
23499705
SB
1367}
1368
af9b897e 1369/**
796a75a9
JS
1370 * tty_init_dev - initialise a tty device
1371 * @driver: tty driver we are opening a device on
1372 * @idx: device index
af9b897e 1373 *
796a75a9
JS
1374 * Prepare a tty device. This may not be a "new" clean device but could also be
1375 * an active device. The pty drivers require special handling because of this.
af9b897e 1376 *
796a75a9
JS
1377 * Locking:
1378 * The function is called under the tty_mutex, which protects us from the
1379 * tty struct or driver itself going away.
af9b897e 1380 *
796a75a9
JS
1381 * On exit the tty device has the line discipline attached and a reference
1382 * count of 1. If a pair was created for pty/tty use and the other was a pty
1383 * master then it too has a reference count of 1.
af9b897e 1384 *
796a75a9
JS
1385 * WSH 06/09/97: Rewritten to remove races and properly clean up after a failed
1386 * open. The new code protects the open with a mutex, so it's really quite
1387 * straightforward. The mutex locking can probably be relaxed for the (most
1388 * common) case of reopening a tty.
fa441954 1389 *
796a75a9 1390 * Return: new tty structure
1da177e4 1391 */
593a27c4 1392struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
1da177e4 1393{
bf970ee4 1394 struct tty_struct *tty;
73ec06fc 1395 int retval;
1da177e4 1396
1da177e4
LT
1397 /*
1398 * First time open is complex, especially for PTY devices.
1399 * This code guarantees that either everything succeeds and the
1400 * TTY is ready for operation, or else the table slots are vacated
37bdfb07 1401 * and the allocated memory released. (Except that the termios
16b00ae8 1402 * may be retained.)
1da177e4
LT
1403 */
1404
73ec06fc
AC
1405 if (!try_module_get(driver->owner))
1406 return ERR_PTR(-ENODEV);
1da177e4 1407
2c964a2f 1408 tty = alloc_tty_struct(driver, idx);
d5543503
JS
1409 if (!tty) {
1410 retval = -ENOMEM;
1411 goto err_module_put;
1412 }
1da177e4 1413
89c8d91e 1414 tty_lock(tty);
73ec06fc 1415 retval = tty_driver_install_tty(driver, tty);
d5543503 1416 if (retval < 0)
c8b710b3 1417 goto err_free_tty;
8b0a88d5 1418
04831dc1
JS
1419 if (!tty->port)
1420 tty->port = driver->ports[idx];
1421
2ae0b31e
JS
1422 if (WARN_RATELIMIT(!tty->port,
1423 "%s: %s driver does not set tty->port. This would crash the kernel. Fix the driver!\n",
1424 __func__, tty->driver->name)) {
1425 retval = -EINVAL;
1426 goto err_release_lock;
1427 }
5d4121c0 1428
b027e229
GK
1429 retval = tty_ldisc_lock(tty, 5 * HZ);
1430 if (retval)
1431 goto err_release_lock;
967fab69
JS
1432 tty->port->itty = tty;
1433
37bdfb07 1434 /*
1da177e4 1435 * Structures all installed ... call the ldisc open routines.
d5698c28
CH
1436 * If we fail here just call release_tty to clean up. No need
1437 * to decrement the use counts, as release_tty doesn't care.
1da177e4 1438 */
bf970ee4 1439 retval = tty_ldisc_setup(tty, tty->link);
01e1abb2 1440 if (retval)
d5543503 1441 goto err_release_tty;
b027e229 1442 tty_ldisc_unlock(tty);
89c8d91e 1443 /* Return the tty locked so that it cannot vanish under the caller */
73ec06fc 1444 return tty;
1da177e4 1445
c8b710b3 1446err_free_tty:
89c8d91e 1447 tty_unlock(tty);
d5543503
JS
1448 free_tty_struct(tty);
1449err_module_put:
1da177e4 1450 module_put(driver->owner);
d5543503 1451 return ERR_PTR(retval);
1da177e4 1452
d5698c28 1453 /* call the tty release_tty routine to clean out this slot */
d5543503 1454err_release_tty:
b027e229 1455 tty_ldisc_unlock(tty);
339f36ba
PH
1456 tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
1457 retval, idx);
b027e229
GK
1458err_release_lock:
1459 tty_unlock(tty);
d5698c28 1460 release_tty(tty, idx);
73ec06fc 1461 return ERR_PTR(retval);
1da177e4
LT
1462}
1463
f51ccf46
JH
1464/**
1465 * tty_save_termios() - save tty termios data in driver table
1466 * @tty: tty whose termios data to save
1467 *
1468 * Locking: Caller guarantees serialisation with tty_init_termios().
1469 */
1470void tty_save_termios(struct tty_struct *tty)
feebed65
AC
1471{
1472 struct ktermios *tp;
1473 int idx = tty->index;
36b3c070
AC
1474
1475 /* If the port is going to reset then it has no termios to save */
1476 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1477 return;
1478
1479 /* Stash the termios data */
1480 tp = tty->driver->termios[idx];
1481 if (tp == NULL) {
a3241891 1482 tp = kmalloc(sizeof(*tp), GFP_KERNEL);
25080652 1483 if (tp == NULL)
36b3c070 1484 return;
4ac5d705 1485 tty->driver->termios[idx] = tp;
feebed65 1486 }
36b3c070 1487 *tp = tty->termios;
feebed65 1488}
f51ccf46 1489EXPORT_SYMBOL_GPL(tty_save_termios);
feebed65 1490
a2965b7b 1491/**
796a75a9
JS
1492 * tty_flush_works - flush all works of a tty/pty pair
1493 * @tty: tty device to flush works for (or either end of a pty pair)
a2965b7b 1494 *
796a75a9 1495 * Sync flush all works belonging to @tty (and the 'other' tty).
a2965b7b
PH
1496 */
1497static void tty_flush_works(struct tty_struct *tty)
1498{
1499 flush_work(&tty->SAK_work);
1500 flush_work(&tty->hangup_work);
949aa64f
PH
1501 if (tty->link) {
1502 flush_work(&tty->link->SAK_work);
1503 flush_work(&tty->link->hangup_work);
1504 }
a2965b7b 1505}
feebed65 1506
af9b897e 1507/**
796a75a9
JS
1508 * release_one_tty - release tty structure memory
1509 * @work: work of tty we are obliterating
af9b897e 1510 *
796a75a9
JS
1511 * Releases memory associated with a tty structure, and clears out the
1512 * driver table slots. This function is called when a device is no longer
1513 * in use. It also gets called when setup of a device fails.
af9b897e 1514 *
796a75a9
JS
1515 * Locking:
1516 * takes the file list lock internally when working on the list of ttys
1517 * that the driver keeps.
b50989dc 1518 *
796a75a9
JS
1519 * This method gets called from a work queue so that the driver private
1520 * cleanup ops can sleep (needed for USB at least)
1da177e4 1521 */
b50989dc 1522static void release_one_tty(struct work_struct *work)
1da177e4 1523{
b50989dc
AC
1524 struct tty_struct *tty =
1525 container_of(work, struct tty_struct, hangup_work);
6f967f78 1526 struct tty_driver *driver = tty->driver;
b216df53 1527 struct module *owner = driver->owner;
d5698c28 1528
f278a2f7
DY
1529 if (tty->ops->cleanup)
1530 tty->ops->cleanup(tty);
1531
7d7b93c1 1532 tty_driver_kref_put(driver);
b216df53 1533 module_put(owner);
d5698c28 1534
4a510969 1535 spin_lock(&tty->files_lock);
1da177e4 1536 list_del_init(&tty->tty_files);
4a510969 1537 spin_unlock(&tty->files_lock);
d5698c28 1538
64d608db
JS
1539 put_pid(tty->ctrl.pgrp);
1540 put_pid(tty->ctrl.session);
1da177e4
LT
1541 free_tty_struct(tty);
1542}
1543
b50989dc
AC
1544static void queue_release_one_tty(struct kref *kref)
1545{
1546 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
f278a2f7 1547
b50989dc 1548 /* The hangup queue is now free so we can reuse it rather than
b426a5b8
XT
1549 * waste a chunk of memory for each port.
1550 */
b50989dc
AC
1551 INIT_WORK(&tty->hangup_work, release_one_tty);
1552 schedule_work(&tty->hangup_work);
1553}
1554
9c9f4ded 1555/**
796a75a9
JS
1556 * tty_kref_put - release a tty kref
1557 * @tty: tty device
9c9f4ded 1558 *
796a75a9
JS
1559 * Release a reference to the @tty device and if need be let the kref layer
1560 * destruct the object for us.
9c9f4ded 1561 */
9c9f4ded
AC
1562void tty_kref_put(struct tty_struct *tty)
1563{
1564 if (tty)
b50989dc 1565 kref_put(&tty->kref, queue_release_one_tty);
9c9f4ded
AC
1566}
1567EXPORT_SYMBOL(tty_kref_put);
1568
d5698c28 1569/**
796a75a9
JS
1570 * release_tty - release tty structure memory
1571 * @tty: tty device release
1572 * @idx: index of the tty device release
d5698c28 1573 *
796a75a9
JS
1574 * Release both @tty and a possible linked partner (think pty pair),
1575 * and decrement the refcount of the backing module.
9c9f4ded 1576 *
796a75a9
JS
1577 * Locking:
1578 * tty_mutex
1579 * takes the file list lock internally when working on the list of ttys
1580 * that the driver keeps.
d5698c28
CH
1581 */
1582static void release_tty(struct tty_struct *tty, int idx)
1583{
9c9f4ded
AC
1584 /* This should always be true but check for the moment */
1585 WARN_ON(tty->index != idx);
d155255a 1586 WARN_ON(!mutex_is_locked(&tty_mutex));
36b3c070
AC
1587 if (tty->ops->shutdown)
1588 tty->ops->shutdown(tty);
f51ccf46 1589 tty_save_termios(tty);
36b3c070 1590 tty_driver_remove_tty(tty->driver, tty);
4466d6d2
MR
1591 if (tty->port)
1592 tty->port->itty = NULL;
64e377dc
PH
1593 if (tty->link)
1594 tty->link->port->itty = NULL;
4466d6d2
MR
1595 if (tty->port)
1596 tty_buffer_cancel_work(tty->port);
2b022ab7
S
1597 if (tty->link)
1598 tty_buffer_cancel_work(tty->link->port);
36b3c070 1599
a211b1af 1600 tty_kref_put(tty->link);
9c9f4ded 1601 tty_kref_put(tty);
d5698c28
CH
1602}
1603
955787ca 1604/**
796a75a9
JS
1605 * tty_release_checks - check a tty before real release
1606 * @tty: tty to check
1607 * @idx: index of the tty
955787ca 1608 *
796a75a9
JS
1609 * Performs some paranoid checking before true release of the @tty. This is a
1610 * no-op unless %TTY_PARANOIA_CHECK is defined.
955787ca 1611 */
359b9fb5 1612static int tty_release_checks(struct tty_struct *tty, int idx)
955787ca
JS
1613{
1614#ifdef TTY_PARANOIA_CHECK
1615 if (idx < 0 || idx >= tty->driver->num) {
e2dfa3d3 1616 tty_debug(tty, "bad idx %d\n", idx);
955787ca
JS
1617 return -1;
1618 }
1619
1620 /* not much to check for devpts */
1621 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1622 return 0;
1623
1624 if (tty != tty->driver->ttys[idx]) {
e2dfa3d3
PH
1625 tty_debug(tty, "bad driver table[%d] = %p\n",
1626 idx, tty->driver->ttys[idx]);
955787ca
JS
1627 return -1;
1628 }
955787ca 1629 if (tty->driver->other) {
359b9fb5
PH
1630 struct tty_struct *o_tty = tty->link;
1631
955787ca 1632 if (o_tty != tty->driver->other->ttys[idx]) {
e2dfa3d3
PH
1633 tty_debug(tty, "bad other table[%d] = %p\n",
1634 idx, tty->driver->other->ttys[idx]);
955787ca
JS
1635 return -1;
1636 }
955787ca 1637 if (o_tty->link != tty) {
e2dfa3d3 1638 tty_debug(tty, "bad link = %p\n", o_tty->link);
955787ca
JS
1639 return -1;
1640 }
1641 }
1642#endif
1643 return 0;
1644}
1645
a09ac397 1646/**
796a75a9
JS
1647 * tty_kclose - closes tty opened by tty_kopen
1648 * @tty: tty device
a09ac397 1649 *
796a75a9
JS
1650 * Performs the final steps to release and free a tty device. It is the same as
1651 * tty_release_struct() except that it also resets %TTY_PORT_KOPENED flag on
1652 * @tty->port.
a09ac397
OK
1653 */
1654void tty_kclose(struct tty_struct *tty)
1655{
1656 /*
1657 * Ask the line discipline code to release its structures
1658 */
1659 tty_ldisc_release(tty);
1660
da1bb4ed 1661 /* Wait for pending work before tty destruction commences */
a09ac397
OK
1662 tty_flush_works(tty);
1663
1664 tty_debug_hangup(tty, "freeing structure\n");
1665 /*
1666 * The release_tty function takes care of the details of clearing
ed069827 1667 * the slots and preserving the termios structure.
a09ac397
OK
1668 */
1669 mutex_lock(&tty_mutex);
1670 tty_port_set_kopened(tty->port, 0);
1671 release_tty(tty, tty->index);
1672 mutex_unlock(&tty_mutex);
1673}
1674EXPORT_SYMBOL_GPL(tty_kclose);
1675
9ed90d20 1676/**
796a75a9
JS
1677 * tty_release_struct - release a tty struct
1678 * @tty: tty device
1679 * @idx: index of the tty
9ed90d20 1680 *
796a75a9
JS
1681 * Performs the final steps to release and free a tty device. It is roughly the
1682 * reverse of tty_init_dev().
9ed90d20
RH
1683 */
1684void tty_release_struct(struct tty_struct *tty, int idx)
1685{
1686 /*
1687 * Ask the line discipline code to release its structures
1688 */
1689 tty_ldisc_release(tty);
1690
1691 /* Wait for pending work before tty destruction commmences */
1692 tty_flush_works(tty);
1693
1694 tty_debug_hangup(tty, "freeing structure\n");
1695 /*
1696 * The release_tty function takes care of the details of clearing
ed069827 1697 * the slots and preserving the termios structure.
9ed90d20
RH
1698 */
1699 mutex_lock(&tty_mutex);
1700 release_tty(tty, idx);
1701 mutex_unlock(&tty_mutex);
1702}
1703EXPORT_SYMBOL_GPL(tty_release_struct);
1704
eeb89d91 1705/**
796a75a9
JS
1706 * tty_release - vfs callback for close
1707 * @inode: inode of tty
1708 * @filp: file pointer for handle to tty
eeb89d91 1709 *
796a75a9
JS
1710 * Called the last time each file handle is closed that references this tty.
1711 * There may however be several such references.
eeb89d91 1712 *
796a75a9
JS
1713 * Locking:
1714 * Takes BKL. See tty_release_dev().
eeb89d91 1715 *
796a75a9
JS
1716 * Even releasing the tty structures is a tricky business. We have to be very
1717 * careful that the structures are all released at the same time, as interrupts
1718 * might otherwise get the wrong pointers.
1da177e4
LT
1719 *
1720 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1721 * lead to double frees or releasing memory still in use.
1722 */
eeb89d91 1723int tty_release(struct inode *inode, struct file *filp)
1da177e4 1724{
d996b62a 1725 struct tty_struct *tty = file_tty(filp);
7ffb6da9
PH
1726 struct tty_struct *o_tty = NULL;
1727 int do_sleep, final;
1da177e4 1728 int idx;
37b16457 1729 long timeout = 0;
494c1eac 1730 int once = 1;
37bdfb07 1731
9de44bd6 1732 if (tty_paranoia_check(tty, inode, __func__))
eeb89d91 1733 return 0;
1da177e4 1734
89c8d91e 1735 tty_lock(tty);
9de44bd6 1736 check_tty_count(tty, __func__);
1da177e4 1737
ec79d605 1738 __tty_fasync(-1, filp, 0);
1da177e4
LT
1739
1740 idx = tty->index;
7ffb6da9
PH
1741 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1742 tty->driver->subtype == PTY_TYPE_MASTER)
1743 o_tty = tty->link;
1da177e4 1744
359b9fb5 1745 if (tty_release_checks(tty, idx)) {
89c8d91e 1746 tty_unlock(tty);
eeb89d91 1747 return 0;
1da177e4 1748 }
1da177e4 1749
d435cefe 1750 tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);
1da177e4 1751
f34d7a5b
AC
1752 if (tty->ops->close)
1753 tty->ops->close(tty, filp);
1da177e4 1754
2aff5e2b
PH
1755 /* If tty is pty master, lock the slave pty (stable lock order) */
1756 tty_lock_slave(o_tty);
1757
1da177e4
LT
1758 /*
1759 * Sanity check: if tty->count is going to zero, there shouldn't be
1760 * any waiters on tty->read_wait or tty->write_wait. We test the
1761 * wait queues and kick everyone out _before_ actually starting to
1762 * close. This ensures that we won't block while releasing the tty
1763 * structure.
1764 *
1765 * The test for the o_tty closing is necessary, since the master and
1766 * slave sides may close in any order. If the slave side closes out
1767 * first, its count will be one, since the master side holds an open.
324c1650 1768 * Thus this test wouldn't be triggered at the time the slave closed,
1da177e4 1769 * so we do it now.
1da177e4
LT
1770 */
1771 while (1) {
1da177e4
LT
1772 do_sleep = 0;
1773
324c1650 1774 if (tty->count <= 1) {
1da177e4 1775 if (waitqueue_active(&tty->read_wait)) {
a9a08845 1776 wake_up_poll(&tty->read_wait, EPOLLIN);
1da177e4
LT
1777 do_sleep++;
1778 }
1779 if (waitqueue_active(&tty->write_wait)) {
a9a08845 1780 wake_up_poll(&tty->write_wait, EPOLLOUT);
1da177e4
LT
1781 do_sleep++;
1782 }
1783 }
7ffb6da9 1784 if (o_tty && o_tty->count <= 1) {
1da177e4 1785 if (waitqueue_active(&o_tty->read_wait)) {
a9a08845 1786 wake_up_poll(&o_tty->read_wait, EPOLLIN);
1da177e4
LT
1787 do_sleep++;
1788 }
1789 if (waitqueue_active(&o_tty->write_wait)) {
a9a08845 1790 wake_up_poll(&o_tty->write_wait, EPOLLOUT);
1da177e4
LT
1791 do_sleep++;
1792 }
1793 }
1794 if (!do_sleep)
1795 break;
1796
494c1eac
PH
1797 if (once) {
1798 once = 0;
339f36ba 1799 tty_warn(tty, "read/write wait queue active!\n");
494c1eac 1800 }
37b16457
PH
1801 schedule_timeout_killable(timeout);
1802 if (timeout < 120 * HZ)
1803 timeout = 2 * timeout + 1;
1804 else
1805 timeout = MAX_SCHEDULE_TIMEOUT;
37bdfb07 1806 }
1da177e4 1807
7ffb6da9 1808 if (o_tty) {
1da177e4 1809 if (--o_tty->count < 0) {
339f36ba 1810 tty_warn(tty, "bad slave count (%d)\n", o_tty->count);
1da177e4
LT
1811 o_tty->count = 0;
1812 }
1813 }
1814 if (--tty->count < 0) {
339f36ba 1815 tty_warn(tty, "bad tty->count (%d)\n", tty->count);
1da177e4
LT
1816 tty->count = 0;
1817 }
37bdfb07 1818
1da177e4
LT
1819 /*
1820 * We've decremented tty->count, so we need to remove this file
1821 * descriptor off the tty->tty_files list; this serves two
1822 * purposes:
1823 * - check_tty_count sees the correct number of file descriptors
1824 * associated with this tty.
1825 * - do_tty_hangup no longer sees this file descriptor as
1826 * something that needs to be handled for hangups.
1827 */
d996b62a 1828 tty_del_file(filp);
1da177e4
LT
1829
1830 /*
1831 * Perform some housekeeping before deciding whether to return.
1832 *
1da177e4
LT
1833 * If _either_ side is closing, make sure there aren't any
1834 * processes that still think tty or o_tty is their controlling
1835 * tty.
1836 */
324c1650 1837 if (!tty->count) {
1da177e4 1838 read_lock(&tasklist_lock);
64d608db 1839 session_clear_tty(tty->ctrl.session);
7ffb6da9 1840 if (o_tty)
64d608db 1841 session_clear_tty(o_tty->ctrl.session);
1da177e4
LT
1842 read_unlock(&tasklist_lock);
1843 }
1844
324c1650 1845 /* check whether both sides are closing ... */
7ffb6da9 1846 final = !tty->count && !(o_tty && o_tty->count);
324c1650 1847
2aff5e2b
PH
1848 tty_unlock_slave(o_tty);
1849 tty_unlock(tty);
1850
04980706 1851 /* At this point, the tty->count == 0 should ensure a dead tty
b426a5b8
XT
1852 * cannot be re-opened by a racing opener.
1853 */
da965822 1854
324c1650 1855 if (!final)
eeb89d91 1856 return 0;
37bdfb07 1857
accff793 1858 tty_debug_hangup(tty, "final close\n");
1da177e4 1859
9ed90d20 1860 tty_release_struct(tty, idx);
eeb89d91 1861 return 0;
1da177e4
LT
1862}
1863
b82154ac 1864/**
796a75a9
JS
1865 * tty_open_current_tty - get locked tty of current task
1866 * @device: device number
1867 * @filp: file pointer to tty
1868 * @return: locked tty of the current task iff @device is /dev/tty
52494eeb 1869 *
796a75a9 1870 * Performs a re-open of the current task's controlling tty.
b82154ac 1871 *
796a75a9
JS
1872 * We cannot return driver and index like for the other nodes because devpts
1873 * will not work then. It expects inodes to be from devpts FS.
b82154ac
JS
1874 */
1875static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1876{
1877 struct tty_struct *tty;
52494eeb 1878 int retval;
b82154ac
JS
1879
1880 if (device != MKDEV(TTYAUX_MAJOR, 0))
1881 return NULL;
1882
1883 tty = get_current_tty();
1884 if (!tty)
1885 return ERR_PTR(-ENXIO);
1886
1887 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1888 /* noctty = 1; */
52494eeb
PH
1889 tty_lock(tty);
1890 tty_kref_put(tty); /* safe to drop the kref now */
1891
1892 retval = tty_reopen(tty);
1893 if (retval < 0) {
1894 tty_unlock(tty);
1895 tty = ERR_PTR(retval);
1896 }
b82154ac
JS
1897 return tty;
1898}
1899
5b5e7040 1900/**
796a75a9
JS
1901 * tty_lookup_driver - lookup a tty driver for a given device file
1902 * @device: device number
1903 * @filp: file pointer to tty
1904 * @index: index for the device in the @return driver
5b5e7040 1905 *
796a75a9
JS
1906 * If returned value is not erroneous, the caller is responsible to decrement
1907 * the refcount by tty_driver_kref_put().
5b5e7040 1908 *
796a75a9
JS
1909 * Locking: %tty_mutex protects get_tty_driver()
1910 *
1911 * Return: driver for this inode (with increased refcount)
5b5e7040
JS
1912 */
1913static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
11e1d4aa 1914 int *index)
5b5e7040 1915{
8c8af41d 1916 struct tty_driver *driver = NULL;
5b5e7040 1917
2cd0050c 1918 switch (device) {
5b5e7040 1919#ifdef CONFIG_VT
2cd0050c 1920 case MKDEV(TTY_MAJOR, 0): {
5b5e7040 1921 extern struct tty_driver *console_driver;
e73b2407 1922
5b5e7040
JS
1923 driver = tty_driver_kref_get(console_driver);
1924 *index = fg_console;
2cd0050c 1925 break;
5b5e7040
JS
1926 }
1927#endif
2cd0050c 1928 case MKDEV(TTYAUX_MAJOR, 1): {
5b5e7040 1929 struct tty_driver *console_driver = console_device(index);
e73b2407 1930
5b5e7040
JS
1931 if (console_driver) {
1932 driver = tty_driver_kref_get(console_driver);
12e84c71 1933 if (driver && filp) {
5b5e7040
JS
1934 /* Don't let /dev/console block */
1935 filp->f_flags |= O_NONBLOCK;
2cd0050c 1936 break;
5b5e7040
JS
1937 }
1938 }
8c8af41d
LY
1939 if (driver)
1940 tty_driver_kref_put(driver);
5b5e7040
JS
1941 return ERR_PTR(-ENODEV);
1942 }
2cd0050c
JS
1943 default:
1944 driver = get_tty_driver(device, index);
1945 if (!driver)
1946 return ERR_PTR(-ENODEV);
1947 break;
1948 }
5b5e7040
JS
1949 return driver;
1950}
1951
4ea3cd65 1952static struct tty_struct *tty_kopen(dev_t device, int shared)
a09ac397
OK
1953{
1954 struct tty_struct *tty;
f1d31743 1955 struct tty_driver *driver;
a09ac397
OK
1956 int index = -1;
1957
1958 mutex_lock(&tty_mutex);
1959 driver = tty_lookup_driver(device, NULL, &index);
1960 if (IS_ERR(driver)) {
1961 mutex_unlock(&tty_mutex);
1962 return ERR_CAST(driver);
1963 }
1964
1965 /* check whether we're reopening an existing tty */
1966 tty = tty_driver_lookup_tty(driver, NULL, index);
4ea3cd65 1967 if (IS_ERR(tty) || shared)
a09ac397
OK
1968 goto out;
1969
1970 if (tty) {
1971 /* drop kref from tty_driver_lookup_tty() */
1972 tty_kref_put(tty);
1973 tty = ERR_PTR(-EBUSY);
1974 } else { /* tty_init_dev returns tty with the tty_lock held */
1975 tty = tty_init_dev(driver, index);
1976 if (IS_ERR(tty))
1977 goto out;
1978 tty_port_set_kopened(tty->port, 1);
1979 }
1980out:
1981 mutex_unlock(&tty_mutex);
1982 tty_driver_kref_put(driver);
1983 return tty;
1984}
4ea3cd65
UKK
1985
1986/**
796a75a9
JS
1987 * tty_kopen_exclusive - open a tty device for kernel
1988 * @device: dev_t of device to open
4ea3cd65 1989 *
796a75a9
JS
1990 * Opens tty exclusively for kernel. Performs the driver lookup, makes sure
1991 * it's not already opened and performs the first-time tty initialization.
4ea3cd65 1992 *
796a75a9
JS
1993 * Claims the global %tty_mutex to serialize:
1994 * * concurrent first-time tty initialization
1995 * * concurrent tty driver removal w/ lookup
1996 * * concurrent tty removal from driver table
4ea3cd65 1997 *
796a75a9 1998 * Return: the locked initialized &tty_struct
4ea3cd65
UKK
1999 */
2000struct tty_struct *tty_kopen_exclusive(dev_t device)
2001{
2002 return tty_kopen(device, 0);
2003}
2004EXPORT_SYMBOL_GPL(tty_kopen_exclusive);
2005
2006/**
796a75a9
JS
2007 * tty_kopen_shared - open a tty device for shared in-kernel use
2008 * @device: dev_t of device to open
4ea3cd65 2009 *
796a75a9
JS
2010 * Opens an already existing tty for in-kernel use. Compared to
2011 * tty_kopen_exclusive() above it doesn't ensure to be the only user.
4ea3cd65 2012 *
796a75a9 2013 * Locking: identical to tty_kopen() above.
4ea3cd65
UKK
2014 */
2015struct tty_struct *tty_kopen_shared(dev_t device)
2016{
2017 return tty_kopen(device, 1);
2018}
2019EXPORT_SYMBOL_GPL(tty_kopen_shared);
a09ac397 2020
d6203d0c 2021/**
796a75a9
JS
2022 * tty_open_by_driver - open a tty device
2023 * @device: dev_t of device to open
2024 * @filp: file pointer to tty
2025 *
2026 * Performs the driver lookup, checks for a reopen, or otherwise performs the
2027 * first-time tty initialization.
d6203d0c 2028 *
d6203d0c 2029 *
796a75a9
JS
2030 * Claims the global tty_mutex to serialize:
2031 * * concurrent first-time tty initialization
2032 * * concurrent tty driver removal w/ lookup
2033 * * concurrent tty removal from driver table
d6203d0c 2034 *
796a75a9 2035 * Return: the locked initialized or re-opened &tty_struct
d6203d0c 2036 */
14ce3848 2037static struct tty_struct *tty_open_by_driver(dev_t device,
d6203d0c
PH
2038 struct file *filp)
2039{
2040 struct tty_struct *tty;
2041 struct tty_driver *driver = NULL;
2042 int index = -1;
2043 int retval;
2044
2045 mutex_lock(&tty_mutex);
2046 driver = tty_lookup_driver(device, filp, &index);
2047 if (IS_ERR(driver)) {
2048 mutex_unlock(&tty_mutex);
2049 return ERR_CAST(driver);
2050 }
2051
2052 /* check whether we're reopening an existing tty */
8ead9dd5 2053 tty = tty_driver_lookup_tty(driver, filp, index);
d6203d0c
PH
2054 if (IS_ERR(tty)) {
2055 mutex_unlock(&tty_mutex);
2056 goto out;
2057 }
2058
2059 if (tty) {
a09ac397
OK
2060 if (tty_port_kopened(tty->port)) {
2061 tty_kref_put(tty);
2062 mutex_unlock(&tty_mutex);
2063 tty = ERR_PTR(-EBUSY);
2064 goto out;
2065 }
d6203d0c
PH
2066 mutex_unlock(&tty_mutex);
2067 retval = tty_lock_interruptible(tty);
5e00bbfb 2068 tty_kref_put(tty); /* drop kref from tty_driver_lookup_tty() */
d6203d0c
PH
2069 if (retval) {
2070 if (retval == -EINTR)
2071 retval = -ERESTARTSYS;
2072 tty = ERR_PTR(retval);
2073 goto out;
2074 }
d6203d0c
PH
2075 retval = tty_reopen(tty);
2076 if (retval < 0) {
2077 tty_unlock(tty);
2078 tty = ERR_PTR(retval);
2079 }
2080 } else { /* Returns with the tty_lock held for now */
2081 tty = tty_init_dev(driver, index);
2082 mutex_unlock(&tty_mutex);
2083 }
2084out:
2085 tty_driver_kref_put(driver);
2086 return tty;
2087}
2088
af9b897e 2089/**
796a75a9
JS
2090 * tty_open - open a tty device
2091 * @inode: inode of device file
2092 * @filp: file pointer to tty
1da177e4 2093 *
796a75a9
JS
2094 * tty_open() and tty_release() keep up the tty count that contains the number
2095 * of opens done on a tty. We cannot use the inode-count, as different inodes
2096 * might point to the same tty.
1da177e4 2097 *
796a75a9
JS
2098 * Open-counting is needed for pty masters, as well as for keeping track of
2099 * serial lines: DTR is dropped when the last close happens.
2100 * (This is not done solely through tty->count, now. - Ted 1/27/92)
af9b897e 2101 *
796a75a9
JS
2102 * The termios state of a pty is reset on the first open so that settings don't
2103 * persist across reuse.
af9b897e 2104 *
796a75a9
JS
2105 * Locking:
2106 * * %tty_mutex protects tty, tty_lookup_driver() and tty_init_dev().
2107 * * @tty->count should protect the rest.
2108 * * ->siglock protects ->signal/->sighand
89c8d91e 2109 *
796a75a9 2110 * Note: the tty_unlock/lock cases without a ref are only safe due to %tty_mutex
1da177e4 2111 */
eeb89d91 2112static int tty_open(struct inode *inode, struct file *filp)
1da177e4 2113{
b82154ac 2114 struct tty_struct *tty;
1da177e4 2115 int noctty, retval;
1da177e4 2116 dev_t device = inode->i_rdev;
846c151a 2117 unsigned saved_flags = filp->f_flags;
1da177e4
LT
2118
2119 nonseekable_open(inode, filp);
37bdfb07 2120
1da177e4 2121retry_open:
fa90e1c9
JS
2122 retval = tty_alloc_file(filp);
2123 if (retval)
2124 return -ENOMEM;
2125
b82154ac 2126 tty = tty_open_current_tty(device, filp);
d6203d0c 2127 if (!tty)
14ce3848 2128 tty = tty_open_by_driver(device, filp);
52494eeb 2129
eeb89d91 2130 if (IS_ERR(tty)) {
d6203d0c 2131 tty_free_file(filp);
ba5db448 2132 retval = PTR_ERR(tty);
7f22f6c9 2133 if (retval != -EAGAIN || signal_pending(current))
d6203d0c 2134 return retval;
7f22f6c9
PH
2135 schedule();
2136 goto retry_open;
eeb89d91 2137 }
1da177e4 2138
fa90e1c9 2139 tty_add_file(tty, filp);
d996b62a 2140
9de44bd6 2141 check_tty_count(tty, __func__);
d435cefe 2142 tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
accff793 2143
909bc774
HRK
2144 if (tty->ops->open)
2145 retval = tty->ops->open(tty, filp);
2146 else
2147 retval = -ENODEV;
1da177e4
LT
2148 filp->f_flags = saved_flags;
2149
1da177e4 2150 if (retval) {
d435cefe 2151 tty_debug_hangup(tty, "open error %d, releasing\n", retval);
accff793 2152
89c8d91e 2153 tty_unlock(tty); /* need to call tty_release without BTM */
eeb89d91 2154 tty_release(inode, filp);
64ba3dc3 2155 if (retval != -ERESTARTSYS)
1da177e4 2156 return retval;
64ba3dc3
AB
2157
2158 if (signal_pending(current))
1da177e4 2159 return retval;
64ba3dc3 2160
1da177e4
LT
2161 schedule();
2162 /*
2163 * Need to reset f_op in case a hangup happened.
2164 */
1256937f 2165 if (tty_hung_up_p(filp))
1da177e4
LT
2166 filp->f_op = &tty_fops;
2167 goto retry_open;
2168 }
d4855e1f 2169 clear_bit(TTY_HUPPED, &tty->flags);
eeb89d91 2170
11e1d4aa 2171 noctty = (filp->f_flags & O_NOCTTY) ||
a1235b3e
NP
2172 (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
2173 device == MKDEV(TTYAUX_MAJOR, 1) ||
2174 (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2175 tty->driver->subtype == PTY_TYPE_MASTER);
2176 if (!noctty)
2177 tty_open_proc_set_tty(filp, tty);
89c8d91e 2178 tty_unlock(tty);
1da177e4
LT
2179 return 0;
2180}
2181
39d95b9d 2182
af9b897e 2183/**
796a75a9
JS
2184 * tty_poll - check tty status
2185 * @filp: file being polled
2186 * @wait: poll wait structures to update
af9b897e 2187 *
796a75a9
JS
2188 * Call the line discipline polling method to obtain the poll status of the
2189 * device.
af9b897e 2190 *
796a75a9
JS
2191 * Locking: locks called line discipline but ldisc poll method may be
2192 * re-entered freely by other callers.
af9b897e 2193 */
afc9a42b 2194static __poll_t tty_poll(struct file *filp, poll_table *wait)
1da177e4 2195{
d996b62a 2196 struct tty_struct *tty = file_tty(filp);
1da177e4 2197 struct tty_ldisc *ld;
e6c8adca 2198 __poll_t ret = 0;
1da177e4 2199
6131ffaa 2200 if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
1da177e4 2201 return 0;
37bdfb07 2202
1da177e4 2203 ld = tty_ldisc_ref_wait(tty);
e55afd11
PH
2204 if (!ld)
2205 return hung_up_tty_poll(filp, wait);
a352def2 2206 if (ld->ops->poll)
c961bfb1 2207 ret = ld->ops->poll(tty, filp, wait);
1da177e4
LT
2208 tty_ldisc_deref(ld);
2209 return ret;
2210}
2211
ec79d605 2212static int __tty_fasync(int fd, struct file *filp, int on)
1da177e4 2213{
d996b62a 2214 struct tty_struct *tty = file_tty(filp);
47f86834 2215 unsigned long flags;
5d1e3230 2216 int retval = 0;
1da177e4 2217
6131ffaa 2218 if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
5d1e3230 2219 goto out;
37bdfb07 2220
1da177e4
LT
2221 retval = fasync_helper(fd, filp, on, &tty->fasync);
2222 if (retval <= 0)
5d1e3230 2223 goto out;
f6c8dbe6 2224
1da177e4 2225 if (on) {
ab521dc0
EB
2226 enum pid_type type;
2227 struct pid *pid;
f6c8dbe6 2228
64d608db
JS
2229 spin_lock_irqsave(&tty->ctrl.lock, flags);
2230 if (tty->ctrl.pgrp) {
2231 pid = tty->ctrl.pgrp;
ab521dc0
EB
2232 type = PIDTYPE_PGID;
2233 } else {
2234 pid = task_pid(current);
01919134 2235 type = PIDTYPE_TGID;
ab521dc0 2236 }
80e1e823 2237 get_pid(pid);
64d608db 2238 spin_unlock_irqrestore(&tty->ctrl.lock, flags);
e0b93edd 2239 __f_setown(filp, pid, type, 0);
80e1e823 2240 put_pid(pid);
e0b93edd 2241 retval = 0;
1da177e4 2242 }
5d1e3230 2243out:
ec79d605
AB
2244 return retval;
2245}
2246
2247static int tty_fasync(int fd, struct file *filp, int on)
2248{
89c8d91e 2249 struct tty_struct *tty = file_tty(filp);
a8f3a297 2250 int retval = -ENOTTY;
89c8d91e
AC
2251
2252 tty_lock(tty);
a8f3a297
PH
2253 if (!tty_hung_up_p(filp))
2254 retval = __tty_fasync(fd, filp, on);
89c8d91e
AC
2255 tty_unlock(tty);
2256
5d1e3230 2257 return retval;
1da177e4
LT
2258}
2259
5c30f3e4 2260static bool tty_legacy_tiocsti __read_mostly = IS_ENABLED(CONFIG_LEGACY_TIOCSTI);
af9b897e 2261/**
796a75a9
JS
2262 * tiocsti - fake input character
2263 * @tty: tty to fake input into
2264 * @p: pointer to character
af9b897e 2265 *
796a75a9 2266 * Fake input to a tty device. Does the necessary locking and input management.
af9b897e 2267 *
796a75a9 2268 * FIXME: does not honour flow control ??
af9b897e 2269 *
796a75a9
JS
2270 * Locking:
2271 * * Called functions take tty_ldiscs_lock
2272 * * current->signal->tty check is safe without locks
af9b897e 2273 */
1da177e4
LT
2274static int tiocsti(struct tty_struct *tty, char __user *p)
2275{
2276 char ch, mbz = 0;
2277 struct tty_ldisc *ld;
37bdfb07 2278
690c8b80 2279 if (!tty_legacy_tiocsti && !capable(CAP_SYS_ADMIN))
83efeeeb
KC
2280 return -EIO;
2281
1da177e4
LT
2282 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2283 return -EPERM;
2284 if (get_user(ch, p))
2285 return -EFAULT;
1e641743 2286 tty_audit_tiocsti(tty, ch);
1da177e4 2287 ld = tty_ldisc_ref_wait(tty);
e55afd11
PH
2288 if (!ld)
2289 return -EIO;
bb2853a6 2290 tty_buffer_lock_exclusive(tty->port);
27cfb3a5
GKH
2291 if (ld->ops->receive_buf)
2292 ld->ops->receive_buf(tty, &ch, &mbz, 1);
bb2853a6 2293 tty_buffer_unlock_exclusive(tty->port);
1da177e4
LT
2294 tty_ldisc_deref(ld);
2295 return 0;
2296}
2297
af9b897e 2298/**
796a75a9
JS
2299 * tiocgwinsz - implement window query ioctl
2300 * @tty: tty
2301 * @arg: user buffer for result
af9b897e 2302 *
796a75a9 2303 * Copies the kernel idea of the window size into the user buffer.
af9b897e 2304 *
796a75a9
JS
2305 * Locking: @tty->winsize_mutex is taken to ensure the winsize data is
2306 * consistent.
af9b897e 2307 */
37bdfb07 2308static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
1da177e4 2309{
808a0d38
AC
2310 int err;
2311
dee4a0be 2312 mutex_lock(&tty->winsize_mutex);
808a0d38 2313 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
dee4a0be 2314 mutex_unlock(&tty->winsize_mutex);
808a0d38 2315
94bc2eb5 2316 return err ? -EFAULT : 0;
1da177e4
LT
2317}
2318
af9b897e 2319/**
796a75a9
JS
2320 * tty_do_resize - resize event
2321 * @tty: tty being resized
2322 * @ws: new dimensions
8c9a9dd0 2323 *
796a75a9
JS
2324 * Update the termios variables and send the necessary signals to peform a
2325 * terminal resize correctly.
af9b897e 2326 */
fc6f6238 2327int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
1da177e4 2328{
fc6f6238 2329 struct pid *pgrp;
1da177e4 2330
fc6f6238 2331 /* Lock the tty */
dee4a0be 2332 mutex_lock(&tty->winsize_mutex);
fc6f6238 2333 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
ca9bda00 2334 goto done;
47f86834 2335
5b239542
PH
2336 /* Signal the foreground process group */
2337 pgrp = tty_get_pgrp(tty);
47f86834
AC
2338 if (pgrp)
2339 kill_pgrp(pgrp, SIGWINCH, 1);
47f86834 2340 put_pid(pgrp);
47f86834 2341
8c9a9dd0 2342 tty->winsize = *ws;
ca9bda00 2343done:
dee4a0be 2344 mutex_unlock(&tty->winsize_mutex);
1da177e4
LT
2345 return 0;
2346}
4d334fd1 2347EXPORT_SYMBOL(tty_do_resize);
1da177e4 2348
8c9a9dd0 2349/**
796a75a9
JS
2350 * tiocswinsz - implement window size set ioctl
2351 * @tty: tty side of tty
2352 * @arg: user buffer for result
8c9a9dd0 2353 *
796a75a9
JS
2354 * Copies the user idea of the window size to the kernel. Traditionally this is
2355 * just advisory information but for the Linux console it actually has driver
2356 * level meaning and triggers a VC resize.
8c9a9dd0 2357 *
796a75a9
JS
2358 * Locking:
2359 * Driver dependent. The default do_resize method takes the tty termios
2360 * mutex and ctrl.lock. The console takes its own lock then calls into the
2361 * default method.
8c9a9dd0 2362 */
fc6f6238 2363static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
8c9a9dd0
AC
2364{
2365 struct winsize tmp_ws;
e73b2407 2366
8c9a9dd0
AC
2367 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2368 return -EFAULT;
2369
2370 if (tty->ops->resize)
fc6f6238 2371 return tty->ops->resize(tty, &tmp_ws);
8c9a9dd0 2372 else
fc6f6238 2373 return tty_do_resize(tty, &tmp_ws);
8c9a9dd0
AC
2374}
2375
af9b897e 2376/**
796a75a9
JS
2377 * tioccons - allow admin to move logical console
2378 * @file: the file to become console
af9b897e 2379 *
796a75a9 2380 * Allow the administrator to move the redirected console device.
af9b897e 2381 *
796a75a9 2382 * Locking: uses redirect_lock to guard the redirect information
af9b897e 2383 */
1da177e4
LT
2384static int tioccons(struct file *file)
2385{
2386 if (!capable(CAP_SYS_ADMIN))
2387 return -EPERM;
9bb48c82 2388 if (file->f_op->write_iter == redirected_tty_write) {
1da177e4 2389 struct file *f;
e73b2407 2390
1da177e4
LT
2391 spin_lock(&redirect_lock);
2392 f = redirect;
2393 redirect = NULL;
2394 spin_unlock(&redirect_lock);
2395 if (f)
2396 fput(f);
2397 return 0;
2398 }
a9cbbb80
LT
2399 if (file->f_op->write_iter != tty_write)
2400 return -ENOTTY;
2401 if (!(file->f_mode & FMODE_WRITE))
2402 return -EBADF;
2403 if (!(file->f_mode & FMODE_CAN_WRITE))
2404 return -EINVAL;
1da177e4
LT
2405 spin_lock(&redirect_lock);
2406 if (redirect) {
2407 spin_unlock(&redirect_lock);
2408 return -EBUSY;
2409 }
cb0942b8 2410 redirect = get_file(file);
1da177e4
LT
2411 spin_unlock(&redirect_lock);
2412 return 0;
2413}
2414
af9b897e 2415/**
796a75a9
JS
2416 * tiocsetd - set line discipline
2417 * @tty: tty device
2418 * @p: pointer to user data
af9b897e 2419 *
796a75a9 2420 * Set the line discipline according to user request.
af9b897e 2421 *
796a75a9 2422 * Locking: see tty_set_ldisc(), this function is just a helper
af9b897e 2423 */
1da177e4
LT
2424static int tiocsetd(struct tty_struct *tty, int __user *p)
2425{
c12da96f 2426 int disc;
04f378b1 2427 int ret;
1da177e4 2428
c12da96f 2429 if (get_user(disc, p))
1da177e4 2430 return -EFAULT;
04f378b1 2431
c12da96f 2432 ret = tty_set_ldisc(tty, disc);
04f378b1
AC
2433
2434 return ret;
1da177e4
LT
2435}
2436
5c17c861 2437/**
796a75a9
JS
2438 * tiocgetd - get line discipline
2439 * @tty: tty device
2440 * @p: pointer to user data
5c17c861 2441 *
796a75a9 2442 * Retrieves the line discipline id directly from the ldisc.
5c17c861 2443 *
796a75a9
JS
2444 * Locking: waits for ldisc reference (in case the line discipline is changing
2445 * or the @tty is being hungup)
5c17c861 2446 */
5c17c861
PH
2447static int tiocgetd(struct tty_struct *tty, int __user *p)
2448{
2449 struct tty_ldisc *ld;
2450 int ret;
2451
2452 ld = tty_ldisc_ref_wait(tty);
e55afd11
PH
2453 if (!ld)
2454 return -EIO;
5c17c861
PH
2455 ret = put_user(ld->ops->num, p);
2456 tty_ldisc_deref(ld);
2457 return ret;
2458}
2459
af9b897e 2460/**
796a75a9
JS
2461 * send_break - performed time break
2462 * @tty: device to break on
2463 * @duration: timeout in mS
af9b897e 2464 *
796a75a9
JS
2465 * Perform a timed break on hardware that lacks its own driver level timed
2466 * break functionality.
af9b897e 2467 *
796a75a9
JS
2468 * Locking:
2469 * @tty->atomic_write_lock serializes
af9b897e 2470 */
b20f3ae5 2471static int send_break(struct tty_struct *tty, unsigned int duration)
1da177e4 2472{
9e98966c
AC
2473 int retval;
2474
2475 if (tty->ops->break_ctl == NULL)
2476 return 0;
2477
2478 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2479 retval = tty->ops->break_ctl(tty, duration);
2480 else {
2481 /* Do the work ourselves */
af815336 2482 if (tty_write_lock(tty, false) < 0)
9e98966c
AC
2483 return -EINTR;
2484 retval = tty->ops->break_ctl(tty, -1);
2485 if (retval)
2486 goto out;
2487 if (!signal_pending(current))
2488 msleep_interruptible(duration);
2489 retval = tty->ops->break_ctl(tty, 0);
2490out:
2491 tty_write_unlock(tty);
2492 if (signal_pending(current))
2493 retval = -EINTR;
2494 }
2495 return retval;
1da177e4
LT
2496}
2497
af9b897e 2498/**
796a75a9
JS
2499 * tty_tiocmget - get modem status
2500 * @tty: tty device
2501 * @p: pointer to result
af9b897e 2502 *
796a75a9
JS
2503 * Obtain the modem status bits from the tty driver if the feature is
2504 * supported. Return -%ENOTTY if it is not available.
af9b897e 2505 *
796a75a9 2506 * Locking: none (up to the driver)
af9b897e 2507 */
60b33c13 2508static int tty_tiocmget(struct tty_struct *tty, int __user *p)
1da177e4 2509{
1b8b2086 2510 int retval = -ENOTTY;
1da177e4 2511
f34d7a5b 2512 if (tty->ops->tiocmget) {
60b33c13 2513 retval = tty->ops->tiocmget(tty);
1da177e4
LT
2514
2515 if (retval >= 0)
2516 retval = put_user(retval, p);
2517 }
2518 return retval;
2519}
2520
af9b897e 2521/**
796a75a9
JS
2522 * tty_tiocmset - set modem status
2523 * @tty: tty device
2524 * @cmd: command - clear bits, set bits or set all
2525 * @p: pointer to desired bits
af9b897e 2526 *
796a75a9
JS
2527 * Set the modem status bits from the tty driver if the feature
2528 * is supported. Return -%ENOTTY if it is not available.
af9b897e 2529 *
796a75a9 2530 * Locking: none (up to the driver)
af9b897e 2531 */
20b9d177 2532static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
1da177e4
LT
2533 unsigned __user *p)
2534{
ae677517
AC
2535 int retval;
2536 unsigned int set, clear, val;
1da177e4 2537
ae677517 2538 if (tty->ops->tiocmset == NULL)
1b8b2086 2539 return -ENOTTY;
1da177e4 2540
ae677517
AC
2541 retval = get_user(val, p);
2542 if (retval)
2543 return retval;
2544 set = clear = 0;
2545 switch (cmd) {
2546 case TIOCMBIS:
2547 set = val;
2548 break;
2549 case TIOCMBIC:
2550 clear = val;
2551 break;
2552 case TIOCMSET:
2553 set = val;
2554 clear = ~val;
2555 break;
2556 }
2557 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2558 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
20b9d177 2559 return tty->ops->tiocmset(tty, set, clear);
1da177e4
LT
2560}
2561
d20c219c 2562/**
796a75a9
JS
2563 * tty_get_icount - get tty statistics
2564 * @tty: tty device
2565 * @icount: output parameter
d20c219c 2566 *
796a75a9 2567 * Gets a copy of the @tty's icount statistics.
d20c219c 2568 *
796a75a9 2569 * Locking: none (up to the driver)
d20c219c
UKK
2570 */
2571int tty_get_icount(struct tty_struct *tty,
2572 struct serial_icounter_struct *icount)
2573{
2574 memset(icount, 0, sizeof(*icount));
2575
2576 if (tty->ops->get_icount)
2577 return tty->ops->get_icount(tty, icount);
2578 else
1b8b2086 2579 return -ENOTTY;
d20c219c
UKK
2580}
2581EXPORT_SYMBOL_GPL(tty_get_icount);
2582
d281da7f
AC
2583static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2584{
d281da7f 2585 struct serial_icounter_struct icount;
d20c219c
UKK
2586 int retval;
2587
2588 retval = tty_get_icount(tty, &icount);
d281da7f
AC
2589 if (retval != 0)
2590 return retval;
d20c219c 2591
d281da7f
AC
2592 if (copy_to_user(arg, &icount, sizeof(icount)))
2593 return -EFAULT;
2594 return 0;
2595}
2596
885c77d5 2597static int tty_set_serial(struct tty_struct *tty, struct serial_struct *ss)
8a8ae62f 2598{
8a8ae62f
JS
2599 char comm[TASK_COMM_LEN];
2600 int flags;
2601
885c77d5 2602 flags = ss->flags & ASYNC_DEPRECATED;
8a8ae62f 2603
1b7bc6b1
JH
2604 if (flags)
2605 pr_warn_ratelimited("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2606 __func__, get_task_comm(comm, current), flags);
885c77d5 2607
2f46a2c1 2608 if (!tty->ops->set_serial)
930236a3 2609 return -ENOTTY;
885c77d5
JH
2610
2611 return tty->ops->set_serial(tty, ss);
2612}
2613
2614static int tty_tiocsserial(struct tty_struct *tty, struct serial_struct __user *ss)
2615{
2616 struct serial_struct v;
2617
2618 if (copy_from_user(&v, ss, sizeof(*ss)))
2619 return -EFAULT;
2620
2621 return tty_set_serial(tty, &v);
2f46a2c1
AV
2622}
2623
2624static int tty_tiocgserial(struct tty_struct *tty, struct serial_struct __user *ss)
2625{
2626 struct serial_struct v;
2627 int err;
2628
a3241891 2629 memset(&v, 0, sizeof(v));
2f46a2c1 2630 if (!tty->ops->get_serial)
930236a3 2631 return -ENOTTY;
2f46a2c1 2632 err = tty->ops->get_serial(tty, &v);
a3241891 2633 if (!err && copy_to_user(ss, &v, sizeof(v)))
2f46a2c1
AV
2634 err = -EFAULT;
2635 return err;
8a8ae62f
JS
2636}
2637
8f166e00
PH
2638/*
2639 * if pty, return the slave side (real_tty)
2640 * otherwise, return self
2641 */
2642static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
e8b70e7d
AC
2643{
2644 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2645 tty->driver->subtype == PTY_TYPE_MASTER)
2646 tty = tty->link;
2647 return tty;
2648}
e8b70e7d 2649
1da177e4
LT
2650/*
2651 * Split this up, as gcc can choke on it otherwise..
2652 */
04f378b1 2653long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1da177e4 2654{
d996b62a
NP
2655 struct tty_struct *tty = file_tty(file);
2656 struct tty_struct *real_tty;
1da177e4
LT
2657 void __user *p = (void __user *)arg;
2658 int retval;
2659 struct tty_ldisc *ld;
37bdfb07 2660
6131ffaa 2661 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
1da177e4
LT
2662 return -EINVAL;
2663
e8b70e7d 2664 real_tty = tty_pair_get_tty(tty);
1da177e4
LT
2665
2666 /*
2667 * Factor out some common prep work
2668 */
2669 switch (cmd) {
2670 case TIOCSETD:
2671 case TIOCSBRK:
2672 case TIOCCBRK:
2673 case TCSBRK:
37bdfb07 2674 case TCSBRKP:
1da177e4
LT
2675 retval = tty_check_change(tty);
2676 if (retval)
2677 return retval;
2678 if (cmd != TIOCCBRK) {
2679 tty_wait_until_sent(tty, 0);
2680 if (signal_pending(current))
2681 return -EINTR;
2682 }
2683 break;
2684 }
2685
9e98966c
AC
2686 /*
2687 * Now do the stuff.
2688 */
1da177e4 2689 switch (cmd) {
37bdfb07
AC
2690 case TIOCSTI:
2691 return tiocsti(tty, p);
2692 case TIOCGWINSZ:
8f520021 2693 return tiocgwinsz(real_tty, p);
37bdfb07 2694 case TIOCSWINSZ:
fc6f6238 2695 return tiocswinsz(real_tty, p);
37bdfb07
AC
2696 case TIOCCONS:
2697 return real_tty != tty ? -EINVAL : tioccons(file);
37bdfb07
AC
2698 case TIOCEXCL:
2699 set_bit(TTY_EXCLUSIVE, &tty->flags);
2700 return 0;
2701 case TIOCNXCL:
2702 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2703 return 0;
84fd7bdf
CG
2704 case TIOCGEXCL:
2705 {
2706 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
e73b2407 2707
84fd7bdf
CG
2708 return put_user(excl, (int __user *)p);
2709 }
37bdfb07 2710 case TIOCGETD:
5c17c861 2711 return tiocgetd(tty, p);
37bdfb07
AC
2712 case TIOCSETD:
2713 return tiocsetd(tty, p);
3c95c985
KS
2714 case TIOCVHANGUP:
2715 if (!capable(CAP_SYS_ADMIN))
2716 return -EPERM;
2717 tty_vhangup(tty);
2718 return 0;
b7b8de08
WF
2719 case TIOCGDEV:
2720 {
2721 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
e73b2407 2722
b7b8de08
WF
2723 return put_user(ret, (unsigned int __user *)p);
2724 }
37bdfb07
AC
2725 /*
2726 * Break handling
2727 */
2728 case TIOCSBRK: /* Turn break on, unconditionally */
f34d7a5b 2729 if (tty->ops->break_ctl)
9e98966c 2730 return tty->ops->break_ctl(tty, -1);
37bdfb07 2731 return 0;
37bdfb07 2732 case TIOCCBRK: /* Turn break off, unconditionally */
f34d7a5b 2733 if (tty->ops->break_ctl)
9e98966c 2734 return tty->ops->break_ctl(tty, 0);
37bdfb07
AC
2735 return 0;
2736 case TCSBRK: /* SVID version: non-zero arg --> no break */
2737 /* non-zero arg means wait for all output data
2738 * to be sent (performed above) but don't send break.
2739 * This is used by the tcdrain() termios function.
2740 */
2741 if (!arg)
2742 return send_break(tty, 250);
2743 return 0;
2744 case TCSBRKP: /* support for POSIX tcsendbreak() */
2745 return send_break(tty, arg ? arg*100 : 250);
2746
2747 case TIOCMGET:
60b33c13 2748 return tty_tiocmget(tty, p);
37bdfb07
AC
2749 case TIOCMSET:
2750 case TIOCMBIC:
2751 case TIOCMBIS:
20b9d177 2752 return tty_tiocmset(tty, cmd, p);
d281da7f 2753 case TIOCGICOUNT:
a3096199 2754 return tty_tiocgicount(tty, p);
37bdfb07
AC
2755 case TCFLSH:
2756 switch (arg) {
2757 case TCIFLUSH:
2758 case TCIOFLUSH:
2759 /* flush tty buffer and allow ldisc to process ioctl */
86c80a8e 2760 tty_buffer_flush(tty, NULL);
c5c34d48 2761 break;
37bdfb07
AC
2762 }
2763 break;
8a8ae62f 2764 case TIOCSSERIAL:
930236a3 2765 return tty_tiocsserial(tty, p);
2f46a2c1 2766 case TIOCGSERIAL:
930236a3 2767 return tty_tiocgserial(tty, p);
311fc65c
EB
2768 case TIOCGPTPEER:
2769 /* Special because the struct file is needed */
2770 return ptm_open_peer(file, tty, (int)arg);
a1235b3e
NP
2771 default:
2772 retval = tty_jobctrl_ioctl(tty, real_tty, file, cmd, arg);
2773 if (retval != -ENOIOCTLCMD)
2774 return retval;
1da177e4 2775 }
f34d7a5b 2776 if (tty->ops->ioctl) {
c961bfb1 2777 retval = tty->ops->ioctl(tty, cmd, arg);
1da177e4
LT
2778 if (retval != -ENOIOCTLCMD)
2779 return retval;
2780 }
2781 ld = tty_ldisc_ref_wait(tty);
e55afd11
PH
2782 if (!ld)
2783 return hung_up_tty_ioctl(file, cmd, arg);
1da177e4 2784 retval = -EINVAL;
a352def2 2785 if (ld->ops->ioctl) {
d78328bc 2786 retval = ld->ops->ioctl(tty, cmd, arg);
1da177e4 2787 if (retval == -ENOIOCTLCMD)
bbb63c51 2788 retval = -ENOTTY;
1da177e4
LT
2789 }
2790 tty_ldisc_deref(ld);
2791 return retval;
2792}
2793
e10cc1df 2794#ifdef CONFIG_COMPAT
77654350
AV
2795
2796struct serial_struct32 {
52b52e91
GS
2797 compat_int_t type;
2798 compat_int_t line;
2799 compat_uint_t port;
2800 compat_int_t irq;
2801 compat_int_t flags;
2802 compat_int_t xmit_fifo_size;
2803 compat_int_t custom_divisor;
2804 compat_int_t baud_base;
2805 unsigned short close_delay;
2806 char io_type;
2807 char reserved_char;
2808 compat_int_t hub6;
2809 unsigned short closing_wait; /* time to wait before closing */
2810 unsigned short closing_wait2; /* no longer used... */
2811 compat_uint_t iomem_base;
2812 unsigned short iomem_reg_shift;
2813 unsigned int port_high;
2814 /* compat_ulong_t iomap_base FIXME */
2815 compat_int_t reserved;
77654350
AV
2816};
2817
2818static int compat_tty_tiocsserial(struct tty_struct *tty,
2819 struct serial_struct32 __user *ss)
2820{
77654350
AV
2821 struct serial_struct32 v32;
2822 struct serial_struct v;
77654350 2823
a3241891 2824 if (copy_from_user(&v32, ss, sizeof(*ss)))
77654350
AV
2825 return -EFAULT;
2826
2827 memcpy(&v, &v32, offsetof(struct serial_struct32, iomem_base));
2828 v.iomem_base = compat_ptr(v32.iomem_base);
2829 v.iomem_reg_shift = v32.iomem_reg_shift;
2830 v.port_high = v32.port_high;
2831 v.iomap_base = 0;
2832
885c77d5 2833 return tty_set_serial(tty, &v);
77654350
AV
2834}
2835
2836static int compat_tty_tiocgserial(struct tty_struct *tty,
2837 struct serial_struct32 __user *ss)
2838{
2839 struct serial_struct32 v32;
2840 struct serial_struct v;
2841 int err;
17329563
EB
2842
2843 memset(&v, 0, sizeof(v));
2844 memset(&v32, 0, sizeof(v32));
77654350 2845
6e622cd8 2846 if (!tty->ops->get_serial)
77654350
AV
2847 return -ENOTTY;
2848 err = tty->ops->get_serial(tty, &v);
2849 if (!err) {
2850 memcpy(&v32, &v, offsetof(struct serial_struct32, iomem_base));
2851 v32.iomem_base = (unsigned long)v.iomem_base >> 32 ?
2852 0xfffffff : ptr_to_compat(v.iomem_base);
2853 v32.iomem_reg_shift = v.iomem_reg_shift;
2854 v32.port_high = v.port_high;
a3241891 2855 if (copy_to_user(ss, &v32, sizeof(v32)))
77654350
AV
2856 err = -EFAULT;
2857 }
2858 return err;
2859}
37bdfb07 2860static long tty_compat_ioctl(struct file *file, unsigned int cmd,
e10cc1df
PF
2861 unsigned long arg)
2862{
d996b62a 2863 struct tty_struct *tty = file_tty(file);
e10cc1df
PF
2864 struct tty_ldisc *ld;
2865 int retval = -ENOIOCTLCMD;
2866
e2112038 2867 switch (cmd) {
c7dc504e 2868 case TIOCOUTQ:
e2112038
AV
2869 case TIOCSTI:
2870 case TIOCGWINSZ:
2871 case TIOCSWINSZ:
2872 case TIOCGEXCL:
2873 case TIOCGETD:
2874 case TIOCSETD:
2875 case TIOCGDEV:
2876 case TIOCMGET:
2877 case TIOCMSET:
2878 case TIOCMBIC:
2879 case TIOCMBIS:
2880 case TIOCGICOUNT:
2881 case TIOCGPGRP:
2882 case TIOCSPGRP:
2883 case TIOCGSID:
2884 case TIOCSERGETLSR:
2885 case TIOCGRS485:
2886 case TIOCSRS485:
2887#ifdef TIOCGETP
2888 case TIOCGETP:
2889 case TIOCSETP:
2890 case TIOCSETN:
2891#endif
2892#ifdef TIOCGETC
2893 case TIOCGETC:
2894 case TIOCSETC:
2895#endif
2896#ifdef TIOCGLTC
2897 case TIOCGLTC:
2898 case TIOCSLTC:
2899#endif
2900 case TCSETSF:
2901 case TCSETSW:
2902 case TCSETS:
2903 case TCGETS:
2904#ifdef TCGETS2
2905 case TCGETS2:
2906 case TCSETSF2:
2907 case TCSETSW2:
2908 case TCSETS2:
2909#endif
2910 case TCGETA:
2911 case TCSETAF:
2912 case TCSETAW:
2913 case TCSETA:
2914 case TIOCGLCKTRMIOS:
2915 case TIOCSLCKTRMIOS:
2916#ifdef TCGETX
2917 case TCGETX:
2918 case TCSETX:
2919 case TCSETXW:
2920 case TCSETXF:
2921#endif
2922 case TIOCGSOFTCAR:
2923 case TIOCSSOFTCAR:
b7aff093
AB
2924
2925 case PPPIOCGCHAN:
2926 case PPPIOCGUNIT:
e2112038
AV
2927 return tty_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
2928 case TIOCCONS:
2929 case TIOCEXCL:
2930 case TIOCNXCL:
2931 case TIOCVHANGUP:
2932 case TIOCSBRK:
2933 case TIOCCBRK:
2934 case TCSBRK:
2935 case TCSBRKP:
2936 case TCFLSH:
2937 case TIOCGPTPEER:
2938 case TIOCNOTTY:
2939 case TIOCSCTTY:
2940 case TCXONC:
2941 case TIOCMIWAIT:
2942 case TIOCSERCONFIG:
2943 return tty_ioctl(file, cmd, arg);
2944 }
2945
6131ffaa 2946 if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
e10cc1df
PF
2947 return -EINVAL;
2948
77654350
AV
2949 switch (cmd) {
2950 case TIOCSSERIAL:
2951 return compat_tty_tiocsserial(tty, compat_ptr(arg));
2952 case TIOCGSERIAL:
2953 return compat_tty_tiocgserial(tty, compat_ptr(arg));
2954 }
f34d7a5b 2955 if (tty->ops->compat_ioctl) {
c961bfb1 2956 retval = tty->ops->compat_ioctl(tty, cmd, arg);
e10cc1df
PF
2957 if (retval != -ENOIOCTLCMD)
2958 return retval;
2959 }
2960
2961 ld = tty_ldisc_ref_wait(tty);
e55afd11
PH
2962 if (!ld)
2963 return hung_up_tty_compat_ioctl(file, cmd, arg);
a352def2 2964 if (ld->ops->compat_ioctl)
d78328bc 2965 retval = ld->ops->compat_ioctl(tty, cmd, arg);
f0193d3e 2966 if (retval == -ENOIOCTLCMD && ld->ops->ioctl)
d78328bc
JS
2967 retval = ld->ops->ioctl(tty, (unsigned long)compat_ptr(cmd),
2968 arg);
e10cc1df
PF
2969 tty_ldisc_deref(ld);
2970
2971 return retval;
2972}
2973#endif
1da177e4 2974
c3c073f8
AV
2975static int this_tty(const void *t, struct file *file, unsigned fd)
2976{
dd78b0c4 2977 if (likely(file->f_op->read_iter != tty_read))
c3c073f8
AV
2978 return 0;
2979 return file_tty(file) != t ? 0 : fd + 1;
2980}
d91c1a3e 2981
1da177e4
LT
2982/*
2983 * This implements the "Secure Attention Key" --- the idea is to
2984 * prevent trojan horses by killing all processes associated with this
2985 * tty when the user hits the "Secure Attention Key". Required for
2986 * super-paranoid applications --- see the Orange Book for more details.
37bdfb07 2987 *
1da177e4
LT
2988 * This code could be nicer; ideally it should send a HUP, wait a few
2989 * seconds, then send a INT, and then a KILL signal. But you then
2990 * have to coordinate with the init process, since all processes associated
2991 * with the current tty must be dead before the new getty is allowed
2992 * to spawn.
2993 *
2994 * Now, if it would be correct ;-/ The current code has a nasty hole -
2995 * it doesn't catch files in flight. We may send the descriptor to ourselves
2996 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2997 *
2998 * Nasty bug: do_SAK is being called in interrupt context. This can
2999 * deadlock. We punt it up to process context. AKPM - 16Mar2001
3000 */
8b6312f4 3001void __do_SAK(struct tty_struct *tty)
1da177e4 3002{
652486fb 3003 struct task_struct *g, *p;
ab521dc0 3004 struct pid *session;
954a0881 3005 int i;
c8bcd9c5 3006 unsigned long flags;
37bdfb07 3007
64d608db
JS
3008 spin_lock_irqsave(&tty->ctrl.lock, flags);
3009 session = get_pid(tty->ctrl.session);
3010 spin_unlock_irqrestore(&tty->ctrl.lock, flags);
37bdfb07 3011
b3f13deb 3012 tty_ldisc_flush(tty);
1da177e4 3013
f34d7a5b 3014 tty_driver_flush_buffer(tty);
37bdfb07 3015
1da177e4 3016 read_lock(&tasklist_lock);
652486fb 3017 /* Kill the entire session */
ab521dc0 3018 do_each_pid_task(session, PIDTYPE_SID, p) {
9b42bb75
PH
3019 tty_notice(tty, "SAK: killed process %d (%s): by session\n",
3020 task_pid_nr(p), p->comm);
a8ebd171 3021 group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p, PIDTYPE_SID);
ab521dc0 3022 } while_each_pid_task(session, PIDTYPE_SID, p);
9b42bb75
PH
3023
3024 /* Now kill any processes that happen to have the tty open */
652486fb
EB
3025 do_each_thread(g, p) {
3026 if (p->signal->tty == tty) {
9b42bb75
PH
3027 tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n",
3028 task_pid_nr(p), p->comm);
954a0881
JS
3029 group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p,
3030 PIDTYPE_SID);
1da177e4
LT
3031 continue;
3032 }
3033 task_lock(p);
c3c073f8
AV
3034 i = iterate_fd(p->files, 0, this_tty, tty);
3035 if (i != 0) {
9b42bb75
PH
3036 tty_notice(tty, "SAK: killed process %d (%s): by fd#%d\n",
3037 task_pid_nr(p), p->comm, i - 1);
954a0881
JS
3038 group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p,
3039 PIDTYPE_SID);
1da177e4
LT
3040 }
3041 task_unlock(p);
652486fb 3042 } while_each_thread(g, p);
1da177e4 3043 read_unlock(&tasklist_lock);
c8bcd9c5 3044 put_pid(session);
1da177e4
LT
3045}
3046
8b6312f4
EB
3047static void do_SAK_work(struct work_struct *work)
3048{
3049 struct tty_struct *tty =
3050 container_of(work, struct tty_struct, SAK_work);
3051 __do_SAK(tty);
3052}
3053
1da177e4
LT
3054/*
3055 * The tq handling here is a little racy - tty->SAK_work may already be queued.
3056 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3057 * the values which we write to it will be identical to the values which it
3058 * already has. --akpm
3059 */
3060void do_SAK(struct tty_struct *tty)
3061{
3062 if (!tty)
3063 return;
1da177e4
LT
3064 schedule_work(&tty->SAK_work);
3065}
1da177e4
LT
3066EXPORT_SYMBOL(do_SAK);
3067
30004ac9
DES
3068/* Must put_device() after it's unused! */
3069static struct device *tty_get_device(struct tty_struct *tty)
3070{
3071 dev_t devt = tty_devnum(tty);
e73b2407 3072
862d8312 3073 return class_find_device_by_devt(&tty_class, devt);
30004ac9
DES
3074}
3075
3076
796a75a9
JS
3077/**
3078 * alloc_tty_struct - allocate a new tty
3079 * @driver: driver which will handle the returned tty
3080 * @idx: minor of the tty
af9b897e 3081 *
796a75a9 3082 * This subroutine allocates and initializes a tty structure.
af9b897e 3083 *
796a75a9 3084 * Locking: none - @tty in question is not exposed at this point
1da177e4 3085 */
2c964a2f 3086struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
1da177e4 3087{
2c964a2f
RV
3088 struct tty_struct *tty;
3089
c72d8592 3090 tty = kzalloc(sizeof(*tty), GFP_KERNEL_ACCOUNT);
2c964a2f
RV
3091 if (!tty)
3092 return NULL;
3093
9c9f4ded 3094 kref_init(&tty->kref);
903f9db1
TH
3095 if (tty_ldisc_init(tty)) {
3096 kfree(tty);
3097 return NULL;
3098 }
64d608db
JS
3099 tty->ctrl.session = NULL;
3100 tty->ctrl.pgrp = NULL;
89c8d91e 3101 mutex_init(&tty->legacy_mutex);
d8c1f929 3102 mutex_init(&tty->throttle_mutex);
6a1c0680 3103 init_rwsem(&tty->termios_rwsem);
dee4a0be 3104 mutex_init(&tty->winsize_mutex);
36697529 3105 init_ldsem(&tty->ldisc_sem);
1da177e4
LT
3106 init_waitqueue_head(&tty->write_wait);
3107 init_waitqueue_head(&tty->read_wait);
65f27f38 3108 INIT_WORK(&tty->hangup_work, do_tty_hangup);
70522e12 3109 mutex_init(&tty->atomic_write_lock);
64d608db 3110 spin_lock_init(&tty->ctrl.lock);
6e94dbc7 3111 spin_lock_init(&tty->flow.lock);
4a510969 3112 spin_lock_init(&tty->files_lock);
1da177e4 3113 INIT_LIST_HEAD(&tty->tty_files);
7f1f86a0 3114 INIT_WORK(&tty->SAK_work, do_SAK_work);
bf970ee4
AC
3115
3116 tty->driver = driver;
3117 tty->ops = driver->ops;
3118 tty->index = idx;
3119 tty_line_name(driver, idx, tty->name);
30004ac9 3120 tty->dev = tty_get_device(tty);
2c964a2f
RV
3121
3122 return tty;
1da177e4
LT
3123}
3124
f34d7a5b 3125/**
796a75a9
JS
3126 * tty_put_char - write one character to a tty
3127 * @tty: tty
3128 * @ch: character to write
3129 *
3130 * Write one byte to the @tty using the provided @tty->ops->put_char() method
3131 * if present.
f34d7a5b 3132 *
796a75a9
JS
3133 * Note: the specific put_char operation in the driver layer may go
3134 * away soon. Don't call it directly, use this method
f34d7a5b 3135 *
796a75a9 3136 * Return: the number of characters successfully output.
1da177e4 3137 */
f34d7a5b 3138int tty_put_char(struct tty_struct *tty, unsigned char ch)
1da177e4 3139{
f34d7a5b
AC
3140 if (tty->ops->put_char)
3141 return tty->ops->put_char(tty, ch);
3142 return tty->ops->write(tty, &ch, 1);
1da177e4 3143}
f34d7a5b
AC
3144EXPORT_SYMBOL_GPL(tty_put_char);
3145
7e73eca6
JS
3146static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3147 unsigned int index, unsigned int count)
3148{
c1a752ba
LY
3149 int err;
3150
7e73eca6 3151 /* init here, since reused cdevs cause crashes */
a3a10ce3
RW
3152 driver->cdevs[index] = cdev_alloc();
3153 if (!driver->cdevs[index])
3154 return -ENOMEM;
c1a752ba 3155 driver->cdevs[index]->ops = &tty_fops;
a3a10ce3 3156 driver->cdevs[index]->owner = driver->owner;
c1a752ba
LY
3157 err = cdev_add(driver->cdevs[index], dev, count);
3158 if (err)
3159 kobject_put(&driver->cdevs[index]->kobj);
3160 return err;
7e73eca6
JS
3161}
3162
1da177e4 3163/**
796a75a9
JS
3164 * tty_register_device - register a tty device
3165 * @driver: the tty driver that describes the tty device
3166 * @index: the index in the tty driver for this tty device
3167 * @device: a struct device that is associated with this tty device.
3168 * This field is optional, if there is no known struct device
3169 * for this tty device it can be set to NULL safely.
1da177e4 3170 *
796a75a9
JS
3171 * This call is required to be made to register an individual tty device
3172 * if the tty driver's flags have the %TTY_DRIVER_DYNAMIC_DEV bit set. If
3173 * that bit is not set, this function should not be called by a tty
3174 * driver.
1cdcb6b4 3175 *
796a75a9 3176 * Locking: ??
af9b897e 3177 *
796a75a9
JS
3178 * Return: A pointer to the struct device for this tty device (or
3179 * ERR_PTR(-EFOO) on error).
1da177e4 3180 */
01107d34
GKH
3181struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3182 struct device *device)
1da177e4 3183{
6915c0e4
TH
3184 return tty_register_device_attr(driver, index, device, NULL, NULL);
3185}
3186EXPORT_SYMBOL(tty_register_device);
3187
b1b79916
TH
3188static void tty_device_create_release(struct device *dev)
3189{
83db1df4 3190 dev_dbg(dev, "releasing...\n");
b1b79916
TH
3191 kfree(dev);
3192}
3193
6915c0e4 3194/**
796a75a9
JS
3195 * tty_register_device_attr - register a tty device
3196 * @driver: the tty driver that describes the tty device
3197 * @index: the index in the tty driver for this tty device
3198 * @device: a struct device that is associated with this tty device.
3199 * This field is optional, if there is no known struct device
3200 * for this tty device it can be set to %NULL safely.
3201 * @drvdata: Driver data to be set to device.
3202 * @attr_grp: Attribute group to be set on device.
6915c0e4 3203 *
796a75a9
JS
3204 * This call is required to be made to register an individual tty device if the
3205 * tty driver's flags have the %TTY_DRIVER_DYNAMIC_DEV bit set. If that bit is
3206 * not set, this function should not be called by a tty driver.
6915c0e4 3207 *
796a75a9 3208 * Locking: ??
6915c0e4 3209 *
796a75a9
JS
3210 * Return: A pointer to the struct device for this tty device (or
3211 * ERR_PTR(-EFOO) on error).
6915c0e4
TH
3212 */
3213struct device *tty_register_device_attr(struct tty_driver *driver,
3214 unsigned index, struct device *device,
3215 void *drvdata,
3216 const struct attribute_group **attr_grp)
3217{
1da177e4 3218 char name[64];
6915c0e4 3219 dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
93857edd 3220 struct ktermios *tp;
6a7e6f78
JH
3221 struct device *dev;
3222 int retval;
1da177e4
LT
3223
3224 if (index >= driver->num) {
656fb867
PH
3225 pr_err("%s: Attempt to register invalid tty line number (%d)\n",
3226 driver->name, index);
1cdcb6b4 3227 return ERR_PTR(-EINVAL);
1da177e4
LT
3228 }
3229
1da177e4
LT
3230 if (driver->type == TTY_DRIVER_TYPE_PTY)
3231 pty_line_name(driver, index, name);
3232 else
3233 tty_line_name(driver, index, name);
1cdcb6b4 3234
6915c0e4 3235 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
6a7e6f78
JH
3236 if (!dev)
3237 return ERR_PTR(-ENOMEM);
7e73eca6 3238
6915c0e4 3239 dev->devt = devt;
862d8312 3240 dev->class = &tty_class;
6915c0e4 3241 dev->parent = device;
b1b79916 3242 dev->release = tty_device_create_release;
6915c0e4
TH
3243 dev_set_name(dev, "%s", name);
3244 dev->groups = attr_grp;
3245 dev_set_drvdata(dev, drvdata);
3246
6a7e6f78
JH
3247 dev_set_uevent_suppress(dev, 1);
3248
6915c0e4
TH
3249 retval = device_register(dev);
3250 if (retval)
6a7e6f78
JH
3251 goto err_put;
3252
3253 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
93857edd
JH
3254 /*
3255 * Free any saved termios data so that the termios state is
3256 * reset when reusing a minor number.
3257 */
3258 tp = driver->termios[index];
3259 if (tp) {
3260 driver->termios[index] = NULL;
3261 kfree(tp);
3262 }
3263
6a7e6f78
JH
3264 retval = tty_cdev_add(driver, devt, index, 1);
3265 if (retval)
3266 goto err_del;
3267 }
3268
3269 dev_set_uevent_suppress(dev, 0);
3270 kobject_uevent(&dev->kobj, KOBJ_ADD);
6915c0e4
TH
3271
3272 return dev;
3273
6a7e6f78
JH
3274err_del:
3275 device_del(dev);
3276err_put:
6915c0e4 3277 put_device(dev);
6a7e6f78 3278
6915c0e4 3279 return ERR_PTR(retval);
1da177e4 3280}
6915c0e4 3281EXPORT_SYMBOL_GPL(tty_register_device_attr);
1da177e4
LT
3282
3283/**
796a75a9
JS
3284 * tty_unregister_device - unregister a tty device
3285 * @driver: the tty driver that describes the tty device
3286 * @index: the index in the tty driver for this tty device
1da177e4 3287 *
796a75a9
JS
3288 * If a tty device is registered with a call to tty_register_device() then
3289 * this function must be called when the tty device is gone.
af9b897e 3290 *
796a75a9 3291 * Locking: ??
1da177e4
LT
3292 */
3293void tty_unregister_device(struct tty_driver *driver, unsigned index)
3294{
862d8312 3295 device_destroy(&tty_class, MKDEV(driver->major, driver->minor_start) + index);
a3a10ce3
RW
3296 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3297 cdev_del(driver->cdevs[index]);
3298 driver->cdevs[index] = NULL;
3299 }
1da177e4 3300}
1da177e4
LT
3301EXPORT_SYMBOL(tty_unregister_device);
3302
7f0bc6a6
JS
3303/**
3304 * __tty_alloc_driver -- allocate tty driver
3305 * @lines: count of lines this driver can handle at most
87838ae3 3306 * @owner: module which is responsible for this driver
796a75a9 3307 * @flags: some of %TTY_DRIVER_ flags, will be set in driver->flags
7f0bc6a6
JS
3308 *
3309 * This should not be called directly, some of the provided macros should be
796a75a9 3310 * used instead. Use IS_ERR() and friends on @retval.
7f0bc6a6
JS
3311 */
3312struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3313 unsigned long flags)
1da177e4
LT
3314{
3315 struct tty_driver *driver;
7e73eca6 3316 unsigned int cdevs = 1;
16a02081 3317 int err;
1da177e4 3318
0019b408 3319 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
7f0bc6a6
JS
3320 return ERR_PTR(-EINVAL);
3321
a3241891 3322 driver = kzalloc(sizeof(*driver), GFP_KERNEL);
7f0bc6a6
JS
3323 if (!driver)
3324 return ERR_PTR(-ENOMEM);
3325
3326 kref_init(&driver->kref);
7f0bc6a6
JS
3327 driver->num = lines;
3328 driver->owner = owner;
3329 driver->flags = flags;
16a02081
JS
3330
3331 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3332 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3333 GFP_KERNEL);
3334 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3335 GFP_KERNEL);
3336 if (!driver->ttys || !driver->termios) {
3337 err = -ENOMEM;
3338 goto err_free_all;
3339 }
3340 }
3341
3342 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3343 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3344 GFP_KERNEL);
3345 if (!driver->ports) {
3346 err = -ENOMEM;
3347 goto err_free_all;
3348 }
7e73eca6
JS
3349 cdevs = lines;
3350 }
3351
3352 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3353 if (!driver->cdevs) {
3354 err = -ENOMEM;
3355 goto err_free_all;
16a02081 3356 }
7f0bc6a6 3357
1da177e4 3358 return driver;
16a02081
JS
3359err_free_all:
3360 kfree(driver->ports);
3361 kfree(driver->ttys);
3362 kfree(driver->termios);
a3a10ce3 3363 kfree(driver->cdevs);
16a02081
JS
3364 kfree(driver);
3365 return ERR_PTR(err);
1da177e4 3366}
7f0bc6a6 3367EXPORT_SYMBOL(__tty_alloc_driver);
1da177e4 3368
7d7b93c1 3369static void destruct_tty_driver(struct kref *kref)
1da177e4 3370{
7d7b93c1
AC
3371 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3372 int i;
3373 struct ktermios *tp;
7d7b93c1
AC
3374
3375 if (driver->flags & TTY_DRIVER_INSTALLED) {
7d7b93c1
AC
3376 for (i = 0; i < driver->num; i++) {
3377 tp = driver->termios[i];
3378 if (tp) {
3379 driver->termios[i] = NULL;
3380 kfree(tp);
3381 }
7d7b93c1
AC
3382 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3383 tty_unregister_device(driver, i);
3384 }
7d7b93c1 3385 proc_tty_unregister_driver(driver);
7e73eca6 3386 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
a3a10ce3 3387 cdev_del(driver->cdevs[0]);
7d7b93c1 3388 }
7e73eca6 3389 kfree(driver->cdevs);
04831dc1 3390 kfree(driver->ports);
16a02081
JS
3391 kfree(driver->termios);
3392 kfree(driver->ttys);
1da177e4
LT
3393 kfree(driver);
3394}
3395
38581283
JS
3396/**
3397 * tty_driver_kref_put -- drop a reference to a tty driver
3398 * @driver: driver of which to drop the reference
3399 *
3400 * The final put will destroy and free up the driver.
3401 */
7d7b93c1
AC
3402void tty_driver_kref_put(struct tty_driver *driver)
3403{
3404 kref_put(&driver->kref, destruct_tty_driver);
3405}
3406EXPORT_SYMBOL(tty_driver_kref_put);
3407
38581283
JS
3408/**
3409 * tty_register_driver -- register a tty driver
3410 * @driver: driver to register
3411 *
1da177e4
LT
3412 * Called by a tty driver to register itself.
3413 */
3414int tty_register_driver(struct tty_driver *driver)
3415{
3416 int error;
37bdfb07 3417 int i;
1da177e4 3418 dev_t dev;
b670bde0 3419 struct device *d;
1da177e4 3420
1da177e4 3421 if (!driver->major) {
37bdfb07
AC
3422 error = alloc_chrdev_region(&dev, driver->minor_start,
3423 driver->num, driver->name);
1da177e4
LT
3424 if (!error) {
3425 driver->major = MAJOR(dev);
3426 driver->minor_start = MINOR(dev);
3427 }
3428 } else {
3429 dev = MKDEV(driver->major, driver->minor_start);
e5717c48 3430 error = register_chrdev_region(dev, driver->num, driver->name);
1da177e4 3431 }
9bb8a3d4 3432 if (error < 0)
16a02081 3433 goto err;
1da177e4 3434
7e73eca6
JS
3435 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3436 error = tty_cdev_add(driver, dev, 0, driver->num);
3437 if (error)
3438 goto err_unreg_char;
3439 }
1da177e4 3440
ca509f69 3441 mutex_lock(&tty_mutex);
1da177e4 3442 list_add(&driver->tty_drivers, &tty_drivers);
ca509f69 3443 mutex_unlock(&tty_mutex);
37bdfb07
AC
3444
3445 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
b670bde0
VK
3446 for (i = 0; i < driver->num; i++) {
3447 d = tty_register_device(driver, i, NULL);
3448 if (IS_ERR(d)) {
3449 error = PTR_ERR(d);
16a02081 3450 goto err_unreg_devs;
b670bde0
VK
3451 }
3452 }
1da177e4
LT
3453 }
3454 proc_tty_register_driver(driver);
7d7b93c1 3455 driver->flags |= TTY_DRIVER_INSTALLED;
1da177e4 3456 return 0;
b670bde0 3457
16a02081 3458err_unreg_devs:
b670bde0
VK
3459 for (i--; i >= 0; i--)
3460 tty_unregister_device(driver, i);
3461
3462 mutex_lock(&tty_mutex);
3463 list_del(&driver->tty_drivers);
3464 mutex_unlock(&tty_mutex);
3465
9bb8a3d4 3466err_unreg_char:
b670bde0 3467 unregister_chrdev_region(dev, driver->num);
16a02081 3468err:
b670bde0 3469 return error;
1da177e4 3470}
1da177e4
LT
3471EXPORT_SYMBOL(tty_register_driver);
3472
38581283
JS
3473/**
3474 * tty_unregister_driver -- unregister a tty driver
3475 * @driver: driver to unregister
3476 *
1da177e4
LT
3477 * Called by a tty driver to unregister itself.
3478 */
a872ab4d 3479void tty_unregister_driver(struct tty_driver *driver)
1da177e4 3480{
1da177e4
LT
3481 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3482 driver->num);
ca509f69 3483 mutex_lock(&tty_mutex);
1da177e4 3484 list_del(&driver->tty_drivers);
ca509f69 3485 mutex_unlock(&tty_mutex);
1da177e4 3486}
1da177e4
LT
3487EXPORT_SYMBOL(tty_unregister_driver);
3488
24ec839c
PZ
3489dev_t tty_devnum(struct tty_struct *tty)
3490{
3491 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3492}
3493EXPORT_SYMBOL(tty_devnum);
1da177e4 3494
d81ed103
AC
3495void tty_default_fops(struct file_operations *fops)
3496{
3497 *fops = tty_fops;
3498}
3499
ff62b8e6 3500static char *tty_devnode(const struct device *dev, umode_t *mode)
e454cea2
KS
3501{
3502 if (!mode)
3503 return NULL;
3504 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3505 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3506 *mode = 0666;
3507 return NULL;
3508}
3509
862d8312
GKH
3510const struct class tty_class = {
3511 .name = "tty",
3512 .devnode = tty_devnode,
3513};
3514
1da177e4
LT
3515static int __init tty_class_init(void)
3516{
862d8312 3517 return class_register(&tty_class);
1da177e4
LT
3518}
3519
3520postcore_initcall(tty_class_init);
3521
3522/* 3/2004 jmc: why do these devices exist? */
1da177e4 3523static struct cdev tty_cdev, console_cdev;
1da177e4 3524
fbc92a34
KS
3525static ssize_t show_cons_active(struct device *dev,
3526 struct device_attribute *attr, char *buf)
3527{
3528 struct console *cs[16];
3529 int i = 0;
3530 struct console *c;
3531 ssize_t count = 0;
3532
d25a2e74 3533 /*
7c2af0f6 3534 * Hold the console_list_lock to guarantee that no consoles are
d25a2e74
JO
3535 * unregistered until all console processing is complete.
3536 * This also allows safe traversal of the console list and
3537 * race-free reading of @flags.
d25a2e74 3538 */
7c2af0f6
JO
3539 console_list_lock();
3540
a2a6a822 3541 for_each_console(c) {
fbc92a34
KS
3542 if (!c->device)
3543 continue;
3544 if (!c->write)
3545 continue;
3546 if ((c->flags & CON_ENABLED) == 0)
3547 continue;
3548 cs[i++] = c;
3549 if (i >= ARRAY_SIZE(cs))
3550 break;
3551 }
7c2af0f6
JO
3552
3553 /*
3554 * Take console_lock to serialize device() callback with
3555 * other console operations. For example, fg_console is
3556 * modified under console_lock when switching vt.
3557 */
3558 console_lock();
723abd87
HR
3559 while (i--) {
3560 int index = cs[i]->index;
3561 struct tty_driver *drv = cs[i]->device(cs[i], &index);
3562
3563 /* don't resolve tty0 as some programs depend on it */
3564 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
3565 count += tty_line_name(drv, index, buf + count);
3566 else
3567 count += sprintf(buf + count, "%s%d",
3568 cs[i]->name, cs[i]->index);
3569
3570 count += sprintf(buf + count, "%c", i ? ' ':'\n');
3571 }
ac751efa 3572 console_unlock();
fbc92a34 3573
7c2af0f6
JO
3574 console_list_unlock();
3575
fbc92a34
KS
3576 return count;
3577}
3578static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3579
1083a7be
TI
3580static struct attribute *cons_dev_attrs[] = {
3581 &dev_attr_active.attr,
3582 NULL
3583};
3584
3585ATTRIBUTE_GROUPS(cons_dev);
3586
fbc92a34
KS
3587static struct device *consdev;
3588
3589void console_sysfs_notify(void)
3590{
3591 if (consdev)
3592 sysfs_notify(&consdev->kobj, NULL, "active");
3593}
3594
5fd8c2d3 3595static struct ctl_table tty_table[] = {
83efeeeb
KC
3596 {
3597 .procname = "legacy_tiocsti",
3598 .data = &tty_legacy_tiocsti,
3599 .maxlen = sizeof(tty_legacy_tiocsti),
3600 .mode = 0644,
3601 .proc_handler = proc_dobool,
3602 },
5fd8c2d3
KC
3603 {
3604 .procname = "ldisc_autoload",
3605 .data = &tty_ldisc_autoload,
3606 .maxlen = sizeof(tty_ldisc_autoload),
3607 .mode = 0644,
3608 .proc_handler = proc_dointvec,
3609 .extra1 = SYSCTL_ZERO,
3610 .extra2 = SYSCTL_ONE,
3611 },
3612 { }
3613};
3614
1da177e4
LT
3615/*
3616 * Ok, now we can initialize the rest of the tty devices and can count
3617 * on memory allocations, interrupts etc..
3618 */
31d1d48e 3619int __init tty_init(void)
1da177e4 3620{
6d12b774 3621 register_sysctl_init("dev/tty", tty_table);
1da177e4
LT
3622 cdev_init(&tty_cdev, &tty_fops);
3623 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3624 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3625 panic("Couldn't register /dev/tty driver\n");
862d8312 3626 device_create(&tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
1da177e4
LT
3627
3628 cdev_init(&console_cdev, &console_fops);
3629 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3630 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3631 panic("Couldn't register /dev/console driver\n");
862d8312 3632 consdev = device_create_with_groups(&tty_class, NULL,
1083a7be
TI
3633 MKDEV(TTYAUX_MAJOR, 1), NULL,
3634 cons_dev_groups, "console");
fbc92a34
KS
3635 if (IS_ERR(consdev))
3636 consdev = NULL;
1da177e4 3637
1da177e4 3638#ifdef CONFIG_VT
d81ed103 3639 vty_init(&console_fops);
1da177e4
LT
3640#endif
3641 return 0;
3642}