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