blob: 5505ffc91da4b5780b33af2cac624ea8f696f5e4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 1991, 1992 Linus Torvalds
3 *
4 * Added support for a Unix98-style ptmx device.
5 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
Alan Coxfe9cd962008-10-13 10:43:38 +01007 * When reading this code see also fs/devpts. In particular note that the
8 * driver_data field is used by the devpts side as a binding to the devpts
9 * inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 */
11
Alan Coxfe9cd962008-10-13 10:43:38 +010012#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013
14#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/interrupt.h>
16#include <linux/tty.h>
17#include <linux/tty_flip.h>
18#include <linux/fcntl.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040019#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/string.h>
21#include <linux/major.h>
22#include <linux/mm.h>
23#include <linux/init.h>
Alan Coxd81ed102008-10-13 10:41:42 +010024#include <linux/device.h>
Alan Coxfe9cd962008-10-13 10:43:38 +010025#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/bitops.h>
27#include <linux/devpts_fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090028#include <linux/slab.h>
Alan Coxd739e652012-05-03 22:22:09 +010029#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Alan Coxfe9cd962008-10-13 10:43:38 +010031
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#ifdef CONFIG_UNIX98_PTYS
Roel Kluinda2bdf92009-01-07 18:09:15 -080033static struct tty_driver *ptm_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034static struct tty_driver *pts_driver;
Alan Coxd739e652012-05-03 22:22:09 +010035static DEFINE_MUTEX(devpts_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#endif
37
Alan Coxfe9cd962008-10-13 10:43:38 +010038static void pty_close(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070039{
Alan Coxfe9cd962008-10-13 10:43:38 +010040 BUG_ON(!tty);
41 if (tty->driver->subtype == PTY_TYPE_MASTER)
42 WARN_ON(tty->count > 1);
43 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 if (tty->count > 2)
45 return;
46 }
47 wake_up_interruptible(&tty->read_wait);
48 wake_up_interruptible(&tty->write_wait);
49 tty->packet = 0;
50 if (!tty->link)
51 return;
52 tty->link->packet = 0;
53 set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
54 wake_up_interruptible(&tty->link->read_wait);
55 wake_up_interruptible(&tty->link->write_wait);
56 if (tty->driver->subtype == PTY_TYPE_MASTER) {
57 set_bit(TTY_OTHER_CLOSED, &tty->flags);
Greg Kroah-Hartmance1000d2012-02-24 13:56:36 -080058#ifdef CONFIG_UNIX98_PTYS
Alan Coxd739e652012-05-03 22:22:09 +010059 if (tty->driver == ptm_driver) {
60 mutex_lock(&devpts_mutex);
Greg Kroah-Hartmance1000d2012-02-24 13:56:36 -080061 devpts_pty_kill(tty->link);
Alan Coxd739e652012-05-03 22:22:09 +010062 mutex_unlock(&devpts_mutex);
63 }
Greg Kroah-Hartmance1000d2012-02-24 13:56:36 -080064#endif
Linus Torvaldsf3095322012-06-02 15:21:43 -070065 tty_unlock();
Arnd Bergmann11dbf202010-06-18 14:58:07 +020066 tty_vhangup(tty->link);
Linus Torvaldsf3095322012-06-02 15:21:43 -070067 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 }
69}
70
71/*
72 * The unthrottle routine is called by the line discipline to signal
73 * that it can receive more characters. For PTY's, the TTY_THROTTLED
74 * flag is always set, to force the line discipline to always call the
Alan Coxfe9cd962008-10-13 10:43:38 +010075 * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 * characters in the queue. This is necessary since each time this
77 * happens, we need to wake up any sleeping processes that could be
78 * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
79 * for the pty buffer to be drained.
80 */
Alan Coxfe9cd962008-10-13 10:43:38 +010081static void pty_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
Alan Coxd945cb92009-07-07 16:39:41 +010083 tty_wakeup(tty->link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 set_bit(TTY_THROTTLED, &tty->flags);
85}
86
Alan Coxd945cb92009-07-07 16:39:41 +010087/**
88 * pty_space - report space left for writing
89 * @to: tty we are writing into
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 *
Alan Coxd945cb92009-07-07 16:39:41 +010091 * The tty buffers allow 64K but we sneak a peak and clip at 8K this
92 * allows a lot of overspill room for echo and other fun messes to
93 * be handled properly
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 */
Alan Coxd945cb92009-07-07 16:39:41 +010095
96static int pty_space(struct tty_struct *to)
97{
98 int n = 8192 - to->buf.memory_used;
99 if (n < 0)
100 return 0;
101 return n;
102}
103
104/**
105 * pty_write - write to a pty
106 * @tty: the tty we write from
107 * @buf: kernel buffer of data
108 * @count: bytes to write
109 *
110 * Our "hardware" write method. Data is coming from the ldisc which
111 * may be in a non sleeping state. We simply throw this at the other
112 * end of the link as if we were an IRQ handler receiving stuff for
113 * the other side of the pty/tty pair.
114 */
115
Linus Torvaldsac89a912009-09-05 13:27:10 -0700116static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
118 struct tty_struct *to = tty->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Alan Coxd945cb92009-07-07 16:39:41 +0100120 if (tty->stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 return 0;
122
Alan Coxd945cb92009-07-07 16:39:41 +0100123 if (c > 0) {
124 /* Stuff the data into the input queue of the other end */
125 c = tty_insert_flip_string(to, buf, c);
126 /* And shovel */
Linus Torvalds202c4672009-09-18 07:05:58 -0700127 if (c) {
128 tty_flip_buffer_push(to);
129 tty_wakeup(tty);
130 }
Alan Cox762faae2009-06-16 17:01:13 +0100131 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 return c;
133}
134
Alan Coxd945cb92009-07-07 16:39:41 +0100135/**
136 * pty_write_room - write space
137 * @tty: tty we are writing from
138 *
139 * Report how many bytes the ldisc can send into the queue for
140 * the other device.
141 */
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143static int pty_write_room(struct tty_struct *tty)
144{
Linus Torvalds85dfd812009-08-10 13:21:19 -0700145 if (tty->stopped)
146 return 0;
Alan Coxd945cb92009-07-07 16:39:41 +0100147 return pty_space(tty->link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
Alan Coxd945cb92009-07-07 16:39:41 +0100150/**
151 * pty_chars_in_buffer - characters currently in our tx queue
152 * @tty: our tty
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 *
Alan Coxd945cb92009-07-07 16:39:41 +0100154 * Report how much we have in the transmit queue. As everything is
155 * instantly at the other end this is easy to implement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 */
Alan Coxd945cb92009-07-07 16:39:41 +0100157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158static int pty_chars_in_buffer(struct tty_struct *tty)
159{
Alan Coxd945cb92009-07-07 16:39:41 +0100160 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
163/* Set the lock flag on a pty */
Alan Coxfe9cd962008-10-13 10:43:38 +0100164static int pty_set_lock(struct tty_struct *tty, int __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165{
166 int val;
Alan Coxfe9cd962008-10-13 10:43:38 +0100167 if (get_user(val, arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 return -EFAULT;
169 if (val)
170 set_bit(TTY_PTY_LOCK, &tty->flags);
171 else
172 clear_bit(TTY_PTY_LOCK, &tty->flags);
173 return 0;
174}
175
hyc@symas.com26df6d12010-06-22 10:14:49 -0700176/* Send a signal to the slave */
177static int pty_signal(struct tty_struct *tty, int sig)
178{
179 unsigned long flags;
180 struct pid *pgrp;
181
182 if (tty->link) {
183 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
184 pgrp = get_pid(tty->link->pgrp);
185 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
186
187 kill_pgrp(pgrp, sig, 1);
188 put_pid(pgrp);
189 }
190 return 0;
191}
192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193static void pty_flush_buffer(struct tty_struct *tty)
194{
195 struct tty_struct *to = tty->link;
Alan Cox04f378b2008-04-30 00:53:29 -0700196 unsigned long flags;
Alan Coxfe9cd962008-10-13 10:43:38 +0100197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 if (!to)
199 return;
Alan Coxd945cb92009-07-07 16:39:41 +0100200 /* tty_buffer_flush(to); FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 if (to->packet) {
Alan Cox04f378b2008-04-30 00:53:29 -0700202 spin_lock_irqsave(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
204 wake_up_interruptible(&to->read_wait);
Alan Cox04f378b2008-04-30 00:53:29 -0700205 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 }
207}
208
Alan Coxfe9cd962008-10-13 10:43:38 +0100209static int pty_open(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
211 int retval = -ENODEV;
212
213 if (!tty || !tty->link)
214 goto out;
215
216 retval = -EIO;
217 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
218 goto out;
219 if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
220 goto out;
221 if (tty->link->count != 1)
222 goto out;
223
224 clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
225 set_bit(TTY_THROTTLED, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 retval = 0;
227out:
228 return retval;
229}
230
Alan Coxfe9cd962008-10-13 10:43:38 +0100231static void pty_set_termios(struct tty_struct *tty,
232 struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
Alan Coxfe9cd962008-10-13 10:43:38 +0100234 tty->termios->c_cflag &= ~(CSIZE | PARENB);
235 tty->termios->c_cflag |= (CS8 | CREAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236}
237
Alan Coxfc6f6232009-01-02 13:43:17 +0000238/**
239 * pty_do_resize - resize event
240 * @tty: tty being resized
Alan Coxc774bda2009-01-11 19:46:49 +0000241 * @ws: window size being set.
Alan Coxfc6f6232009-01-02 13:43:17 +0000242 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +0800243 * Update the termios variables and send the necessary signals to
Alan Coxfc6f6232009-01-02 13:43:17 +0000244 * peform a terminal resize correctly
245 */
246
247int pty_resize(struct tty_struct *tty, struct winsize *ws)
248{
249 struct pid *pgrp, *rpgrp;
250 unsigned long flags;
251 struct tty_struct *pty = tty->link;
252
253 /* For a PTY we need to lock the tty side */
254 mutex_lock(&tty->termios_mutex);
255 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
256 goto done;
257
258 /* Get the PID values and reference them so we can
259 avoid holding the tty ctrl lock while sending signals.
260 We need to lock these individually however. */
261
262 spin_lock_irqsave(&tty->ctrl_lock, flags);
263 pgrp = get_pid(tty->pgrp);
264 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
265
266 spin_lock_irqsave(&pty->ctrl_lock, flags);
267 rpgrp = get_pid(pty->pgrp);
268 spin_unlock_irqrestore(&pty->ctrl_lock, flags);
269
270 if (pgrp)
271 kill_pgrp(pgrp, SIGWINCH, 1);
272 if (rpgrp != pgrp && rpgrp)
273 kill_pgrp(rpgrp, SIGWINCH, 1);
274
275 put_pid(pgrp);
276 put_pid(rpgrp);
277
278 tty->winsize = *ws;
279 pty->winsize = *ws; /* Never used so will go away soon */
280done:
281 mutex_unlock(&tty->termios_mutex);
282 return 0;
283}
284
Linus Torvalds342a5972009-09-30 07:49:40 -0700285/* Traditional BSD devices */
286#ifdef CONFIG_LEGACY_PTYS
287
Alan Coxbf970ee2008-10-13 10:42:39 +0100288static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
289{
290 struct tty_struct *o_tty;
291 int idx = tty->index;
292 int retval;
293
294 o_tty = alloc_tty_struct();
295 if (!o_tty)
296 return -ENOMEM;
297 if (!try_module_get(driver->other->owner)) {
298 /* This cannot in fact currently happen */
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100299 retval = -ENOMEM;
300 goto err_free_tty;
Alan Coxbf970ee2008-10-13 10:42:39 +0100301 }
302 initialize_tty_struct(o_tty, driver->other, idx);
303
304 /* We always use new tty termios data so we can do this
305 the easy way .. */
306 retval = tty_init_termios(tty);
307 if (retval)
Jiri Slabya9dccdd2011-03-23 10:48:36 +0100308 goto err_deinit_tty;
Alan Coxbf970ee2008-10-13 10:42:39 +0100309
310 retval = tty_init_termios(o_tty);
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100311 if (retval)
312 goto err_free_termios;
Alan Coxfe9cd962008-10-13 10:43:38 +0100313
Alan Coxbf970ee2008-10-13 10:42:39 +0100314 /*
315 * Everything allocated ... set up the o_tty structure.
316 */
317 driver->other->ttys[idx] = o_tty;
318 tty_driver_kref_get(driver->other);
319 if (driver->subtype == PTY_TYPE_MASTER)
320 o_tty->count++;
321 /* Establish the links in both directions */
322 tty->link = o_tty;
323 o_tty->link = tty;
324
325 tty_driver_kref_get(driver);
326 tty->count++;
327 driver->ttys[idx] = tty;
328 return 0;
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100329err_free_termios:
330 tty_free_termios(tty);
Jiri Slabya9dccdd2011-03-23 10:48:36 +0100331err_deinit_tty:
332 deinitialize_tty_struct(o_tty);
Alan Coxbf970ee2008-10-13 10:42:39 +0100333 module_put(o_tty->driver->owner);
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100334err_free_tty:
Alan Coxbf970ee2008-10-13 10:42:39 +0100335 free_tty_struct(o_tty);
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100336 return retval;
Alan Coxbf970ee2008-10-13 10:42:39 +0100337}
338
Alan Cox6caa76b2011-02-14 16:27:22 +0000339static int pty_bsd_ioctl(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 unsigned int cmd, unsigned long arg)
341{
342 switch (cmd) {
343 case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
344 return pty_set_lock(tty, (int __user *) arg);
hyc@symas.com26df6d12010-06-22 10:14:49 -0700345 case TIOCSIG: /* Send signal to other side of pty */
346 return pty_signal(tty, (int) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 }
348 return -ENOIOCTLCMD;
349}
350
Kay Sieversdc8c8582007-08-15 12:25:38 +0200351static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
352module_param(legacy_count, int, 0);
353
Linus Torvalds342a5972009-09-30 07:49:40 -0700354/*
355 * The master side of a pty can do TIOCSPTLCK and thus
356 * has pty_bsd_ioctl.
357 */
358static const struct tty_operations master_pty_ops_bsd = {
359 .install = pty_install,
Alan Cox3e8e88c2008-04-30 00:54:10 -0700360 .open = pty_open,
361 .close = pty_close,
362 .write = pty_write,
363 .write_room = pty_write_room,
364 .flush_buffer = pty_flush_buffer,
365 .chars_in_buffer = pty_chars_in_buffer,
366 .unthrottle = pty_unthrottle,
367 .set_termios = pty_set_termios,
368 .ioctl = pty_bsd_ioctl,
Alan Coxfc6f6232009-01-02 13:43:17 +0000369 .resize = pty_resize
Alan Cox3e8e88c2008-04-30 00:54:10 -0700370};
371
Linus Torvalds342a5972009-09-30 07:49:40 -0700372static const struct tty_operations slave_pty_ops_bsd = {
373 .install = pty_install,
374 .open = pty_open,
375 .close = pty_close,
376 .write = pty_write,
377 .write_room = pty_write_room,
378 .flush_buffer = pty_flush_buffer,
379 .chars_in_buffer = pty_chars_in_buffer,
380 .unthrottle = pty_unthrottle,
381 .set_termios = pty_set_termios,
382 .resize = pty_resize
383};
384
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385static void __init legacy_pty_init(void)
386{
Linus Torvalds342a5972009-09-30 07:49:40 -0700387 struct tty_driver *pty_driver, *pty_slave_driver;
388
Kay Sieversdc8c8582007-08-15 12:25:38 +0200389 if (legacy_count <= 0)
390 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Kay Sieversdc8c8582007-08-15 12:25:38 +0200392 pty_driver = alloc_tty_driver(legacy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if (!pty_driver)
394 panic("Couldn't allocate pty driver");
395
Kay Sieversdc8c8582007-08-15 12:25:38 +0200396 pty_slave_driver = alloc_tty_driver(legacy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (!pty_slave_driver)
398 panic("Couldn't allocate pty slave driver");
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 pty_driver->driver_name = "pty_master";
401 pty_driver->name = "pty";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 pty_driver->major = PTY_MASTER_MAJOR;
403 pty_driver->minor_start = 0;
404 pty_driver->type = TTY_DRIVER_TYPE_PTY;
405 pty_driver->subtype = PTY_TYPE_MASTER;
406 pty_driver->init_termios = tty_std_termios;
407 pty_driver->init_termios.c_iflag = 0;
408 pty_driver->init_termios.c_oflag = 0;
409 pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
410 pty_driver->init_termios.c_lflag = 0;
Alan Cox606d0992006-12-08 02:38:45 -0800411 pty_driver->init_termios.c_ispeed = 38400;
412 pty_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 pty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
414 pty_driver->other = pty_slave_driver;
Linus Torvalds342a5972009-09-30 07:49:40 -0700415 tty_set_operations(pty_driver, &master_pty_ops_bsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 pty_slave_driver->driver_name = "pty_slave";
418 pty_slave_driver->name = "ttyp";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 pty_slave_driver->major = PTY_SLAVE_MAJOR;
420 pty_slave_driver->minor_start = 0;
421 pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
422 pty_slave_driver->subtype = PTY_TYPE_SLAVE;
423 pty_slave_driver->init_termios = tty_std_termios;
424 pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
Alan Cox606d0992006-12-08 02:38:45 -0800425 pty_slave_driver->init_termios.c_ispeed = 38400;
426 pty_slave_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 pty_slave_driver->flags = TTY_DRIVER_RESET_TERMIOS |
428 TTY_DRIVER_REAL_RAW;
429 pty_slave_driver->other = pty_driver;
Linus Torvalds342a5972009-09-30 07:49:40 -0700430 tty_set_operations(pty_slave_driver, &slave_pty_ops_bsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
432 if (tty_register_driver(pty_driver))
433 panic("Couldn't register pty driver");
434 if (tty_register_driver(pty_slave_driver))
435 panic("Couldn't register pty slave driver");
436}
437#else
438static inline void legacy_pty_init(void) { }
439#endif
440
441/* Unix98 devices */
442#ifdef CONFIG_UNIX98_PTYS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
Alan Coxd81ed102008-10-13 10:41:42 +0100444static struct cdev ptmx_cdev;
445
Alan Cox6caa76b2011-02-14 16:27:22 +0000446static int pty_unix98_ioctl(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 unsigned int cmd, unsigned long arg)
448{
449 switch (cmd) {
450 case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
451 return pty_set_lock(tty, (int __user *)arg);
452 case TIOCGPTN: /* Get PT Number */
453 return put_user(tty->index, (unsigned int __user *)arg);
hyc@symas.com26df6d12010-06-22 10:14:49 -0700454 case TIOCSIG: /* Send signal to other side of pty */
455 return pty_signal(tty, (int) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 }
457
458 return -ENOIOCTLCMD;
459}
460
Alan Cox99f1fe12008-10-13 10:42:00 +0100461/**
462 * ptm_unix98_lookup - find a pty master
463 * @driver: ptm driver
464 * @idx: tty index
465 *
466 * Look up a pty master device. Called under the tty_mutex for now.
467 * This provides our locking.
468 */
469
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100470static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
471 struct inode *ptm_inode, int idx)
Alan Cox99f1fe12008-10-13 10:42:00 +0100472{
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +0400473 /* Master must be open via /dev/ptmx */
474 return ERR_PTR(-EIO);
Alan Cox99f1fe12008-10-13 10:42:00 +0100475}
476
477/**
478 * pts_unix98_lookup - find a pty slave
479 * @driver: pts driver
480 * @idx: tty index
481 *
482 * Look up a pty master device. Called under the tty_mutex for now.
Alan Coxd739e652012-05-03 22:22:09 +0100483 * This provides our locking for the tty pointer.
Alan Cox99f1fe12008-10-13 10:42:00 +0100484 */
485
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100486static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
487 struct inode *pts_inode, int idx)
Alan Cox99f1fe12008-10-13 10:42:00 +0100488{
Alan Coxd739e652012-05-03 22:22:09 +0100489 struct tty_struct *tty;
490
491 mutex_lock(&devpts_mutex);
492 tty = devpts_get_tty(pts_inode, idx);
493 mutex_unlock(&devpts_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +0100494 /* Master must be open before slave */
495 if (!tty)
496 return ERR_PTR(-EIO);
497 return tty;
498}
499
Alan Coxbf970ee2008-10-13 10:42:39 +0100500static void pty_unix98_shutdown(struct tty_struct *tty)
Alan Coxfeebed62008-10-13 10:41:30 +0100501{
Jiri Slaby24d406a2011-08-10 14:59:28 +0200502 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +0100503 /* We have our own method as we don't use the tty index */
504 kfree(tty->termios);
Alan Coxfeebed62008-10-13 10:41:30 +0100505}
506
Alan Cox8b0a88d2008-10-13 10:42:19 +0100507/* We have no need to install and remove our tty objects as devpts does all
508 the work for us */
509
Alan Coxbf970ee2008-10-13 10:42:39 +0100510static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +0100511{
Alan Coxbf970ee2008-10-13 10:42:39 +0100512 struct tty_struct *o_tty;
513 int idx = tty->index;
514
515 o_tty = alloc_tty_struct();
516 if (!o_tty)
517 return -ENOMEM;
518 if (!try_module_get(driver->other->owner)) {
519 /* This cannot in fact currently happen */
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100520 goto err_free_tty;
Alan Coxbf970ee2008-10-13 10:42:39 +0100521 }
522 initialize_tty_struct(o_tty, driver->other, idx);
523
Alan Cox8dff04e2008-10-13 10:43:58 +0100524 tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
Alan Coxbf970ee2008-10-13 10:42:39 +0100525 if (tty->termios == NULL)
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100526 goto err_free_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +0100527 *tty->termios = driver->init_termios;
Alan Cox8dff04e2008-10-13 10:43:58 +0100528 tty->termios_locked = tty->termios + 1;
529
530 o_tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
Alan Coxbf970ee2008-10-13 10:42:39 +0100531 if (o_tty->termios == NULL)
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100532 goto err_free_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +0100533 *o_tty->termios = driver->other->init_termios;
Alan Cox8dff04e2008-10-13 10:43:58 +0100534 o_tty->termios_locked = o_tty->termios + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +0100535
536 tty_driver_kref_get(driver->other);
537 if (driver->subtype == PTY_TYPE_MASTER)
538 o_tty->count++;
539 /* Establish the links in both directions */
540 tty->link = o_tty;
541 o_tty->link = tty;
542 /*
543 * All structures have been allocated, so now we install them.
544 * Failures after this point use release_tty to clean up, so
545 * there's no need to null out the local pointers.
546 */
547 tty_driver_kref_get(driver);
548 tty->count++;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100549 return 0;
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100550err_free_mem:
Jiri Slabya9dccdd2011-03-23 10:48:36 +0100551 deinitialize_tty_struct(o_tty);
Alan Cox8dff04e2008-10-13 10:43:58 +0100552 kfree(o_tty->termios);
Alan Cox8dff04e2008-10-13 10:43:58 +0100553 kfree(tty->termios);
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100554 module_put(o_tty->driver->owner);
555err_free_tty:
556 free_tty_struct(o_tty);
Alan Coxbf970ee2008-10-13 10:42:39 +0100557 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100558}
559
Jiri Slaby484af542011-11-16 16:27:11 +0100560static void ptm_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +0100561{
Jiri Slaby484af542011-11-16 16:27:11 +0100562}
563
564static void pts_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
565{
Alan Cox8b0a88d2008-10-13 10:42:19 +0100566}
567
Alan Coxfeebed62008-10-13 10:41:30 +0100568static const struct tty_operations ptm_unix98_ops = {
Alan Cox99f1fe12008-10-13 10:42:00 +0100569 .lookup = ptm_unix98_lookup,
Alan Coxbf970ee2008-10-13 10:42:39 +0100570 .install = pty_unix98_install,
Jiri Slaby484af542011-11-16 16:27:11 +0100571 .remove = ptm_unix98_remove,
Alan Cox3e8e88c2008-04-30 00:54:10 -0700572 .open = pty_open,
573 .close = pty_close,
574 .write = pty_write,
575 .write_room = pty_write_room,
576 .flush_buffer = pty_flush_buffer,
577 .chars_in_buffer = pty_chars_in_buffer,
578 .unthrottle = pty_unthrottle,
579 .set_termios = pty_set_termios,
Alan Coxfeebed62008-10-13 10:41:30 +0100580 .ioctl = pty_unix98_ioctl,
Alan Coxfc6f6232009-01-02 13:43:17 +0000581 .shutdown = pty_unix98_shutdown,
582 .resize = pty_resize
Alan Cox3e8e88c2008-04-30 00:54:10 -0700583};
584
Alan Cox99f1fe12008-10-13 10:42:00 +0100585static const struct tty_operations pty_unix98_ops = {
586 .lookup = pts_unix98_lookup,
Alan Coxbf970ee2008-10-13 10:42:39 +0100587 .install = pty_unix98_install,
Jiri Slaby484af542011-11-16 16:27:11 +0100588 .remove = pts_unix98_remove,
Alan Cox99f1fe12008-10-13 10:42:00 +0100589 .open = pty_open,
590 .close = pty_close,
591 .write = pty_write,
592 .write_room = pty_write_room,
593 .flush_buffer = pty_flush_buffer,
594 .chars_in_buffer = pty_chars_in_buffer,
595 .unthrottle = pty_unthrottle,
596 .set_termios = pty_set_termios,
Alan Coxbf970ee2008-10-13 10:42:39 +0100597 .shutdown = pty_unix98_shutdown
Alan Cox99f1fe12008-10-13 10:42:00 +0100598};
Alan Coxd81ed102008-10-13 10:41:42 +0100599
600/**
601 * ptmx_open - open a unix 98 pty master
602 * @inode: inode of device file
603 * @filp: file pointer to tty
604 *
605 * Allocate a unix98 pty master device from the ptmx driver.
606 *
607 * Locking: tty_mutex protects the init_dev work. tty->count should
608 * protect the rest.
609 * allocated_ptys_lock handles the list of free pty numbers
610 */
611
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +0200612static int ptmx_open(struct inode *inode, struct file *filp)
Alan Coxd81ed102008-10-13 10:41:42 +0100613{
614 struct tty_struct *tty;
615 int retval;
616 int index;
617
618 nonseekable_open(inode, filp);
619
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200620 retval = tty_alloc_file(filp);
621 if (retval)
622 return retval;
623
Alan Coxd81ed102008-10-13 10:41:42 +0100624 /* find a device that is not in use. */
Linus Torvaldsf3095322012-06-02 15:21:43 -0700625 tty_lock();
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100626 index = devpts_new_index(inode);
Linus Torvaldsf3095322012-06-02 15:21:43 -0700627 tty_unlock();
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200628 if (index < 0) {
629 retval = index;
630 goto err_file;
631 }
Alan Coxd81ed102008-10-13 10:41:42 +0100632
633 mutex_lock(&tty_mutex);
Linus Torvaldsf3095322012-06-02 15:21:43 -0700634 mutex_lock(&devpts_mutex);
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +0400635 tty = tty_init_dev(ptm_driver, index);
Linus Torvaldsf3095322012-06-02 15:21:43 -0700636 mutex_unlock(&devpts_mutex);
637 tty_lock();
638 mutex_unlock(&tty_mutex);
Alan Coxd81ed102008-10-13 10:41:42 +0100639
Alan Cox73ec06f2008-10-13 10:42:29 +0100640 if (IS_ERR(tty)) {
641 retval = PTR_ERR(tty);
Alan Coxd81ed102008-10-13 10:41:42 +0100642 goto out;
Alan Cox73ec06f2008-10-13 10:42:29 +0100643 }
Alan Coxd81ed102008-10-13 10:41:42 +0100644
645 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
Nick Pigginee2ffa02010-08-18 04:37:35 +1000646
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200647 tty_add_file(tty, filp);
Alan Coxd81ed102008-10-13 10:41:42 +0100648
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100649 retval = devpts_pty_new(inode, tty->link);
Alan Coxd81ed102008-10-13 10:41:42 +0100650 if (retval)
Jiri Slaby1177c0e2011-10-12 11:32:44 +0200651 goto err_release;
Alan Coxd81ed102008-10-13 10:41:42 +0100652
653 retval = ptm_driver->ops->open(tty, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +0200654 if (retval)
Jiri Slaby1177c0e2011-10-12 11:32:44 +0200655 goto err_release;
656
Linus Torvaldsf3095322012-06-02 15:21:43 -0700657 tty_unlock();
Jiri Slaby1177c0e2011-10-12 11:32:44 +0200658 return 0;
659err_release:
Linus Torvaldsf3095322012-06-02 15:21:43 -0700660 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +0000661 tty_release(inode, filp);
Alan Coxd81ed102008-10-13 10:41:42 +0100662 return retval;
663out:
Jiri Slabyd3bda522012-01-30 21:14:32 +0100664 devpts_kill_index(inode, index);
Linus Torvaldsf3095322012-06-02 15:21:43 -0700665 tty_unlock();
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200666err_file:
667 tty_free_file(filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +0200668 return retval;
Alan Coxd81ed102008-10-13 10:41:42 +0100669}
670
671static struct file_operations ptmx_fops;
672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673static void __init unix98_pty_init(void)
674{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 ptm_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
676 if (!ptm_driver)
677 panic("Couldn't allocate Unix98 ptm driver");
678 pts_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
679 if (!pts_driver)
680 panic("Couldn't allocate Unix98 pts driver");
681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 ptm_driver->driver_name = "pty_master";
683 ptm_driver->name = "ptm";
684 ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
685 ptm_driver->minor_start = 0;
686 ptm_driver->type = TTY_DRIVER_TYPE_PTY;
687 ptm_driver->subtype = PTY_TYPE_MASTER;
688 ptm_driver->init_termios = tty_std_termios;
689 ptm_driver->init_termios.c_iflag = 0;
690 ptm_driver->init_termios.c_oflag = 0;
691 ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
692 ptm_driver->init_termios.c_lflag = 0;
Alan Cox606d0992006-12-08 02:38:45 -0800693 ptm_driver->init_termios.c_ispeed = 38400;
694 ptm_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -0700696 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 ptm_driver->other = pts_driver;
Alan Coxfeebed62008-10-13 10:41:30 +0100698 tty_set_operations(ptm_driver, &ptm_unix98_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 pts_driver->driver_name = "pty_slave";
701 pts_driver->name = "pts";
702 pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
703 pts_driver->minor_start = 0;
704 pts_driver->type = TTY_DRIVER_TYPE_PTY;
705 pts_driver->subtype = PTY_TYPE_SLAVE;
706 pts_driver->init_termios = tty_std_termios;
707 pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
Alan Cox606d0992006-12-08 02:38:45 -0800708 pts_driver->init_termios.c_ispeed = 38400;
709 pts_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -0700711 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 pts_driver->other = ptm_driver;
Alan Cox99f1fe12008-10-13 10:42:00 +0100713 tty_set_operations(pts_driver, &pty_unix98_ops);
Alan Coxfe9cd962008-10-13 10:43:38 +0100714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 if (tty_register_driver(ptm_driver))
716 panic("Couldn't register Unix98 ptm driver");
717 if (tty_register_driver(pts_driver))
718 panic("Couldn't register Unix98 pts driver");
719
Alan Coxd81ed102008-10-13 10:41:42 +0100720 /* Now create the /dev/ptmx special device */
721 tty_default_fops(&ptmx_fops);
722 ptmx_fops.open = ptmx_open;
723
724 cdev_init(&ptmx_cdev, &ptmx_fops);
725 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
726 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
727 panic("Couldn't register /dev/ptmx driver\n");
728 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729}
Alan Coxd81ed102008-10-13 10:41:42 +0100730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731#else
732static inline void unix98_pty_init(void) { }
733#endif
734
735static int __init pty_init(void)
736{
737 legacy_pty_init();
738 unix98_pty_init();
739 return 0;
740}
741module_init(pty_init);