blob: 21bddf359dbbc5e732457c38315bef54575f5e08 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/char/pty.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * Added support for a Unix98-style ptmx device.
7 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
Alan Coxfe9cd962008-10-13 10:43:38 +01009 * When reading this code see also fs/devpts. In particular note that the
10 * driver_data field is used by the devpts side as a binding to the devpts
11 * inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 */
13
Alan Coxfe9cd962008-10-13 10:43:38 +010014#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
16#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/interrupt.h>
18#include <linux/tty.h>
19#include <linux/tty_flip.h>
20#include <linux/fcntl.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040021#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/string.h>
23#include <linux/major.h>
24#include <linux/mm.h>
25#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/sysctl.h>
Alan Coxd81ed102008-10-13 10:41:42 +010027#include <linux/device.h>
Alan Coxfe9cd962008-10-13 10:43:38 +010028#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/bitops.h>
30#include <linux/devpts_fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Alan Coxfe9cd962008-10-13 10:43:38 +010033#include <asm/system.h>
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#ifdef CONFIG_UNIX98_PTYS
Roel Kluinda2bdf92009-01-07 18:09:15 -080036static struct tty_driver *ptm_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037static struct tty_driver *pts_driver;
38#endif
39
Alan Coxfe9cd962008-10-13 10:43:38 +010040static void pty_close(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041{
Alan Coxfe9cd962008-10-13 10:43:38 +010042 BUG_ON(!tty);
43 if (tty->driver->subtype == PTY_TYPE_MASTER)
44 WARN_ON(tty->count > 1);
45 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 if (tty->count > 2)
47 return;
48 }
49 wake_up_interruptible(&tty->read_wait);
50 wake_up_interruptible(&tty->write_wait);
51 tty->packet = 0;
52 if (!tty->link)
53 return;
54 tty->link->packet = 0;
55 set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
56 wake_up_interruptible(&tty->link->read_wait);
57 wake_up_interruptible(&tty->link->write_wait);
58 if (tty->driver->subtype == PTY_TYPE_MASTER) {
59 set_bit(TTY_OTHER_CLOSED, &tty->flags);
60#ifdef CONFIG_UNIX98_PTYS
61 if (tty->driver == ptm_driver)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +010062 devpts_pty_kill(tty->link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +020064 tty_unlock();
65 tty_vhangup(tty->link);
66 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 }
68}
69
70/*
71 * The unthrottle routine is called by the line discipline to signal
72 * that it can receive more characters. For PTY's, the TTY_THROTTLED
73 * flag is always set, to force the line discipline to always call the
Alan Coxfe9cd962008-10-13 10:43:38 +010074 * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 * characters in the queue. This is necessary since each time this
76 * happens, we need to wake up any sleeping processes that could be
77 * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
78 * for the pty buffer to be drained.
79 */
Alan Coxfe9cd962008-10-13 10:43:38 +010080static void pty_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
Alan Coxd945cb92009-07-07 16:39:41 +010082 tty_wakeup(tty->link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 set_bit(TTY_THROTTLED, &tty->flags);
84}
85
Alan Coxd945cb92009-07-07 16:39:41 +010086/**
87 * pty_space - report space left for writing
88 * @to: tty we are writing into
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 *
Alan Coxd945cb92009-07-07 16:39:41 +010090 * The tty buffers allow 64K but we sneak a peak and clip at 8K this
91 * allows a lot of overspill room for echo and other fun messes to
92 * be handled properly
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 */
Alan Coxd945cb92009-07-07 16:39:41 +010094
95static int pty_space(struct tty_struct *to)
96{
97 int n = 8192 - to->buf.memory_used;
98 if (n < 0)
99 return 0;
100 return n;
101}
102
103/**
104 * pty_write - write to a pty
105 * @tty: the tty we write from
106 * @buf: kernel buffer of data
107 * @count: bytes to write
108 *
109 * Our "hardware" write method. Data is coming from the ldisc which
110 * may be in a non sleeping state. We simply throw this at the other
111 * end of the link as if we were an IRQ handler receiving stuff for
112 * the other side of the pty/tty pair.
113 */
114
Linus Torvaldsac89a912009-09-05 13:27:10 -0700115static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
117 struct tty_struct *to = tty->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Alan Coxd945cb92009-07-07 16:39:41 +0100119 if (tty->stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 return 0;
121
Alan Coxd945cb92009-07-07 16:39:41 +0100122 if (c > 0) {
123 /* Stuff the data into the input queue of the other end */
124 c = tty_insert_flip_string(to, buf, c);
125 /* And shovel */
Linus Torvalds202c4672009-09-18 07:05:58 -0700126 if (c) {
127 tty_flip_buffer_push(to);
128 tty_wakeup(tty);
129 }
Alan Cox762faae2009-06-16 17:01:13 +0100130 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 return c;
132}
133
Alan Coxd945cb92009-07-07 16:39:41 +0100134/**
135 * pty_write_room - write space
136 * @tty: tty we are writing from
137 *
138 * Report how many bytes the ldisc can send into the queue for
139 * the other device.
140 */
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static int pty_write_room(struct tty_struct *tty)
143{
Linus Torvalds85dfd812009-08-10 13:21:19 -0700144 if (tty->stopped)
145 return 0;
Alan Coxd945cb92009-07-07 16:39:41 +0100146 return pty_space(tty->link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
Alan Coxd945cb92009-07-07 16:39:41 +0100149/**
150 * pty_chars_in_buffer - characters currently in our tx queue
151 * @tty: our tty
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 *
Alan Coxd945cb92009-07-07 16:39:41 +0100153 * Report how much we have in the transmit queue. As everything is
154 * instantly at the other end this is easy to implement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 */
Alan Coxd945cb92009-07-07 16:39:41 +0100156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157static int pty_chars_in_buffer(struct tty_struct *tty)
158{
Alan Coxd945cb92009-07-07 16:39:41 +0100159 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160}
161
162/* Set the lock flag on a pty */
Alan Coxfe9cd962008-10-13 10:43:38 +0100163static int pty_set_lock(struct tty_struct *tty, int __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
165 int val;
Alan Coxfe9cd962008-10-13 10:43:38 +0100166 if (get_user(val, arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return -EFAULT;
168 if (val)
169 set_bit(TTY_PTY_LOCK, &tty->flags);
170 else
171 clear_bit(TTY_PTY_LOCK, &tty->flags);
172 return 0;
173}
174
hyc@symas.com26df6d12010-06-22 10:14:49 -0700175/* Send a signal to the slave */
176static int pty_signal(struct tty_struct *tty, int sig)
177{
178 unsigned long flags;
179 struct pid *pgrp;
180
181 if (tty->link) {
182 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
183 pgrp = get_pid(tty->link->pgrp);
184 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
185
186 kill_pgrp(pgrp, sig, 1);
187 put_pid(pgrp);
188 }
189 return 0;
190}
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192static void pty_flush_buffer(struct tty_struct *tty)
193{
194 struct tty_struct *to = tty->link;
Alan Cox04f378b2008-04-30 00:53:29 -0700195 unsigned long flags;
Alan Coxfe9cd962008-10-13 10:43:38 +0100196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (!to)
198 return;
Alan Coxd945cb92009-07-07 16:39:41 +0100199 /* tty_buffer_flush(to); FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 if (to->packet) {
Alan Cox04f378b2008-04-30 00:53:29 -0700201 spin_lock_irqsave(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
203 wake_up_interruptible(&to->read_wait);
Alan Cox04f378b2008-04-30 00:53:29 -0700204 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 }
206}
207
Alan Coxfe9cd962008-10-13 10:43:38 +0100208static int pty_open(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
210 int retval = -ENODEV;
211
212 if (!tty || !tty->link)
213 goto out;
214
215 retval = -EIO;
216 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
217 goto out;
218 if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
219 goto out;
220 if (tty->link->count != 1)
221 goto out;
222
223 clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
224 set_bit(TTY_THROTTLED, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 retval = 0;
226out:
227 return retval;
228}
229
Alan Coxfe9cd962008-10-13 10:43:38 +0100230static void pty_set_termios(struct tty_struct *tty,
231 struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
Alan Coxfe9cd962008-10-13 10:43:38 +0100233 tty->termios->c_cflag &= ~(CSIZE | PARENB);
234 tty->termios->c_cflag |= (CS8 | CREAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235}
236
Alan Coxfc6f6232009-01-02 13:43:17 +0000237/**
238 * pty_do_resize - resize event
239 * @tty: tty being resized
Alan Coxc774bda2009-01-11 19:46:49 +0000240 * @ws: window size being set.
Alan Coxfc6f6232009-01-02 13:43:17 +0000241 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +0800242 * Update the termios variables and send the necessary signals to
Alan Coxfc6f6232009-01-02 13:43:17 +0000243 * peform a terminal resize correctly
244 */
245
246int pty_resize(struct tty_struct *tty, struct winsize *ws)
247{
248 struct pid *pgrp, *rpgrp;
249 unsigned long flags;
250 struct tty_struct *pty = tty->link;
251
252 /* For a PTY we need to lock the tty side */
253 mutex_lock(&tty->termios_mutex);
254 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
255 goto done;
256
257 /* Get the PID values and reference them so we can
258 avoid holding the tty ctrl lock while sending signals.
259 We need to lock these individually however. */
260
261 spin_lock_irqsave(&tty->ctrl_lock, flags);
262 pgrp = get_pid(tty->pgrp);
263 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
264
265 spin_lock_irqsave(&pty->ctrl_lock, flags);
266 rpgrp = get_pid(pty->pgrp);
267 spin_unlock_irqrestore(&pty->ctrl_lock, flags);
268
269 if (pgrp)
270 kill_pgrp(pgrp, SIGWINCH, 1);
271 if (rpgrp != pgrp && rpgrp)
272 kill_pgrp(rpgrp, SIGWINCH, 1);
273
274 put_pid(pgrp);
275 put_pid(rpgrp);
276
277 tty->winsize = *ws;
278 pty->winsize = *ws; /* Never used so will go away soon */
279done:
280 mutex_unlock(&tty->termios_mutex);
281 return 0;
282}
283
Linus Torvalds342a5972009-09-30 07:49:40 -0700284/* Traditional BSD devices */
285#ifdef CONFIG_LEGACY_PTYS
286
Alan Coxbf970ee2008-10-13 10:42:39 +0100287static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
288{
289 struct tty_struct *o_tty;
290 int idx = tty->index;
291 int retval;
292
293 o_tty = alloc_tty_struct();
294 if (!o_tty)
295 return -ENOMEM;
296 if (!try_module_get(driver->other->owner)) {
297 /* This cannot in fact currently happen */
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100298 retval = -ENOMEM;
299 goto err_free_tty;
Alan Coxbf970ee2008-10-13 10:42:39 +0100300 }
301 initialize_tty_struct(o_tty, driver->other, idx);
302
303 /* We always use new tty termios data so we can do this
304 the easy way .. */
305 retval = tty_init_termios(tty);
306 if (retval)
Jiri Slabya9dccdd2011-03-23 10:48:36 +0100307 goto err_deinit_tty;
Alan Coxbf970ee2008-10-13 10:42:39 +0100308
309 retval = tty_init_termios(o_tty);
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100310 if (retval)
311 goto err_free_termios;
Alan Coxfe9cd962008-10-13 10:43:38 +0100312
Alan Coxbf970ee2008-10-13 10:42:39 +0100313 /*
314 * Everything allocated ... set up the o_tty structure.
315 */
316 driver->other->ttys[idx] = o_tty;
317 tty_driver_kref_get(driver->other);
318 if (driver->subtype == PTY_TYPE_MASTER)
319 o_tty->count++;
320 /* Establish the links in both directions */
321 tty->link = o_tty;
322 o_tty->link = tty;
323
324 tty_driver_kref_get(driver);
325 tty->count++;
326 driver->ttys[idx] = tty;
327 return 0;
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100328err_free_termios:
329 tty_free_termios(tty);
Jiri Slabya9dccdd2011-03-23 10:48:36 +0100330err_deinit_tty:
331 deinitialize_tty_struct(o_tty);
Alan Coxbf970ee2008-10-13 10:42:39 +0100332 module_put(o_tty->driver->owner);
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100333err_free_tty:
Alan Coxbf970ee2008-10-13 10:42:39 +0100334 free_tty_struct(o_tty);
Jiri Slaby8a1b8d72011-03-23 10:48:33 +0100335 return retval;
Alan Coxbf970ee2008-10-13 10:42:39 +0100336}
337
Alan Cox6caa76b2011-02-14 16:27:22 +0000338static int pty_bsd_ioctl(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 unsigned int cmd, unsigned long arg)
340{
341 switch (cmd) {
342 case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
343 return pty_set_lock(tty, (int __user *) arg);
hyc@symas.com26df6d12010-06-22 10:14:49 -0700344 case TIOCSIG: /* Send signal to other side of pty */
345 return pty_signal(tty, (int) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
347 return -ENOIOCTLCMD;
348}
349
Kay Sieversdc8c8582007-08-15 12:25:38 +0200350static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
351module_param(legacy_count, int, 0);
352
Linus Torvalds342a5972009-09-30 07:49:40 -0700353/*
354 * The master side of a pty can do TIOCSPTLCK and thus
355 * has pty_bsd_ioctl.
356 */
357static const struct tty_operations master_pty_ops_bsd = {
358 .install = pty_install,
Alan Cox3e8e88c2008-04-30 00:54:10 -0700359 .open = pty_open,
360 .close = pty_close,
361 .write = pty_write,
362 .write_room = pty_write_room,
363 .flush_buffer = pty_flush_buffer,
364 .chars_in_buffer = pty_chars_in_buffer,
365 .unthrottle = pty_unthrottle,
366 .set_termios = pty_set_termios,
367 .ioctl = pty_bsd_ioctl,
Alan Coxfc6f6232009-01-02 13:43:17 +0000368 .resize = pty_resize
Alan Cox3e8e88c2008-04-30 00:54:10 -0700369};
370
Linus Torvalds342a5972009-09-30 07:49:40 -0700371static const struct tty_operations slave_pty_ops_bsd = {
372 .install = pty_install,
373 .open = pty_open,
374 .close = pty_close,
375 .write = pty_write,
376 .write_room = pty_write_room,
377 .flush_buffer = pty_flush_buffer,
378 .chars_in_buffer = pty_chars_in_buffer,
379 .unthrottle = pty_unthrottle,
380 .set_termios = pty_set_termios,
381 .resize = pty_resize
382};
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384static void __init legacy_pty_init(void)
385{
Linus Torvalds342a5972009-09-30 07:49:40 -0700386 struct tty_driver *pty_driver, *pty_slave_driver;
387
Kay Sieversdc8c8582007-08-15 12:25:38 +0200388 if (legacy_count <= 0)
389 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Kay Sieversdc8c8582007-08-15 12:25:38 +0200391 pty_driver = alloc_tty_driver(legacy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 if (!pty_driver)
393 panic("Couldn't allocate pty driver");
394
Kay Sieversdc8c8582007-08-15 12:25:38 +0200395 pty_slave_driver = alloc_tty_driver(legacy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 if (!pty_slave_driver)
397 panic("Couldn't allocate pty slave driver");
398
399 pty_driver->owner = THIS_MODULE;
400 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
417 pty_slave_driver->owner = THIS_MODULE;
418 pty_slave_driver->driver_name = "pty_slave";
419 pty_slave_driver->name = "ttyp";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 pty_slave_driver->major = PTY_SLAVE_MAJOR;
421 pty_slave_driver->minor_start = 0;
422 pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
423 pty_slave_driver->subtype = PTY_TYPE_SLAVE;
424 pty_slave_driver->init_termios = tty_std_termios;
425 pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
Alan Cox606d0992006-12-08 02:38:45 -0800426 pty_slave_driver->init_termios.c_ispeed = 38400;
427 pty_slave_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 pty_slave_driver->flags = TTY_DRIVER_RESET_TERMIOS |
429 TTY_DRIVER_REAL_RAW;
430 pty_slave_driver->other = pty_driver;
Linus Torvalds342a5972009-09-30 07:49:40 -0700431 tty_set_operations(pty_slave_driver, &slave_pty_ops_bsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433 if (tty_register_driver(pty_driver))
434 panic("Couldn't register pty driver");
435 if (tty_register_driver(pty_slave_driver))
436 panic("Couldn't register pty slave driver");
437}
438#else
439static inline void legacy_pty_init(void) { }
440#endif
441
442/* Unix98 devices */
443#ifdef CONFIG_UNIX98_PTYS
444/*
445 * sysctl support for setting limits on the number of Unix98 ptys allocated.
446 * Otherwise one can eat up all kernel memory by opening /dev/ptmx repeatedly.
447 */
448int pty_limit = NR_UNIX98_PTY_DEFAULT;
Alan Coxfe9cd962008-10-13 10:43:38 +0100449static int pty_limit_min;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450static int pty_limit_max = NR_UNIX98_PTY_MAX;
Alan Coxfe9cd962008-10-13 10:43:38 +0100451static int pty_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Alan Coxd81ed102008-10-13 10:41:42 +0100453static struct cdev ptmx_cdev;
454
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700455static struct ctl_table pty_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 .procname = "max",
458 .maxlen = sizeof(int),
459 .mode = 0644,
460 .data = &pty_limit,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800461 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 .extra1 = &pty_limit_min,
463 .extra2 = &pty_limit_max,
464 }, {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 .procname = "nr",
466 .maxlen = sizeof(int),
467 .mode = 0444,
Alan Coxbf970ee2008-10-13 10:42:39 +0100468 .data = &pty_count,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800469 .proc_handler = proc_dointvec,
Eric W. Biederman894d2492009-11-05 14:34:02 -0800470 },
471 {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472};
473
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700474static struct ctl_table pty_kern_table[] = {
475 {
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700476 .procname = "pty",
477 .mode = 0555,
478 .child = pty_table,
479 },
480 {}
481};
482
483static struct ctl_table pty_root_table[] = {
484 {
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700485 .procname = "kernel",
486 .mode = 0555,
487 .child = pty_kern_table,
488 },
489 {}
490};
491
492
Alan Cox6caa76b2011-02-14 16:27:22 +0000493static int pty_unix98_ioctl(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 unsigned int cmd, unsigned long arg)
495{
496 switch (cmd) {
497 case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
498 return pty_set_lock(tty, (int __user *)arg);
499 case TIOCGPTN: /* Get PT Number */
500 return put_user(tty->index, (unsigned int __user *)arg);
hyc@symas.com26df6d12010-06-22 10:14:49 -0700501 case TIOCSIG: /* Send signal to other side of pty */
502 return pty_signal(tty, (int) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 }
504
505 return -ENOIOCTLCMD;
506}
507
Alan Cox99f1fe12008-10-13 10:42:00 +0100508/**
509 * ptm_unix98_lookup - find a pty master
510 * @driver: ptm driver
511 * @idx: tty index
512 *
513 * Look up a pty master device. Called under the tty_mutex for now.
514 * This provides our locking.
515 */
516
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100517static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
518 struct inode *ptm_inode, int idx)
Alan Cox99f1fe12008-10-13 10:42:00 +0100519{
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100520 struct tty_struct *tty = devpts_get_tty(ptm_inode, idx);
Alan Cox99f1fe12008-10-13 10:42:00 +0100521 if (tty)
522 tty = tty->link;
523 return tty;
524}
525
526/**
527 * pts_unix98_lookup - find a pty slave
528 * @driver: pts driver
529 * @idx: tty index
530 *
531 * Look up a pty master device. Called under the tty_mutex for now.
532 * This provides our locking.
533 */
534
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100535static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
536 struct inode *pts_inode, int idx)
Alan Cox99f1fe12008-10-13 10:42:00 +0100537{
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100538 struct tty_struct *tty = devpts_get_tty(pts_inode, idx);
Alan Cox99f1fe12008-10-13 10:42:00 +0100539 /* Master must be open before slave */
540 if (!tty)
541 return ERR_PTR(-EIO);
542 return tty;
543}
544
Alan Coxbf970ee2008-10-13 10:42:39 +0100545static void pty_unix98_shutdown(struct tty_struct *tty)
Alan Coxfeebed62008-10-13 10:41:30 +0100546{
547 /* We have our own method as we don't use the tty index */
548 kfree(tty->termios);
Alan Coxfeebed62008-10-13 10:41:30 +0100549}
550
Alan Cox8b0a88d2008-10-13 10:42:19 +0100551/* We have no need to install and remove our tty objects as devpts does all
552 the work for us */
553
Alan Coxbf970ee2008-10-13 10:42:39 +0100554static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +0100555{
Alan Coxbf970ee2008-10-13 10:42:39 +0100556 struct tty_struct *o_tty;
557 int idx = tty->index;
558
559 o_tty = alloc_tty_struct();
560 if (!o_tty)
561 return -ENOMEM;
562 if (!try_module_get(driver->other->owner)) {
563 /* This cannot in fact currently happen */
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100564 goto err_free_tty;
Alan Coxbf970ee2008-10-13 10:42:39 +0100565 }
566 initialize_tty_struct(o_tty, driver->other, idx);
567
Alan Cox8dff04e2008-10-13 10:43:58 +0100568 tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
Alan Coxbf970ee2008-10-13 10:42:39 +0100569 if (tty->termios == NULL)
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100570 goto err_free_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +0100571 *tty->termios = driver->init_termios;
Alan Cox8dff04e2008-10-13 10:43:58 +0100572 tty->termios_locked = tty->termios + 1;
573
574 o_tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
Alan Coxbf970ee2008-10-13 10:42:39 +0100575 if (o_tty->termios == NULL)
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100576 goto err_free_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +0100577 *o_tty->termios = driver->other->init_termios;
Alan Cox8dff04e2008-10-13 10:43:58 +0100578 o_tty->termios_locked = o_tty->termios + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +0100579
580 tty_driver_kref_get(driver->other);
581 if (driver->subtype == PTY_TYPE_MASTER)
582 o_tty->count++;
583 /* Establish the links in both directions */
584 tty->link = o_tty;
585 o_tty->link = tty;
586 /*
587 * All structures have been allocated, so now we install them.
588 * Failures after this point use release_tty to clean up, so
589 * there's no need to null out the local pointers.
590 */
591 tty_driver_kref_get(driver);
592 tty->count++;
593 pty_count++;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100594 return 0;
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100595err_free_mem:
Jiri Slabya9dccdd2011-03-23 10:48:36 +0100596 deinitialize_tty_struct(o_tty);
Alan Cox8dff04e2008-10-13 10:43:58 +0100597 kfree(o_tty->termios);
Alan Cox8dff04e2008-10-13 10:43:58 +0100598 kfree(tty->termios);
Jiri Slabyc18d77a2011-03-23 10:48:34 +0100599 module_put(o_tty->driver->owner);
600err_free_tty:
601 free_tty_struct(o_tty);
Alan Coxbf970ee2008-10-13 10:42:39 +0100602 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100603}
604
Alan Coxbf970ee2008-10-13 10:42:39 +0100605static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +0100606{
Alan Coxbf970ee2008-10-13 10:42:39 +0100607 pty_count--;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100608}
609
Alan Coxfeebed62008-10-13 10:41:30 +0100610static const struct tty_operations ptm_unix98_ops = {
Alan Cox99f1fe12008-10-13 10:42:00 +0100611 .lookup = ptm_unix98_lookup,
Alan Coxbf970ee2008-10-13 10:42:39 +0100612 .install = pty_unix98_install,
613 .remove = pty_unix98_remove,
Alan Cox3e8e88c2008-04-30 00:54:10 -0700614 .open = pty_open,
615 .close = pty_close,
616 .write = pty_write,
617 .write_room = pty_write_room,
618 .flush_buffer = pty_flush_buffer,
619 .chars_in_buffer = pty_chars_in_buffer,
620 .unthrottle = pty_unthrottle,
621 .set_termios = pty_set_termios,
Alan Coxfeebed62008-10-13 10:41:30 +0100622 .ioctl = pty_unix98_ioctl,
Alan Coxfc6f6232009-01-02 13:43:17 +0000623 .shutdown = pty_unix98_shutdown,
624 .resize = pty_resize
Alan Cox3e8e88c2008-04-30 00:54:10 -0700625};
626
Alan Cox99f1fe12008-10-13 10:42:00 +0100627static const struct tty_operations pty_unix98_ops = {
628 .lookup = pts_unix98_lookup,
Alan Coxbf970ee2008-10-13 10:42:39 +0100629 .install = pty_unix98_install,
630 .remove = pty_unix98_remove,
Alan Cox99f1fe12008-10-13 10:42:00 +0100631 .open = pty_open,
632 .close = pty_close,
633 .write = pty_write,
634 .write_room = pty_write_room,
635 .flush_buffer = pty_flush_buffer,
636 .chars_in_buffer = pty_chars_in_buffer,
637 .unthrottle = pty_unthrottle,
638 .set_termios = pty_set_termios,
Alan Coxbf970ee2008-10-13 10:42:39 +0100639 .shutdown = pty_unix98_shutdown
Alan Cox99f1fe12008-10-13 10:42:00 +0100640};
Alan Coxd81ed102008-10-13 10:41:42 +0100641
642/**
643 * ptmx_open - open a unix 98 pty master
644 * @inode: inode of device file
645 * @filp: file pointer to tty
646 *
647 * Allocate a unix98 pty master device from the ptmx driver.
648 *
649 * Locking: tty_mutex protects the init_dev work. tty->count should
650 * protect the rest.
651 * allocated_ptys_lock handles the list of free pty numbers
652 */
653
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +0200654static int ptmx_open(struct inode *inode, struct file *filp)
Alan Coxd81ed102008-10-13 10:41:42 +0100655{
656 struct tty_struct *tty;
657 int retval;
658 int index;
659
660 nonseekable_open(inode, filp);
661
662 /* find a device that is not in use. */
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +0200663 tty_lock();
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100664 index = devpts_new_index(inode);
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +0200665 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +0100666 if (index < 0)
667 return index;
668
669 mutex_lock(&tty_mutex);
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +0200670 tty_lock();
Alan Cox73ec06f2008-10-13 10:42:29 +0100671 tty = tty_init_dev(ptm_driver, index, 1);
Alan Coxd81ed102008-10-13 10:41:42 +0100672 mutex_unlock(&tty_mutex);
673
Alan Cox73ec06f2008-10-13 10:42:29 +0100674 if (IS_ERR(tty)) {
675 retval = PTR_ERR(tty);
Alan Coxd81ed102008-10-13 10:41:42 +0100676 goto out;
Alan Cox73ec06f2008-10-13 10:42:29 +0100677 }
Alan Coxd81ed102008-10-13 10:41:42 +0100678
679 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
Nick Pigginee2ffa02010-08-18 04:37:35 +1000680
Pekka Enbergf573bd12010-08-24 07:48:34 +0300681 retval = tty_add_file(tty, filp);
682 if (retval)
683 goto out;
Alan Coxd81ed102008-10-13 10:41:42 +0100684
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100685 retval = devpts_pty_new(inode, tty->link);
Alan Coxd81ed102008-10-13 10:41:42 +0100686 if (retval)
687 goto out1;
688
689 retval = ptm_driver->ops->open(tty, filp);
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +0200690 if (retval)
691 goto out2;
Alan Coxd81ed102008-10-13 10:41:42 +0100692out1:
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +0200693 tty_unlock();
694 return retval;
695out2:
696 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +0000697 tty_release(inode, filp);
Alan Coxd81ed102008-10-13 10:41:42 +0100698 return retval;
699out:
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100700 devpts_kill_index(inode, index);
Arnd Bergmannec79d602010-06-01 22:53:01 +0200701 tty_unlock();
Arnd Bergmann64ba3dc32010-06-01 22:53:02 +0200702 return retval;
Alan Coxd81ed102008-10-13 10:41:42 +0100703}
704
705static struct file_operations ptmx_fops;
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707static void __init unix98_pty_init(void)
708{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 ptm_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
710 if (!ptm_driver)
711 panic("Couldn't allocate Unix98 ptm driver");
712 pts_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
713 if (!pts_driver)
714 panic("Couldn't allocate Unix98 pts driver");
715
716 ptm_driver->owner = THIS_MODULE;
717 ptm_driver->driver_name = "pty_master";
718 ptm_driver->name = "ptm";
719 ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
720 ptm_driver->minor_start = 0;
721 ptm_driver->type = TTY_DRIVER_TYPE_PTY;
722 ptm_driver->subtype = PTY_TYPE_MASTER;
723 ptm_driver->init_termios = tty_std_termios;
724 ptm_driver->init_termios.c_iflag = 0;
725 ptm_driver->init_termios.c_oflag = 0;
726 ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
727 ptm_driver->init_termios.c_lflag = 0;
Alan Cox606d0992006-12-08 02:38:45 -0800728 ptm_driver->init_termios.c_ispeed = 38400;
729 ptm_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -0700731 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 ptm_driver->other = pts_driver;
Alan Coxfeebed62008-10-13 10:41:30 +0100733 tty_set_operations(ptm_driver, &ptm_unix98_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 pts_driver->owner = THIS_MODULE;
736 pts_driver->driver_name = "pty_slave";
737 pts_driver->name = "pts";
738 pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
739 pts_driver->minor_start = 0;
740 pts_driver->type = TTY_DRIVER_TYPE_PTY;
741 pts_driver->subtype = PTY_TYPE_SLAVE;
742 pts_driver->init_termios = tty_std_termios;
743 pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
Alan Cox606d0992006-12-08 02:38:45 -0800744 pts_driver->init_termios.c_ispeed = 38400;
745 pts_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -0700747 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 pts_driver->other = ptm_driver;
Alan Cox99f1fe12008-10-13 10:42:00 +0100749 tty_set_operations(pts_driver, &pty_unix98_ops);
Alan Coxfe9cd962008-10-13 10:43:38 +0100750
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 if (tty_register_driver(ptm_driver))
752 panic("Couldn't register Unix98 ptm driver");
753 if (tty_register_driver(pts_driver))
754 panic("Couldn't register Unix98 pts driver");
755
Alan Coxfe9cd962008-10-13 10:43:38 +0100756 register_sysctl_table(pty_root_table);
Alan Coxd81ed102008-10-13 10:41:42 +0100757
758 /* Now create the /dev/ptmx special device */
759 tty_default_fops(&ptmx_fops);
760 ptmx_fops.open = ptmx_open;
761
762 cdev_init(&ptmx_cdev, &ptmx_fops);
763 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
764 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
765 panic("Couldn't register /dev/ptmx driver\n");
766 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767}
Alan Coxd81ed102008-10-13 10:41:42 +0100768
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769#else
770static inline void unix98_pty_init(void) { }
771#endif
772
773static int __init pty_init(void)
774{
775 legacy_pty_init();
776 unix98_pty_init();
777 return 0;
778}
779module_init(pty_init);