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