blob: 385c44b3034f4000df9d8a4ad917f3e030c4a143 [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>
Alexey Dobriyan405f5572009-07-11 22:08:37 +040026#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/sysctl.h>
Alan Coxd81ed102008-10-13 10:41:42 +010028#include <linux/device.h>
Alan Coxfe9cd962008-10-13 10:43:38 +010029#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/bitops.h>
31#include <linux/devpts_fs.h>
32
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
64 tty_vhangup(tty->link);
65 }
66}
67
68/*
69 * The unthrottle routine is called by the line discipline to signal
70 * that it can receive more characters. For PTY's, the TTY_THROTTLED
71 * flag is always set, to force the line discipline to always call the
Alan Coxfe9cd962008-10-13 10:43:38 +010072 * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 * characters in the queue. This is necessary since each time this
74 * happens, we need to wake up any sleeping processes that could be
75 * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
76 * for the pty buffer to be drained.
77 */
Alan Coxfe9cd962008-10-13 10:43:38 +010078static void pty_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -070079{
Alan Coxd945cb92009-07-07 16:39:41 +010080 tty_wakeup(tty->link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 set_bit(TTY_THROTTLED, &tty->flags);
82}
83
Alan Coxd945cb92009-07-07 16:39:41 +010084/**
85 * pty_space - report space left for writing
86 * @to: tty we are writing into
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 *
Alan Coxd945cb92009-07-07 16:39:41 +010088 * The tty buffers allow 64K but we sneak a peak and clip at 8K this
89 * allows a lot of overspill room for echo and other fun messes to
90 * be handled properly
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 */
Alan Coxd945cb92009-07-07 16:39:41 +010092
93static int pty_space(struct tty_struct *to)
94{
95 int n = 8192 - to->buf.memory_used;
96 if (n < 0)
97 return 0;
98 return n;
99}
100
101/**
102 * pty_write - write to a pty
103 * @tty: the tty we write from
104 * @buf: kernel buffer of data
105 * @count: bytes to write
106 *
107 * Our "hardware" write method. Data is coming from the ldisc which
108 * may be in a non sleeping state. We simply throw this at the other
109 * end of the link as if we were an IRQ handler receiving stuff for
110 * the other side of the pty/tty pair.
111 */
112
Linus Torvaldsac89a912009-09-05 13:27:10 -0700113static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 struct tty_struct *to = tty->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
Alan Coxd945cb92009-07-07 16:39:41 +0100117 if (tty->stopped)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 return 0;
119
Alan Coxd945cb92009-07-07 16:39:41 +0100120 if (c > 0) {
121 /* Stuff the data into the input queue of the other end */
122 c = tty_insert_flip_string(to, buf, c);
123 /* And shovel */
Linus Torvalds202c4672009-09-18 07:05:58 -0700124 if (c) {
125 tty_flip_buffer_push(to);
126 tty_wakeup(tty);
127 }
Alan Cox762faae2009-06-16 17:01:13 +0100128 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 return c;
130}
131
Alan Coxd945cb92009-07-07 16:39:41 +0100132/**
133 * pty_write_room - write space
134 * @tty: tty we are writing from
135 *
136 * Report how many bytes the ldisc can send into the queue for
137 * the other device.
138 */
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140static int pty_write_room(struct tty_struct *tty)
141{
Linus Torvalds85dfd812009-08-10 13:21:19 -0700142 if (tty->stopped)
143 return 0;
Alan Coxd945cb92009-07-07 16:39:41 +0100144 return pty_space(tty->link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
Alan Coxd945cb92009-07-07 16:39:41 +0100147/**
148 * pty_chars_in_buffer - characters currently in our tx queue
149 * @tty: our tty
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 *
Alan Coxd945cb92009-07-07 16:39:41 +0100151 * Report how much we have in the transmit queue. As everything is
152 * instantly at the other end this is easy to implement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 */
Alan Coxd945cb92009-07-07 16:39:41 +0100154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155static int pty_chars_in_buffer(struct tty_struct *tty)
156{
Alan Coxd945cb92009-07-07 16:39:41 +0100157 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158}
159
160/* Set the lock flag on a pty */
Alan Coxfe9cd962008-10-13 10:43:38 +0100161static int pty_set_lock(struct tty_struct *tty, int __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
163 int val;
Alan Coxfe9cd962008-10-13 10:43:38 +0100164 if (get_user(val, arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 return -EFAULT;
166 if (val)
167 set_bit(TTY_PTY_LOCK, &tty->flags);
168 else
169 clear_bit(TTY_PTY_LOCK, &tty->flags);
170 return 0;
171}
172
173static void pty_flush_buffer(struct tty_struct *tty)
174{
175 struct tty_struct *to = tty->link;
Alan Cox04f378b2008-04-30 00:53:29 -0700176 unsigned long flags;
Alan Coxfe9cd962008-10-13 10:43:38 +0100177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 if (!to)
179 return;
Alan Coxd945cb92009-07-07 16:39:41 +0100180 /* tty_buffer_flush(to); FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 if (to->packet) {
Alan Cox04f378b2008-04-30 00:53:29 -0700182 spin_lock_irqsave(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
184 wake_up_interruptible(&to->read_wait);
Alan Cox04f378b2008-04-30 00:53:29 -0700185 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 }
187}
188
Alan Coxfe9cd962008-10-13 10:43:38 +0100189static int pty_open(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
191 int retval = -ENODEV;
192
193 if (!tty || !tty->link)
194 goto out;
195
196 retval = -EIO;
197 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
198 goto out;
199 if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
200 goto out;
201 if (tty->link->count != 1)
202 goto out;
203
204 clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
205 set_bit(TTY_THROTTLED, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 retval = 0;
207out:
208 return retval;
209}
210
Alan Coxfe9cd962008-10-13 10:43:38 +0100211static void pty_set_termios(struct tty_struct *tty,
212 struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
Alan Coxfe9cd962008-10-13 10:43:38 +0100214 tty->termios->c_cflag &= ~(CSIZE | PARENB);
215 tty->termios->c_cflag |= (CS8 | CREAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
Alan Coxfc6f6232009-01-02 13:43:17 +0000218/**
219 * pty_do_resize - resize event
220 * @tty: tty being resized
Alan Coxc774bda2009-01-11 19:46:49 +0000221 * @ws: window size being set.
Alan Coxfc6f6232009-01-02 13:43:17 +0000222 *
223 * Update the termios variables and send the neccessary signals to
224 * peform a terminal resize correctly
225 */
226
227int pty_resize(struct tty_struct *tty, struct winsize *ws)
228{
229 struct pid *pgrp, *rpgrp;
230 unsigned long flags;
231 struct tty_struct *pty = tty->link;
232
233 /* For a PTY we need to lock the tty side */
234 mutex_lock(&tty->termios_mutex);
235 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
236 goto done;
237
238 /* Get the PID values and reference them so we can
239 avoid holding the tty ctrl lock while sending signals.
240 We need to lock these individually however. */
241
242 spin_lock_irqsave(&tty->ctrl_lock, flags);
243 pgrp = get_pid(tty->pgrp);
244 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
245
246 spin_lock_irqsave(&pty->ctrl_lock, flags);
247 rpgrp = get_pid(pty->pgrp);
248 spin_unlock_irqrestore(&pty->ctrl_lock, flags);
249
250 if (pgrp)
251 kill_pgrp(pgrp, SIGWINCH, 1);
252 if (rpgrp != pgrp && rpgrp)
253 kill_pgrp(rpgrp, SIGWINCH, 1);
254
255 put_pid(pgrp);
256 put_pid(rpgrp);
257
258 tty->winsize = *ws;
259 pty->winsize = *ws; /* Never used so will go away soon */
260done:
261 mutex_unlock(&tty->termios_mutex);
262 return 0;
263}
264
Linus Torvalds342a5972009-09-30 07:49:40 -0700265/* Traditional BSD devices */
266#ifdef CONFIG_LEGACY_PTYS
267
Alan Coxbf970ee2008-10-13 10:42:39 +0100268static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
269{
270 struct tty_struct *o_tty;
271 int idx = tty->index;
272 int retval;
273
274 o_tty = alloc_tty_struct();
275 if (!o_tty)
276 return -ENOMEM;
277 if (!try_module_get(driver->other->owner)) {
278 /* This cannot in fact currently happen */
279 free_tty_struct(o_tty);
280 return -ENOMEM;
281 }
282 initialize_tty_struct(o_tty, driver->other, idx);
283
284 /* We always use new tty termios data so we can do this
285 the easy way .. */
286 retval = tty_init_termios(tty);
287 if (retval)
288 goto free_mem_out;
289
290 retval = tty_init_termios(o_tty);
291 if (retval) {
292 tty_free_termios(tty);
293 goto free_mem_out;
294 }
Alan Coxfe9cd962008-10-13 10:43:38 +0100295
Alan Coxbf970ee2008-10-13 10:42:39 +0100296 /*
297 * Everything allocated ... set up the o_tty structure.
298 */
299 driver->other->ttys[idx] = o_tty;
300 tty_driver_kref_get(driver->other);
301 if (driver->subtype == PTY_TYPE_MASTER)
302 o_tty->count++;
303 /* Establish the links in both directions */
304 tty->link = o_tty;
305 o_tty->link = tty;
306
307 tty_driver_kref_get(driver);
308 tty->count++;
309 driver->ttys[idx] = tty;
310 return 0;
311free_mem_out:
312 module_put(o_tty->driver->owner);
313 free_tty_struct(o_tty);
314 return -ENOMEM;
315}
316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317static int pty_bsd_ioctl(struct tty_struct *tty, struct file *file,
318 unsigned int cmd, unsigned long arg)
319{
320 switch (cmd) {
321 case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
322 return pty_set_lock(tty, (int __user *) arg);
323 }
324 return -ENOIOCTLCMD;
325}
326
Kay Sieversdc8c8582007-08-15 12:25:38 +0200327static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
328module_param(legacy_count, int, 0);
329
Linus Torvalds342a5972009-09-30 07:49:40 -0700330/*
331 * The master side of a pty can do TIOCSPTLCK and thus
332 * has pty_bsd_ioctl.
333 */
334static const struct tty_operations master_pty_ops_bsd = {
335 .install = pty_install,
Alan Cox3e8e88c2008-04-30 00:54:10 -0700336 .open = pty_open,
337 .close = pty_close,
338 .write = pty_write,
339 .write_room = pty_write_room,
340 .flush_buffer = pty_flush_buffer,
341 .chars_in_buffer = pty_chars_in_buffer,
342 .unthrottle = pty_unthrottle,
343 .set_termios = pty_set_termios,
344 .ioctl = pty_bsd_ioctl,
Alan Coxfc6f6232009-01-02 13:43:17 +0000345 .resize = pty_resize
Alan Cox3e8e88c2008-04-30 00:54:10 -0700346};
347
Linus Torvalds342a5972009-09-30 07:49:40 -0700348static const struct tty_operations slave_pty_ops_bsd = {
349 .install = pty_install,
350 .open = pty_open,
351 .close = pty_close,
352 .write = pty_write,
353 .write_room = pty_write_room,
354 .flush_buffer = pty_flush_buffer,
355 .chars_in_buffer = pty_chars_in_buffer,
356 .unthrottle = pty_unthrottle,
357 .set_termios = pty_set_termios,
358 .resize = pty_resize
359};
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361static void __init legacy_pty_init(void)
362{
Linus Torvalds342a5972009-09-30 07:49:40 -0700363 struct tty_driver *pty_driver, *pty_slave_driver;
364
Kay Sieversdc8c8582007-08-15 12:25:38 +0200365 if (legacy_count <= 0)
366 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
Kay Sieversdc8c8582007-08-15 12:25:38 +0200368 pty_driver = alloc_tty_driver(legacy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (!pty_driver)
370 panic("Couldn't allocate pty driver");
371
Kay Sieversdc8c8582007-08-15 12:25:38 +0200372 pty_slave_driver = alloc_tty_driver(legacy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 if (!pty_slave_driver)
374 panic("Couldn't allocate pty slave driver");
375
376 pty_driver->owner = THIS_MODULE;
377 pty_driver->driver_name = "pty_master";
378 pty_driver->name = "pty";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 pty_driver->major = PTY_MASTER_MAJOR;
380 pty_driver->minor_start = 0;
381 pty_driver->type = TTY_DRIVER_TYPE_PTY;
382 pty_driver->subtype = PTY_TYPE_MASTER;
383 pty_driver->init_termios = tty_std_termios;
384 pty_driver->init_termios.c_iflag = 0;
385 pty_driver->init_termios.c_oflag = 0;
386 pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
387 pty_driver->init_termios.c_lflag = 0;
Alan Cox606d0992006-12-08 02:38:45 -0800388 pty_driver->init_termios.c_ispeed = 38400;
389 pty_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 pty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
391 pty_driver->other = pty_slave_driver;
Linus Torvalds342a5972009-09-30 07:49:40 -0700392 tty_set_operations(pty_driver, &master_pty_ops_bsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394 pty_slave_driver->owner = THIS_MODULE;
395 pty_slave_driver->driver_name = "pty_slave";
396 pty_slave_driver->name = "ttyp";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 pty_slave_driver->major = PTY_SLAVE_MAJOR;
398 pty_slave_driver->minor_start = 0;
399 pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
400 pty_slave_driver->subtype = PTY_TYPE_SLAVE;
401 pty_slave_driver->init_termios = tty_std_termios;
402 pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
Alan Cox606d0992006-12-08 02:38:45 -0800403 pty_slave_driver->init_termios.c_ispeed = 38400;
404 pty_slave_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 pty_slave_driver->flags = TTY_DRIVER_RESET_TERMIOS |
406 TTY_DRIVER_REAL_RAW;
407 pty_slave_driver->other = pty_driver;
Linus Torvalds342a5972009-09-30 07:49:40 -0700408 tty_set_operations(pty_slave_driver, &slave_pty_ops_bsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 if (tty_register_driver(pty_driver))
411 panic("Couldn't register pty driver");
412 if (tty_register_driver(pty_slave_driver))
413 panic("Couldn't register pty slave driver");
414}
415#else
416static inline void legacy_pty_init(void) { }
417#endif
418
419/* Unix98 devices */
420#ifdef CONFIG_UNIX98_PTYS
421/*
422 * sysctl support for setting limits on the number of Unix98 ptys allocated.
423 * Otherwise one can eat up all kernel memory by opening /dev/ptmx repeatedly.
424 */
425int pty_limit = NR_UNIX98_PTY_DEFAULT;
Alan Coxfe9cd962008-10-13 10:43:38 +0100426static int pty_limit_min;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427static int pty_limit_max = NR_UNIX98_PTY_MAX;
Alan Coxfe9cd962008-10-13 10:43:38 +0100428static int pty_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Alan Coxd81ed102008-10-13 10:41:42 +0100430static struct cdev ptmx_cdev;
431
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700432static struct ctl_table pty_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 .procname = "max",
435 .maxlen = sizeof(int),
436 .mode = 0644,
437 .data = &pty_limit,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800438 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 .extra1 = &pty_limit_min,
440 .extra2 = &pty_limit_max,
441 }, {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 .procname = "nr",
443 .maxlen = sizeof(int),
444 .mode = 0444,
Alan Coxbf970ee2008-10-13 10:42:39 +0100445 .data = &pty_count,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800446 .proc_handler = proc_dointvec,
Eric W. Biederman894d2492009-11-05 14:34:02 -0800447 },
448 {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449};
450
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700451static struct ctl_table pty_kern_table[] = {
452 {
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700453 .procname = "pty",
454 .mode = 0555,
455 .child = pty_table,
456 },
457 {}
458};
459
460static struct ctl_table pty_root_table[] = {
461 {
Eric W. Biederman35834ca2007-10-18 03:05:31 -0700462 .procname = "kernel",
463 .mode = 0555,
464 .child = pty_kern_table,
465 },
466 {}
467};
468
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470static int pty_unix98_ioctl(struct tty_struct *tty, struct file *file,
471 unsigned int cmd, unsigned long arg)
472{
473 switch (cmd) {
474 case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
475 return pty_set_lock(tty, (int __user *)arg);
476 case TIOCGPTN: /* Get PT Number */
477 return put_user(tty->index, (unsigned int __user *)arg);
478 }
479
480 return -ENOIOCTLCMD;
481}
482
Alan Cox99f1fe12008-10-13 10:42:00 +0100483/**
484 * ptm_unix98_lookup - find a pty master
485 * @driver: ptm driver
486 * @idx: tty index
487 *
488 * Look up a pty master device. Called under the tty_mutex for now.
489 * This provides our locking.
490 */
491
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100492static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
493 struct inode *ptm_inode, int idx)
Alan Cox99f1fe12008-10-13 10:42:00 +0100494{
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100495 struct tty_struct *tty = devpts_get_tty(ptm_inode, idx);
Alan Cox99f1fe12008-10-13 10:42:00 +0100496 if (tty)
497 tty = tty->link;
498 return tty;
499}
500
501/**
502 * pts_unix98_lookup - find a pty slave
503 * @driver: pts driver
504 * @idx: tty index
505 *
506 * Look up a pty master device. Called under the tty_mutex for now.
507 * This provides our locking.
508 */
509
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100510static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
511 struct inode *pts_inode, int idx)
Alan Cox99f1fe12008-10-13 10:42:00 +0100512{
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100513 struct tty_struct *tty = devpts_get_tty(pts_inode, idx);
Alan Cox99f1fe12008-10-13 10:42:00 +0100514 /* Master must be open before slave */
515 if (!tty)
516 return ERR_PTR(-EIO);
517 return tty;
518}
519
Alan Coxbf970ee2008-10-13 10:42:39 +0100520static void pty_unix98_shutdown(struct tty_struct *tty)
Alan Coxfeebed62008-10-13 10:41:30 +0100521{
522 /* We have our own method as we don't use the tty index */
523 kfree(tty->termios);
Alan Coxfeebed62008-10-13 10:41:30 +0100524}
525
Alan Cox8b0a88d2008-10-13 10:42:19 +0100526/* We have no need to install and remove our tty objects as devpts does all
527 the work for us */
528
Alan Coxbf970ee2008-10-13 10:42:39 +0100529static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +0100530{
Alan Coxbf970ee2008-10-13 10:42:39 +0100531 struct tty_struct *o_tty;
532 int idx = tty->index;
533
534 o_tty = alloc_tty_struct();
535 if (!o_tty)
536 return -ENOMEM;
537 if (!try_module_get(driver->other->owner)) {
538 /* This cannot in fact currently happen */
539 free_tty_struct(o_tty);
540 return -ENOMEM;
541 }
542 initialize_tty_struct(o_tty, driver->other, idx);
543
Alan Cox8dff04e2008-10-13 10:43:58 +0100544 tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
Alan Coxbf970ee2008-10-13 10:42:39 +0100545 if (tty->termios == NULL)
546 goto free_mem_out;
547 *tty->termios = driver->init_termios;
Alan Cox8dff04e2008-10-13 10:43:58 +0100548 tty->termios_locked = tty->termios + 1;
549
550 o_tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
Alan Coxbf970ee2008-10-13 10:42:39 +0100551 if (o_tty->termios == NULL)
552 goto free_mem_out;
553 *o_tty->termios = driver->other->init_termios;
Alan Cox8dff04e2008-10-13 10:43:58 +0100554 o_tty->termios_locked = o_tty->termios + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +0100555
556 tty_driver_kref_get(driver->other);
557 if (driver->subtype == PTY_TYPE_MASTER)
558 o_tty->count++;
559 /* Establish the links in both directions */
560 tty->link = o_tty;
561 o_tty->link = tty;
562 /*
563 * All structures have been allocated, so now we install them.
564 * Failures after this point use release_tty to clean up, so
565 * there's no need to null out the local pointers.
566 */
567 tty_driver_kref_get(driver);
568 tty->count++;
569 pty_count++;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100570 return 0;
Alan Coxbf970ee2008-10-13 10:42:39 +0100571free_mem_out:
Alan Cox8dff04e2008-10-13 10:43:58 +0100572 kfree(o_tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +0100573 module_put(o_tty->driver->owner);
574 free_tty_struct(o_tty);
Alan Cox8dff04e2008-10-13 10:43:58 +0100575 kfree(tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +0100576 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100577}
578
Alan Coxbf970ee2008-10-13 10:42:39 +0100579static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +0100580{
Alan Coxbf970ee2008-10-13 10:42:39 +0100581 pty_count--;
Alan Cox8b0a88d2008-10-13 10:42:19 +0100582}
583
Alan Coxfeebed62008-10-13 10:41:30 +0100584static const struct tty_operations ptm_unix98_ops = {
Alan Cox99f1fe12008-10-13 10:42:00 +0100585 .lookup = ptm_unix98_lookup,
Alan Coxbf970ee2008-10-13 10:42:39 +0100586 .install = pty_unix98_install,
587 .remove = pty_unix98_remove,
Alan Cox3e8e88c2008-04-30 00:54:10 -0700588 .open = pty_open,
589 .close = pty_close,
590 .write = pty_write,
591 .write_room = pty_write_room,
592 .flush_buffer = pty_flush_buffer,
593 .chars_in_buffer = pty_chars_in_buffer,
594 .unthrottle = pty_unthrottle,
595 .set_termios = pty_set_termios,
Alan Coxfeebed62008-10-13 10:41:30 +0100596 .ioctl = pty_unix98_ioctl,
Alan Coxfc6f6232009-01-02 13:43:17 +0000597 .shutdown = pty_unix98_shutdown,
598 .resize = pty_resize
Alan Cox3e8e88c2008-04-30 00:54:10 -0700599};
600
Alan Cox99f1fe12008-10-13 10:42:00 +0100601static const struct tty_operations pty_unix98_ops = {
602 .lookup = pts_unix98_lookup,
Alan Coxbf970ee2008-10-13 10:42:39 +0100603 .install = pty_unix98_install,
604 .remove = pty_unix98_remove,
Alan Cox99f1fe12008-10-13 10:42:00 +0100605 .open = pty_open,
606 .close = pty_close,
607 .write = pty_write,
608 .write_room = pty_write_room,
609 .flush_buffer = pty_flush_buffer,
610 .chars_in_buffer = pty_chars_in_buffer,
611 .unthrottle = pty_unthrottle,
612 .set_termios = pty_set_termios,
Alan Coxbf970ee2008-10-13 10:42:39 +0100613 .shutdown = pty_unix98_shutdown
Alan Cox99f1fe12008-10-13 10:42:00 +0100614};
Alan Coxd81ed102008-10-13 10:41:42 +0100615
616/**
617 * ptmx_open - open a unix 98 pty master
618 * @inode: inode of device file
619 * @filp: file pointer to tty
620 *
621 * Allocate a unix98 pty master device from the ptmx driver.
622 *
623 * Locking: tty_mutex protects the init_dev work. tty->count should
624 * protect the rest.
625 * allocated_ptys_lock handles the list of free pty numbers
626 */
627
628static int __ptmx_open(struct inode *inode, struct file *filp)
629{
630 struct tty_struct *tty;
631 int retval;
632 int index;
633
634 nonseekable_open(inode, filp);
635
636 /* find a device that is not in use. */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100637 index = devpts_new_index(inode);
Alan Coxd81ed102008-10-13 10:41:42 +0100638 if (index < 0)
639 return index;
640
641 mutex_lock(&tty_mutex);
Alan Cox73ec06f2008-10-13 10:42:29 +0100642 tty = tty_init_dev(ptm_driver, index, 1);
Alan Coxd81ed102008-10-13 10:41:42 +0100643 mutex_unlock(&tty_mutex);
644
Alan Cox73ec06f2008-10-13 10:42:29 +0100645 if (IS_ERR(tty)) {
646 retval = PTR_ERR(tty);
Alan Coxd81ed102008-10-13 10:41:42 +0100647 goto out;
Alan Cox73ec06f2008-10-13 10:42:29 +0100648 }
Alan Coxd81ed102008-10-13 10:41:42 +0100649
650 set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
651 filp->private_data = tty;
652 file_move(filp, &tty->tty_files);
653
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100654 retval = devpts_pty_new(inode, tty->link);
Alan Coxd81ed102008-10-13 10:41:42 +0100655 if (retval)
656 goto out1;
657
658 retval = ptm_driver->ops->open(tty, filp);
659 if (!retval)
660 return 0;
661out1:
Alan Coxeeb89d92009-11-30 13:18:29 +0000662 tty_release(inode, filp);
Alan Coxd81ed102008-10-13 10:41:42 +0100663 return retval;
664out:
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +0100665 devpts_kill_index(inode, index);
Alan Coxd81ed102008-10-13 10:41:42 +0100666 return retval;
667}
668
669static int ptmx_open(struct inode *inode, struct file *filp)
670{
671 int ret;
672
673 lock_kernel();
674 ret = __ptmx_open(inode, filp);
675 unlock_kernel();
676 return ret;
677}
678
679static struct file_operations ptmx_fops;
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681static void __init unix98_pty_init(void)
682{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 ptm_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
684 if (!ptm_driver)
685 panic("Couldn't allocate Unix98 ptm driver");
686 pts_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
687 if (!pts_driver)
688 panic("Couldn't allocate Unix98 pts driver");
689
690 ptm_driver->owner = THIS_MODULE;
691 ptm_driver->driver_name = "pty_master";
692 ptm_driver->name = "ptm";
693 ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
694 ptm_driver->minor_start = 0;
695 ptm_driver->type = TTY_DRIVER_TYPE_PTY;
696 ptm_driver->subtype = PTY_TYPE_MASTER;
697 ptm_driver->init_termios = tty_std_termios;
698 ptm_driver->init_termios.c_iflag = 0;
699 ptm_driver->init_termios.c_oflag = 0;
700 ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
701 ptm_driver->init_termios.c_lflag = 0;
Alan Cox606d0992006-12-08 02:38:45 -0800702 ptm_driver->init_termios.c_ispeed = 38400;
703 ptm_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -0700705 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 ptm_driver->other = pts_driver;
Alan Coxfeebed62008-10-13 10:41:30 +0100707 tty_set_operations(ptm_driver, &ptm_unix98_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
709 pts_driver->owner = THIS_MODULE;
710 pts_driver->driver_name = "pty_slave";
711 pts_driver->name = "pts";
712 pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
713 pts_driver->minor_start = 0;
714 pts_driver->type = TTY_DRIVER_TYPE_PTY;
715 pts_driver->subtype = PTY_TYPE_SLAVE;
716 pts_driver->init_termios = tty_std_termios;
717 pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
Alan Cox606d0992006-12-08 02:38:45 -0800718 pts_driver->init_termios.c_ispeed = 38400;
719 pts_driver->init_termios.c_ospeed = 38400;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -0700721 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 pts_driver->other = ptm_driver;
Alan Cox99f1fe12008-10-13 10:42:00 +0100723 tty_set_operations(pts_driver, &pty_unix98_ops);
Alan Coxfe9cd962008-10-13 10:43:38 +0100724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 if (tty_register_driver(ptm_driver))
726 panic("Couldn't register Unix98 ptm driver");
727 if (tty_register_driver(pts_driver))
728 panic("Couldn't register Unix98 pts driver");
729
Alan Coxfe9cd962008-10-13 10:43:38 +0100730 register_sysctl_table(pty_root_table);
Alan Coxd81ed102008-10-13 10:41:42 +0100731
732 /* Now create the /dev/ptmx special device */
733 tty_default_fops(&ptmx_fops);
734 ptmx_fops.open = ptmx_open;
735
736 cdev_init(&ptmx_cdev, &ptmx_fops);
737 if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
738 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
739 panic("Couldn't register /dev/ptmx driver\n");
740 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741}
Alan Coxd81ed102008-10-13 10:41:42 +0100742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743#else
744static inline void unix98_pty_init(void) { }
745#endif
746
747static int __init pty_init(void)
748{
749 legacy_pty_init();
750 unix98_pty_init();
751 return 0;
752}
753module_init(pty_init);