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