Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (C) 1991, 1992 Linus Torvalds
4 : *
5 : * Added support for a Unix98-style ptmx device.
6 : * -- C. Scott Ananian <[email protected]>, 14-Jan-1998
7 : *
8 : */
9 :
10 : #include <linux/module.h>
11 : #include <linux/errno.h>
12 : #include <linux/interrupt.h>
13 : #include <linux/tty.h>
14 : #include <linux/tty_flip.h>
15 : #include <linux/fcntl.h>
16 : #include <linux/sched/signal.h>
17 : #include <linux/string.h>
18 : #include <linux/major.h>
19 : #include <linux/mm.h>
20 : #include <linux/init.h>
21 : #include <linux/device.h>
22 : #include <linux/uaccess.h>
23 : #include <linux/bitops.h>
24 : #include <linux/devpts_fs.h>
25 : #include <linux/slab.h>
26 : #include <linux/mutex.h>
27 : #include <linux/poll.h>
28 : #include <linux/mount.h>
29 : #include <linux/file.h>
30 : #include <linux/ioctl.h>
31 : #include <linux/compat.h>
32 : #include "tty.h"
33 :
34 : #undef TTY_DEBUG_HANGUP
35 : #ifdef TTY_DEBUG_HANGUP
36 : # define tty_debug_hangup(tty, f, args...) tty_debug(tty, f, ##args)
37 : #else
38 : # define tty_debug_hangup(tty, f, args...) do {} while (0)
39 : #endif
40 :
41 : #ifdef CONFIG_UNIX98_PTYS
42 : static struct tty_driver *ptm_driver;
43 : static struct tty_driver *pts_driver;
44 : static DEFINE_MUTEX(devpts_mutex);
45 : #endif
46 :
47 0 : static void pty_close(struct tty_struct *tty, struct file *filp)
48 : {
49 0 : if (tty->driver->subtype == PTY_TYPE_MASTER)
50 0 : WARN_ON(tty->count > 1);
51 : else {
52 0 : if (tty_io_error(tty))
53 0 : return;
54 0 : if (tty->count > 2)
55 0 : return;
56 : }
57 0 : set_bit(TTY_IO_ERROR, &tty->flags);
58 0 : wake_up_interruptible(&tty->read_wait);
59 0 : wake_up_interruptible(&tty->write_wait);
60 0 : spin_lock_irq(&tty->ctrl.lock);
61 0 : tty->ctrl.packet = false;
62 0 : spin_unlock_irq(&tty->ctrl.lock);
63 : /* Review - krefs on tty_link ?? */
64 0 : if (!tty->link)
65 0 : return;
66 0 : set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
67 0 : wake_up_interruptible(&tty->link->read_wait);
68 0 : wake_up_interruptible(&tty->link->write_wait);
69 0 : if (tty->driver->subtype == PTY_TYPE_MASTER) {
70 0 : set_bit(TTY_OTHER_CLOSED, &tty->flags);
71 : #ifdef CONFIG_UNIX98_PTYS
72 0 : if (tty->driver == ptm_driver) {
73 0 : mutex_lock(&devpts_mutex);
74 0 : if (tty->link->driver_data)
75 0 : devpts_pty_kill(tty->link->driver_data);
76 0 : mutex_unlock(&devpts_mutex);
77 0 : }
78 : #endif
79 0 : tty_vhangup(tty->link);
80 0 : }
81 0 : }
82 :
83 : /*
84 : * The unthrottle routine is called by the line discipline to signal
85 : * that it can receive more characters. For PTY's, the TTY_THROTTLED
86 : * flag is always set, to force the line discipline to always call the
87 : * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
88 : * characters in the queue. This is necessary since each time this
89 : * happens, we need to wake up any sleeping processes that could be
90 : * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
91 : * for the pty buffer to be drained.
92 : */
93 0 : static void pty_unthrottle(struct tty_struct *tty)
94 : {
95 0 : tty_wakeup(tty->link);
96 0 : set_bit(TTY_THROTTLED, &tty->flags);
97 0 : }
98 :
99 : /**
100 : * pty_write - write to a pty
101 : * @tty: the tty we write from
102 : * @buf: kernel buffer of data
103 : * @c: bytes to write
104 : *
105 : * Our "hardware" write method. Data is coming from the ldisc which
106 : * may be in a non sleeping state. We simply throw this at the other
107 : * end of the link as if we were an IRQ handler receiving stuff for
108 : * the other side of the pty/tty pair.
109 : */
110 :
111 52 : static ssize_t pty_write(struct tty_struct *tty, const u8 *buf, size_t c)
112 : {
113 52 : struct tty_struct *to = tty->link;
114 :
115 52 : if (tty->flow.stopped || !c)
116 0 : return 0;
117 :
118 52 : return tty_insert_flip_string_and_push_buffer(to->port, buf, c);
119 52 : }
120 :
121 : /**
122 : * pty_write_room - write space
123 : * @tty: tty we are writing from
124 : *
125 : * Report how many bytes the ldisc can send into the queue for
126 : * the other device.
127 : */
128 :
129 89 : static unsigned int pty_write_room(struct tty_struct *tty)
130 : {
131 89 : if (tty->flow.stopped)
132 0 : return 0;
133 89 : return tty_buffer_space_avail(tty->link->port);
134 89 : }
135 :
136 : /* Set the lock flag on a pty */
137 0 : static int pty_set_lock(struct tty_struct *tty, int __user *arg)
138 : {
139 0 : int val;
140 :
141 0 : if (get_user(val, arg))
142 0 : return -EFAULT;
143 0 : if (val)
144 0 : set_bit(TTY_PTY_LOCK, &tty->flags);
145 : else
146 0 : clear_bit(TTY_PTY_LOCK, &tty->flags);
147 0 : return 0;
148 0 : }
149 :
150 0 : static int pty_get_lock(struct tty_struct *tty, int __user *arg)
151 : {
152 0 : int locked = test_bit(TTY_PTY_LOCK, &tty->flags);
153 :
154 0 : return put_user(locked, arg);
155 0 : }
156 :
157 : /* Set the packet mode on a pty */
158 0 : static int pty_set_pktmode(struct tty_struct *tty, int __user *arg)
159 : {
160 0 : int pktmode;
161 :
162 0 : if (get_user(pktmode, arg))
163 0 : return -EFAULT;
164 :
165 0 : spin_lock_irq(&tty->ctrl.lock);
166 0 : if (pktmode) {
167 0 : if (!tty->ctrl.packet) {
168 0 : tty->link->ctrl.pktstatus = 0;
169 0 : smp_mb();
170 0 : tty->ctrl.packet = true;
171 0 : }
172 0 : } else
173 0 : tty->ctrl.packet = false;
174 0 : spin_unlock_irq(&tty->ctrl.lock);
175 :
176 0 : return 0;
177 0 : }
178 :
179 : /* Get the packet mode of a pty */
180 0 : static int pty_get_pktmode(struct tty_struct *tty, int __user *arg)
181 : {
182 0 : int pktmode = tty->ctrl.packet;
183 :
184 0 : return put_user(pktmode, arg);
185 0 : }
186 :
187 : /* Send a signal to the slave */
188 0 : static int pty_signal(struct tty_struct *tty, int sig)
189 : {
190 0 : struct pid *pgrp;
191 :
192 0 : if (sig != SIGINT && sig != SIGQUIT && sig != SIGTSTP)
193 0 : return -EINVAL;
194 :
195 0 : if (tty->link) {
196 0 : pgrp = tty_get_pgrp(tty->link);
197 0 : if (pgrp)
198 0 : kill_pgrp(pgrp, sig, 1);
199 0 : put_pid(pgrp);
200 0 : }
201 0 : return 0;
202 0 : }
203 :
204 0 : static void pty_flush_buffer(struct tty_struct *tty)
205 : {
206 0 : struct tty_struct *to = tty->link;
207 :
208 0 : if (!to)
209 0 : return;
210 :
211 0 : tty_buffer_flush(to, NULL);
212 0 : if (to->ctrl.packet) {
213 0 : spin_lock_irq(&tty->ctrl.lock);
214 0 : tty->ctrl.pktstatus |= TIOCPKT_FLUSHWRITE;
215 0 : wake_up_interruptible(&to->read_wait);
216 0 : spin_unlock_irq(&tty->ctrl.lock);
217 0 : }
218 0 : }
219 :
220 0 : static int pty_open(struct tty_struct *tty, struct file *filp)
221 : {
222 0 : if (!tty || !tty->link)
223 0 : return -ENODEV;
224 :
225 0 : if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
226 0 : goto out;
227 0 : if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
228 0 : goto out;
229 0 : if (tty->driver->subtype == PTY_TYPE_SLAVE && tty->link->count != 1)
230 0 : goto out;
231 :
232 0 : clear_bit(TTY_IO_ERROR, &tty->flags);
233 0 : clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
234 0 : set_bit(TTY_THROTTLED, &tty->flags);
235 0 : return 0;
236 :
237 : out:
238 0 : set_bit(TTY_IO_ERROR, &tty->flags);
239 0 : return -EIO;
240 0 : }
241 :
242 0 : static void pty_set_termios(struct tty_struct *tty,
243 : const struct ktermios *old_termios)
244 : {
245 : /* See if packet mode change of state. */
246 0 : if (tty->link && tty->link->ctrl.packet) {
247 0 : int extproc = (old_termios->c_lflag & EXTPROC) | L_EXTPROC(tty);
248 0 : int old_flow = ((old_termios->c_iflag & IXON) &&
249 0 : (old_termios->c_cc[VSTOP] == '\023') &&
250 0 : (old_termios->c_cc[VSTART] == '\021'));
251 0 : int new_flow = (I_IXON(tty) &&
252 0 : STOP_CHAR(tty) == '\023' &&
253 0 : START_CHAR(tty) == '\021');
254 0 : if ((old_flow != new_flow) || extproc) {
255 0 : spin_lock_irq(&tty->ctrl.lock);
256 0 : if (old_flow != new_flow) {
257 0 : tty->ctrl.pktstatus &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
258 0 : if (new_flow)
259 0 : tty->ctrl.pktstatus |= TIOCPKT_DOSTOP;
260 : else
261 0 : tty->ctrl.pktstatus |= TIOCPKT_NOSTOP;
262 0 : }
263 0 : if (extproc)
264 0 : tty->ctrl.pktstatus |= TIOCPKT_IOCTL;
265 0 : spin_unlock_irq(&tty->ctrl.lock);
266 0 : wake_up_interruptible(&tty->link->read_wait);
267 0 : }
268 0 : }
269 :
270 0 : tty->termios.c_cflag &= ~(CSIZE | PARENB);
271 0 : tty->termios.c_cflag |= (CS8 | CREAD);
272 0 : }
273 :
274 : /**
275 : * pty_resize - resize event
276 : * @tty: tty being resized
277 : * @ws: window size being set.
278 : *
279 : * Update the termios variables and send the necessary signals to
280 : * peform a terminal resize correctly
281 : */
282 :
283 0 : static int pty_resize(struct tty_struct *tty, struct winsize *ws)
284 : {
285 0 : struct pid *pgrp, *rpgrp;
286 0 : struct tty_struct *pty = tty->link;
287 :
288 : /* For a PTY we need to lock the tty side */
289 0 : mutex_lock(&tty->winsize_mutex);
290 0 : if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
291 0 : goto done;
292 :
293 : /* Signal the foreground process group of both ptys */
294 0 : pgrp = tty_get_pgrp(tty);
295 0 : rpgrp = tty_get_pgrp(pty);
296 :
297 0 : if (pgrp)
298 0 : kill_pgrp(pgrp, SIGWINCH, 1);
299 0 : if (rpgrp != pgrp && rpgrp)
300 0 : kill_pgrp(rpgrp, SIGWINCH, 1);
301 :
302 0 : put_pid(pgrp);
303 0 : put_pid(rpgrp);
304 :
305 0 : tty->winsize = *ws;
306 0 : pty->winsize = *ws; /* Never used so will go away soon */
307 : done:
308 0 : mutex_unlock(&tty->winsize_mutex);
309 0 : return 0;
310 0 : }
311 :
312 : /**
313 : * pty_start - start() handler
314 : * pty_stop - stop() handler
315 : * @tty: tty being flow-controlled
316 : *
317 : * Propagates the TIOCPKT status to the master pty.
318 : *
319 : * NB: only the master pty can be in packet mode so only the slave
320 : * needs start()/stop() handlers
321 : */
322 0 : static void pty_start(struct tty_struct *tty)
323 : {
324 0 : unsigned long flags;
325 :
326 0 : if (tty->link && tty->link->ctrl.packet) {
327 0 : spin_lock_irqsave(&tty->ctrl.lock, flags);
328 0 : tty->ctrl.pktstatus &= ~TIOCPKT_STOP;
329 0 : tty->ctrl.pktstatus |= TIOCPKT_START;
330 0 : spin_unlock_irqrestore(&tty->ctrl.lock, flags);
331 0 : wake_up_interruptible_poll(&tty->link->read_wait, EPOLLIN);
332 0 : }
333 0 : }
334 :
335 0 : static void pty_stop(struct tty_struct *tty)
336 : {
337 0 : unsigned long flags;
338 :
339 0 : if (tty->link && tty->link->ctrl.packet) {
340 0 : spin_lock_irqsave(&tty->ctrl.lock, flags);
341 0 : tty->ctrl.pktstatus &= ~TIOCPKT_START;
342 0 : tty->ctrl.pktstatus |= TIOCPKT_STOP;
343 0 : spin_unlock_irqrestore(&tty->ctrl.lock, flags);
344 0 : wake_up_interruptible_poll(&tty->link->read_wait, EPOLLIN);
345 0 : }
346 0 : }
347 :
348 : /**
349 : * pty_common_install - set up the pty pair
350 : * @driver: the pty driver
351 : * @tty: the tty being instantiated
352 : * @legacy: true if this is BSD style
353 : *
354 : * Perform the initial set up for the tty/pty pair. Called from the
355 : * tty layer when the port is first opened.
356 : *
357 : * Locking: the caller must hold the tty_mutex
358 : */
359 0 : static int pty_common_install(struct tty_driver *driver, struct tty_struct *tty,
360 : bool legacy)
361 : {
362 0 : struct tty_struct *o_tty;
363 0 : struct tty_port *ports[2];
364 0 : int idx = tty->index;
365 0 : int retval = -ENOMEM;
366 :
367 : /* Opening the slave first has always returned -EIO */
368 0 : if (driver->subtype != PTY_TYPE_MASTER)
369 0 : return -EIO;
370 :
371 0 : ports[0] = kmalloc(sizeof **ports, GFP_KERNEL);
372 0 : ports[1] = kmalloc(sizeof **ports, GFP_KERNEL);
373 0 : if (!ports[0] || !ports[1])
374 0 : goto err;
375 0 : if (!try_module_get(driver->other->owner)) {
376 : /* This cannot in fact currently happen */
377 0 : goto err;
378 : }
379 0 : o_tty = alloc_tty_struct(driver->other, idx);
380 0 : if (!o_tty)
381 0 : goto err_put_module;
382 :
383 0 : tty_set_lock_subclass(o_tty);
384 0 : lockdep_set_subclass(&o_tty->termios_rwsem, TTY_LOCK_SLAVE);
385 :
386 0 : if (legacy) {
387 : /* We always use new tty termios data so we can do this
388 : the easy way .. */
389 0 : tty_init_termios(tty);
390 0 : tty_init_termios(o_tty);
391 :
392 0 : driver->other->ttys[idx] = o_tty;
393 0 : driver->ttys[idx] = tty;
394 0 : } else {
395 0 : memset(&tty->termios_locked, 0, sizeof(tty->termios_locked));
396 0 : tty->termios = driver->init_termios;
397 0 : memset(&o_tty->termios_locked, 0, sizeof(tty->termios_locked));
398 0 : o_tty->termios = driver->other->init_termios;
399 : }
400 :
401 : /*
402 : * Everything allocated ... set up the o_tty structure.
403 : */
404 0 : tty_driver_kref_get(driver->other);
405 : /* Establish the links in both directions */
406 0 : tty->link = o_tty;
407 0 : o_tty->link = tty;
408 0 : tty_port_init(ports[0]);
409 0 : tty_port_init(ports[1]);
410 0 : tty_buffer_set_limit(ports[0], 8192);
411 0 : tty_buffer_set_limit(ports[1], 8192);
412 0 : o_tty->port = ports[0];
413 0 : tty->port = ports[1];
414 0 : o_tty->port->itty = o_tty;
415 :
416 0 : tty_buffer_set_lock_subclass(o_tty->port);
417 :
418 0 : tty_driver_kref_get(driver);
419 0 : tty->count++;
420 0 : o_tty->count++;
421 0 : return 0;
422 :
423 : err_put_module:
424 0 : module_put(driver->other->owner);
425 : err:
426 0 : kfree(ports[0]);
427 0 : kfree(ports[1]);
428 0 : return retval;
429 0 : }
430 :
431 0 : static void pty_cleanup(struct tty_struct *tty)
432 : {
433 0 : tty_port_put(tty->port);
434 0 : }
435 :
436 : /* Traditional BSD devices */
437 : #ifdef CONFIG_LEGACY_PTYS
438 :
439 : static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
440 : {
441 : return pty_common_install(driver, tty, true);
442 : }
443 :
444 : static void pty_remove(struct tty_driver *driver, struct tty_struct *tty)
445 : {
446 : struct tty_struct *pair = tty->link;
447 :
448 : driver->ttys[tty->index] = NULL;
449 : if (pair)
450 : pair->driver->ttys[pair->index] = NULL;
451 : }
452 :
453 : static int pty_bsd_ioctl(struct tty_struct *tty,
454 : unsigned int cmd, unsigned long arg)
455 : {
456 : switch (cmd) {
457 : case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
458 : return pty_set_lock(tty, (int __user *) arg);
459 : case TIOCGPTLCK: /* Get PT Lock status */
460 : return pty_get_lock(tty, (int __user *)arg);
461 : case TIOCPKT: /* Set PT packet mode */
462 : return pty_set_pktmode(tty, (int __user *)arg);
463 : case TIOCGPKT: /* Get PT packet mode */
464 : return pty_get_pktmode(tty, (int __user *)arg);
465 : case TIOCSIG: /* Send signal to other side of pty */
466 : return pty_signal(tty, (int) arg);
467 : case TIOCGPTN: /* TTY returns ENOTTY, but glibc expects EINVAL here */
468 : return -EINVAL;
469 : }
470 : return -ENOIOCTLCMD;
471 : }
472 :
473 : #ifdef CONFIG_COMPAT
474 : static long pty_bsd_compat_ioctl(struct tty_struct *tty,
475 : unsigned int cmd, unsigned long arg)
476 : {
477 : /*
478 : * PTY ioctls don't require any special translation between 32-bit and
479 : * 64-bit userspace, they are already compatible.
480 : */
481 : return pty_bsd_ioctl(tty, cmd, (unsigned long)compat_ptr(arg));
482 : }
483 : #else
484 : #define pty_bsd_compat_ioctl NULL
485 : #endif
486 :
487 : static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
488 : /*
489 : * not really modular, but the easiest way to keep compat with existing
490 : * bootargs behaviour is to continue using module_param here.
491 : */
492 : module_param(legacy_count, int, 0);
493 :
494 : /*
495 : * The master side of a pty can do TIOCSPTLCK and thus
496 : * has pty_bsd_ioctl.
497 : */
498 : static const struct tty_operations master_pty_ops_bsd = {
499 : .install = pty_install,
500 : .open = pty_open,
501 : .close = pty_close,
502 : .write = pty_write,
503 : .write_room = pty_write_room,
504 : .flush_buffer = pty_flush_buffer,
505 : .unthrottle = pty_unthrottle,
506 : .ioctl = pty_bsd_ioctl,
507 : .compat_ioctl = pty_bsd_compat_ioctl,
508 : .cleanup = pty_cleanup,
509 : .resize = pty_resize,
510 : .remove = pty_remove
511 : };
512 :
513 : static const struct tty_operations slave_pty_ops_bsd = {
514 : .install = pty_install,
515 : .open = pty_open,
516 : .close = pty_close,
517 : .write = pty_write,
518 : .write_room = pty_write_room,
519 : .flush_buffer = pty_flush_buffer,
520 : .unthrottle = pty_unthrottle,
521 : .set_termios = pty_set_termios,
522 : .cleanup = pty_cleanup,
523 : .resize = pty_resize,
524 : .start = pty_start,
525 : .stop = pty_stop,
526 : .remove = pty_remove
527 : };
528 :
529 : static void __init legacy_pty_init(void)
530 : {
531 : struct tty_driver *pty_driver, *pty_slave_driver;
532 :
533 : if (legacy_count <= 0)
534 : return;
535 :
536 : pty_driver = tty_alloc_driver(legacy_count,
537 : TTY_DRIVER_RESET_TERMIOS |
538 : TTY_DRIVER_REAL_RAW |
539 : TTY_DRIVER_DYNAMIC_ALLOC);
540 : if (IS_ERR(pty_driver))
541 : panic("Couldn't allocate pty driver");
542 :
543 : pty_slave_driver = tty_alloc_driver(legacy_count,
544 : TTY_DRIVER_RESET_TERMIOS |
545 : TTY_DRIVER_REAL_RAW |
546 : TTY_DRIVER_DYNAMIC_ALLOC);
547 : if (IS_ERR(pty_slave_driver))
548 : panic("Couldn't allocate pty slave driver");
549 :
550 : pty_driver->driver_name = "pty_master";
551 : pty_driver->name = "pty";
552 : pty_driver->major = PTY_MASTER_MAJOR;
553 : pty_driver->minor_start = 0;
554 : pty_driver->type = TTY_DRIVER_TYPE_PTY;
555 : pty_driver->subtype = PTY_TYPE_MASTER;
556 : pty_driver->init_termios = tty_std_termios;
557 : pty_driver->init_termios.c_iflag = 0;
558 : pty_driver->init_termios.c_oflag = 0;
559 : pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
560 : pty_driver->init_termios.c_lflag = 0;
561 : pty_driver->init_termios.c_ispeed = 38400;
562 : pty_driver->init_termios.c_ospeed = 38400;
563 : pty_driver->other = pty_slave_driver;
564 : tty_set_operations(pty_driver, &master_pty_ops_bsd);
565 :
566 : pty_slave_driver->driver_name = "pty_slave";
567 : pty_slave_driver->name = "ttyp";
568 : pty_slave_driver->major = PTY_SLAVE_MAJOR;
569 : pty_slave_driver->minor_start = 0;
570 : pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
571 : pty_slave_driver->subtype = PTY_TYPE_SLAVE;
572 : pty_slave_driver->init_termios = tty_std_termios;
573 : pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
574 : pty_slave_driver->init_termios.c_ispeed = 38400;
575 : pty_slave_driver->init_termios.c_ospeed = 38400;
576 : pty_slave_driver->other = pty_driver;
577 : tty_set_operations(pty_slave_driver, &slave_pty_ops_bsd);
578 :
579 : if (tty_register_driver(pty_driver))
580 : panic("Couldn't register pty driver");
581 : if (tty_register_driver(pty_slave_driver))
582 : panic("Couldn't register pty slave driver");
583 : }
584 : #else
585 0 : static inline void legacy_pty_init(void) { }
586 : #endif
587 :
588 : /* Unix98 devices */
589 : #ifdef CONFIG_UNIX98_PTYS
590 : static struct cdev ptmx_cdev;
591 :
592 : /**
593 : * ptm_open_peer - open the peer of a pty
594 : * @master: the open struct file of the ptmx device node
595 : * @tty: the master of the pty being opened
596 : * @flags: the flags for open
597 : *
598 : * Provide a race free way for userspace to open the slave end of a pty
599 : * (where they have the master fd and cannot access or trust the mount
600 : * namespace /dev/pts was mounted inside).
601 : */
602 0 : int ptm_open_peer(struct file *master, struct tty_struct *tty, int flags)
603 : {
604 0 : int fd;
605 0 : struct file *filp;
606 0 : int retval = -EINVAL;
607 0 : struct path path;
608 :
609 0 : if (tty->driver != ptm_driver)
610 0 : return -EIO;
611 :
612 0 : fd = get_unused_fd_flags(flags);
613 0 : if (fd < 0) {
614 0 : retval = fd;
615 0 : goto err;
616 : }
617 :
618 : /* Compute the slave's path */
619 0 : path.mnt = devpts_mntget(master, tty->driver_data);
620 0 : if (IS_ERR(path.mnt)) {
621 0 : retval = PTR_ERR(path.mnt);
622 0 : goto err_put;
623 : }
624 0 : path.dentry = tty->link->driver_data;
625 :
626 0 : filp = dentry_open(&path, flags, current_cred());
627 0 : mntput(path.mnt);
628 0 : if (IS_ERR(filp)) {
629 0 : retval = PTR_ERR(filp);
630 0 : goto err_put;
631 : }
632 :
633 0 : fd_install(fd, filp);
634 0 : return fd;
635 :
636 : err_put:
637 0 : put_unused_fd(fd);
638 : err:
639 0 : return retval;
640 0 : }
641 :
642 0 : static int pty_unix98_ioctl(struct tty_struct *tty,
643 : unsigned int cmd, unsigned long arg)
644 : {
645 0 : switch (cmd) {
646 : case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
647 0 : return pty_set_lock(tty, (int __user *)arg);
648 : case TIOCGPTLCK: /* Get PT Lock status */
649 0 : return pty_get_lock(tty, (int __user *)arg);
650 : case TIOCPKT: /* Set PT packet mode */
651 0 : return pty_set_pktmode(tty, (int __user *)arg);
652 : case TIOCGPKT: /* Get PT packet mode */
653 0 : return pty_get_pktmode(tty, (int __user *)arg);
654 : case TIOCGPTN: /* Get PT Number */
655 0 : return put_user(tty->index, (unsigned int __user *)arg);
656 : case TIOCSIG: /* Send signal to other side of pty */
657 0 : return pty_signal(tty, (int) arg);
658 : }
659 :
660 0 : return -ENOIOCTLCMD;
661 0 : }
662 :
663 : #ifdef CONFIG_COMPAT
664 0 : static long pty_unix98_compat_ioctl(struct tty_struct *tty,
665 : unsigned int cmd, unsigned long arg)
666 : {
667 : /*
668 : * PTY ioctls don't require any special translation between 32-bit and
669 : * 64-bit userspace, they are already compatible.
670 : */
671 0 : return pty_unix98_ioctl(tty, cmd,
672 0 : cmd == TIOCSIG ? arg : (unsigned long)compat_ptr(arg));
673 : }
674 : #else
675 : #define pty_unix98_compat_ioctl NULL
676 : #endif
677 :
678 : /**
679 : * ptm_unix98_lookup - find a pty master
680 : * @driver: ptm driver
681 : * @file: unused
682 : * @idx: tty index
683 : *
684 : * Look up a pty master device. Called under the tty_mutex for now.
685 : * This provides our locking.
686 : */
687 :
688 0 : static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
689 : struct file *file, int idx)
690 : {
691 : /* Master must be open via /dev/ptmx */
692 0 : return ERR_PTR(-EIO);
693 : }
694 :
695 : /**
696 : * pts_unix98_lookup - find a pty slave
697 : * @driver: pts driver
698 : * @file: file pointer to tty
699 : * @idx: tty index
700 : *
701 : * Look up a pty master device. Called under the tty_mutex for now.
702 : * This provides our locking for the tty pointer.
703 : */
704 :
705 0 : static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
706 : struct file *file, int idx)
707 : {
708 0 : struct tty_struct *tty;
709 :
710 0 : mutex_lock(&devpts_mutex);
711 0 : tty = devpts_get_priv(file->f_path.dentry);
712 0 : mutex_unlock(&devpts_mutex);
713 : /* Master must be open before slave */
714 0 : if (!tty)
715 0 : return ERR_PTR(-EIO);
716 0 : return tty;
717 0 : }
718 :
719 0 : static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
720 : {
721 0 : return pty_common_install(driver, tty, false);
722 : }
723 :
724 : /* this is called once with whichever end is closed last */
725 0 : static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
726 : {
727 0 : struct pts_fs_info *fsi;
728 :
729 0 : if (tty->driver->subtype == PTY_TYPE_MASTER)
730 0 : fsi = tty->driver_data;
731 : else
732 0 : fsi = tty->link->driver_data;
733 :
734 0 : if (fsi) {
735 0 : devpts_kill_index(fsi, tty->index);
736 0 : devpts_release(fsi);
737 0 : }
738 0 : }
739 :
740 0 : static void pty_show_fdinfo(struct tty_struct *tty, struct seq_file *m)
741 : {
742 0 : seq_printf(m, "tty-index:\t%d\n", tty->index);
743 0 : }
744 :
745 : static const struct tty_operations ptm_unix98_ops = {
746 : .lookup = ptm_unix98_lookup,
747 : .install = pty_unix98_install,
748 : .remove = pty_unix98_remove,
749 : .open = pty_open,
750 : .close = pty_close,
751 : .write = pty_write,
752 : .write_room = pty_write_room,
753 : .flush_buffer = pty_flush_buffer,
754 : .unthrottle = pty_unthrottle,
755 : .ioctl = pty_unix98_ioctl,
756 : .compat_ioctl = pty_unix98_compat_ioctl,
757 : .resize = pty_resize,
758 : .cleanup = pty_cleanup,
759 : .show_fdinfo = pty_show_fdinfo,
760 : };
761 :
762 : static const struct tty_operations pty_unix98_ops = {
763 : .lookup = pts_unix98_lookup,
764 : .install = pty_unix98_install,
765 : .remove = pty_unix98_remove,
766 : .open = pty_open,
767 : .close = pty_close,
768 : .write = pty_write,
769 : .write_room = pty_write_room,
770 : .flush_buffer = pty_flush_buffer,
771 : .unthrottle = pty_unthrottle,
772 : .set_termios = pty_set_termios,
773 : .start = pty_start,
774 : .stop = pty_stop,
775 : .cleanup = pty_cleanup,
776 : };
777 :
778 : /**
779 : * ptmx_open - open a unix 98 pty master
780 : * @inode: inode of device file
781 : * @filp: file pointer to tty
782 : *
783 : * Allocate a unix98 pty master device from the ptmx driver.
784 : *
785 : * Locking: tty_mutex protects the init_dev work. tty->count should
786 : * protect the rest.
787 : * allocated_ptys_lock handles the list of free pty numbers
788 : */
789 :
790 0 : static int ptmx_open(struct inode *inode, struct file *filp)
791 : {
792 0 : struct pts_fs_info *fsi;
793 0 : struct tty_struct *tty;
794 0 : struct dentry *dentry;
795 0 : int retval;
796 0 : int index;
797 :
798 0 : nonseekable_open(inode, filp);
799 :
800 : /* We refuse fsnotify events on ptmx, since it's a shared resource */
801 0 : file_set_fsnotify_mode(filp, FMODE_NONOTIFY);
802 :
803 0 : retval = tty_alloc_file(filp);
804 0 : if (retval)
805 0 : return retval;
806 :
807 0 : fsi = devpts_acquire(filp);
808 0 : if (IS_ERR(fsi)) {
809 0 : retval = PTR_ERR(fsi);
810 0 : goto out_free_file;
811 : }
812 :
813 : /* find a device that is not in use. */
814 0 : mutex_lock(&devpts_mutex);
815 0 : index = devpts_new_index(fsi);
816 0 : mutex_unlock(&devpts_mutex);
817 :
818 0 : retval = index;
819 0 : if (index < 0)
820 0 : goto out_put_fsi;
821 :
822 :
823 0 : mutex_lock(&tty_mutex);
824 0 : tty = tty_init_dev(ptm_driver, index);
825 : /* The tty returned here is locked so we can safely
826 : drop the mutex */
827 0 : mutex_unlock(&tty_mutex);
828 :
829 0 : retval = PTR_ERR(tty);
830 0 : if (IS_ERR(tty))
831 0 : goto out;
832 :
833 : /*
834 : * From here on out, the tty is "live", and the index and
835 : * fsi will be killed/put by the tty_release()
836 : */
837 0 : set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
838 0 : tty->driver_data = fsi;
839 :
840 0 : tty_add_file(tty, filp);
841 :
842 0 : dentry = devpts_pty_new(fsi, index, tty->link);
843 0 : if (IS_ERR(dentry)) {
844 0 : retval = PTR_ERR(dentry);
845 0 : goto err_release;
846 : }
847 0 : tty->link->driver_data = dentry;
848 :
849 0 : retval = ptm_driver->ops->open(tty, filp);
850 0 : if (retval)
851 0 : goto err_release;
852 :
853 0 : tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
854 :
855 0 : tty_unlock(tty);
856 0 : return 0;
857 : err_release:
858 0 : tty_unlock(tty);
859 : // This will also put-ref the fsi
860 0 : tty_release(inode, filp);
861 0 : return retval;
862 : out:
863 0 : devpts_kill_index(fsi, index);
864 : out_put_fsi:
865 0 : devpts_release(fsi);
866 : out_free_file:
867 0 : tty_free_file(filp);
868 0 : return retval;
869 0 : }
870 :
871 : static struct file_operations ptmx_fops __ro_after_init;
872 :
873 0 : static void __init unix98_pty_init(void)
874 : {
875 0 : ptm_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX,
876 : TTY_DRIVER_RESET_TERMIOS |
877 : TTY_DRIVER_REAL_RAW |
878 : TTY_DRIVER_DYNAMIC_DEV |
879 : TTY_DRIVER_DEVPTS_MEM |
880 : TTY_DRIVER_DYNAMIC_ALLOC);
881 0 : if (IS_ERR(ptm_driver))
882 0 : panic("Couldn't allocate Unix98 ptm driver");
883 0 : pts_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX,
884 : TTY_DRIVER_RESET_TERMIOS |
885 : TTY_DRIVER_REAL_RAW |
886 : TTY_DRIVER_DYNAMIC_DEV |
887 : TTY_DRIVER_DEVPTS_MEM |
888 : TTY_DRIVER_DYNAMIC_ALLOC);
889 0 : if (IS_ERR(pts_driver))
890 0 : panic("Couldn't allocate Unix98 pts driver");
891 :
892 0 : ptm_driver->driver_name = "pty_master";
893 0 : ptm_driver->name = "ptm";
894 0 : ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
895 0 : ptm_driver->minor_start = 0;
896 0 : ptm_driver->type = TTY_DRIVER_TYPE_PTY;
897 0 : ptm_driver->subtype = PTY_TYPE_MASTER;
898 0 : ptm_driver->init_termios = tty_std_termios;
899 0 : ptm_driver->init_termios.c_iflag = 0;
900 0 : ptm_driver->init_termios.c_oflag = 0;
901 0 : ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
902 0 : ptm_driver->init_termios.c_lflag = 0;
903 0 : ptm_driver->init_termios.c_ispeed = 38400;
904 0 : ptm_driver->init_termios.c_ospeed = 38400;
905 0 : ptm_driver->other = pts_driver;
906 0 : tty_set_operations(ptm_driver, &ptm_unix98_ops);
907 :
908 0 : pts_driver->driver_name = "pty_slave";
909 0 : pts_driver->name = "pts";
910 0 : pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
911 0 : pts_driver->minor_start = 0;
912 0 : pts_driver->type = TTY_DRIVER_TYPE_PTY;
913 0 : pts_driver->subtype = PTY_TYPE_SLAVE;
914 0 : pts_driver->init_termios = tty_std_termios;
915 0 : pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
916 0 : pts_driver->init_termios.c_ispeed = 38400;
917 0 : pts_driver->init_termios.c_ospeed = 38400;
918 0 : pts_driver->other = ptm_driver;
919 0 : tty_set_operations(pts_driver, &pty_unix98_ops);
920 :
921 0 : if (tty_register_driver(ptm_driver))
922 0 : panic("Couldn't register Unix98 ptm driver");
923 0 : if (tty_register_driver(pts_driver))
924 0 : panic("Couldn't register Unix98 pts driver");
925 :
926 : /* Now create the /dev/ptmx special device */
927 0 : tty_default_fops(&ptmx_fops);
928 0 : ptmx_fops.open = ptmx_open;
929 :
930 0 : cdev_init(&ptmx_cdev, &ptmx_fops);
931 0 : if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
932 0 : register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
933 0 : panic("Couldn't register /dev/ptmx driver");
934 0 : device_create(&tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
935 0 : }
936 :
937 : #else
938 : static inline void unix98_pty_init(void) { }
939 : #endif
940 :
941 0 : static int __init pty_init(void)
942 : {
943 0 : legacy_pty_init();
944 0 : unix98_pty_init();
945 0 : return 0;
946 : }
947 : device_initcall(pty_init);
|
