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