pty.c 19.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Added support for a Unix98-style ptmx device.
 *    -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
 *
A
Alan Cox 已提交
7 8 9
 *  When reading this code see also fs/devpts. In particular note that the
 *  driver_data field is used by the devpts side as a binding to the devpts
 *  inode.
L
Linus Torvalds 已提交
10 11
 */

A
Alan Cox 已提交
12
#include <linux/module.h>
L
Linus Torvalds 已提交
13 14 15 16 17 18

#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/fcntl.h>
19
#include <linux/sched.h>
L
Linus Torvalds 已提交
20 21 22 23 24
#include <linux/string.h>
#include <linux/major.h>
#include <linux/mm.h>
#include <linux/init.h>
#include <linux/sysctl.h>
25
#include <linux/device.h>
A
Alan Cox 已提交
26
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
27 28
#include <linux/bitops.h>
#include <linux/devpts_fs.h>
29
#include <linux/slab.h>
L
Linus Torvalds 已提交
30

A
Alan Cox 已提交
31 32
#include <asm/system.h>

L
Linus Torvalds 已提交
33
#ifdef CONFIG_UNIX98_PTYS
R
Roel Kluin 已提交
34
static struct tty_driver *ptm_driver;
L
Linus Torvalds 已提交
35 36 37
static struct tty_driver *pts_driver;
#endif

A
Alan Cox 已提交
38
static void pty_close(struct tty_struct *tty, struct file *filp)
L
Linus Torvalds 已提交
39
{
A
Alan Cox 已提交
40 41 42 43
	BUG_ON(!tty);
	if (tty->driver->subtype == PTY_TYPE_MASTER)
		WARN_ON(tty->count > 1);
	else {
L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
		if (tty->count > 2)
			return;
	}
	wake_up_interruptible(&tty->read_wait);
	wake_up_interruptible(&tty->write_wait);
	tty->packet = 0;
	if (!tty->link)
		return;
	tty->link->packet = 0;
	set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
	wake_up_interruptible(&tty->link->read_wait);
	wake_up_interruptible(&tty->link->write_wait);
	if (tty->driver->subtype == PTY_TYPE_MASTER) {
		set_bit(TTY_OTHER_CLOSED, &tty->flags);
#ifdef CONFIG_UNIX98_PTYS
		if (tty->driver == ptm_driver)
60
			devpts_pty_kill(tty->link);
L
Linus Torvalds 已提交
61
#endif
62 63 64
		tty_unlock();
		tty_vhangup(tty->link);
		tty_lock();
L
Linus Torvalds 已提交
65 66 67 68 69 70 71
	}
}

/*
 * The unthrottle routine is called by the line discipline to signal
 * that it can receive more characters.  For PTY's, the TTY_THROTTLED
 * flag is always set, to force the line discipline to always call the
A
Alan Cox 已提交
72
 * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
L
Linus Torvalds 已提交
73 74 75 76 77
 * characters in the queue.  This is necessary since each time this
 * happens, we need to wake up any sleeping processes that could be
 * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
 * for the pty buffer to be drained.
 */
A
Alan Cox 已提交
78
static void pty_unthrottle(struct tty_struct *tty)
L
Linus Torvalds 已提交
79
{
80
	tty_wakeup(tty->link);
L
Linus Torvalds 已提交
81 82 83
	set_bit(TTY_THROTTLED, &tty->flags);
}

84 85 86
/**
 *	pty_space	-	report space left for writing
 *	@to: tty we are writing into
L
Linus Torvalds 已提交
87
 *
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
 *	The tty buffers allow 64K but we sneak a peak and clip at 8K this
 *	allows a lot of overspill room for echo and other fun messes to
 *	be handled properly
 */

static int pty_space(struct tty_struct *to)
{
	int n = 8192 - to->buf.memory_used;
	if (n < 0)
		return 0;
	return n;
}

/**
 *	pty_write		-	write to a pty
 *	@tty: the tty we write from
 *	@buf: kernel buffer of data
 *	@count: bytes to write
A
Alan Cox 已提交
106
 *
107 108 109 110
 *	Our "hardware" write method. Data is coming from the ldisc which
 *	may be in a non sleeping state. We simply throw this at the other
 *	end of the link as if we were an IRQ handler receiving stuff for
 *	the other side of the pty/tty pair.
L
Linus Torvalds 已提交
111
 */
112

113
static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
L
Linus Torvalds 已提交
114 115 116
{
	struct tty_struct *to = tty->link;

117
	if (tty->stopped)
L
Linus Torvalds 已提交
118
		return 0;
119 120 121 122 123

	if (c > 0) {
		/* Stuff the data into the input queue of the other end */
		c = tty_insert_flip_string(to, buf, c);
		/* And shovel */
124 125 126 127
		if (c) {
			tty_flip_buffer_push(to);
			tty_wakeup(tty);
		}
A
Alan Cox 已提交
128
	}
L
Linus Torvalds 已提交
129 130 131
	return c;
}

132 133 134 135 136 137 138 139
/**
 *	pty_write_room	-	write space
 *	@tty: tty we are writing from
 *
 *	Report how many bytes the ldisc can send into the queue for
 *	the other device.
 */

L
Linus Torvalds 已提交
140 141
static int pty_write_room(struct tty_struct *tty)
{
142 143
	if (tty->stopped)
		return 0;
144
	return pty_space(tty->link);
L
Linus Torvalds 已提交
145 146
}

147 148 149
/**
 *	pty_chars_in_buffer	-	characters currently in our tx queue
 *	@tty: our tty
A
Alan Cox 已提交
150
 *
151 152
 *	Report how much we have in the transmit queue. As everything is
 *	instantly at the other end this is easy to implement.
L
Linus Torvalds 已提交
153
 */
154

L
Linus Torvalds 已提交
155 156
static int pty_chars_in_buffer(struct tty_struct *tty)
{
157
	return 0;
L
Linus Torvalds 已提交
158 159 160
}

/* Set the lock flag on a pty */
A
Alan Cox 已提交
161
static int pty_set_lock(struct tty_struct *tty, int __user *arg)
L
Linus Torvalds 已提交
162 163
{
	int val;
A
Alan Cox 已提交
164
	if (get_user(val, arg))
L
Linus Torvalds 已提交
165 166 167 168 169 170 171 172
		return -EFAULT;
	if (val)
		set_bit(TTY_PTY_LOCK, &tty->flags);
	else
		clear_bit(TTY_PTY_LOCK, &tty->flags);
	return 0;
}

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
/* Send a signal to the slave */
static int pty_signal(struct tty_struct *tty, int sig)
{
	unsigned long flags;
	struct pid *pgrp;

	if (tty->link) {
		spin_lock_irqsave(&tty->link->ctrl_lock, flags);
		pgrp = get_pid(tty->link->pgrp);
		spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);

		kill_pgrp(pgrp, sig, 1);
		put_pid(pgrp);
	}
	return 0;
}

L
Linus Torvalds 已提交
190 191 192
static void pty_flush_buffer(struct tty_struct *tty)
{
	struct tty_struct *to = tty->link;
A
Alan Cox 已提交
193
	unsigned long flags;
A
Alan Cox 已提交
194

L
Linus Torvalds 已提交
195 196
	if (!to)
		return;
197
	/* tty_buffer_flush(to); FIXME */
L
Linus Torvalds 已提交
198
	if (to->packet) {
A
Alan Cox 已提交
199
		spin_lock_irqsave(&tty->ctrl_lock, flags);
L
Linus Torvalds 已提交
200 201
		tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
		wake_up_interruptible(&to->read_wait);
A
Alan Cox 已提交
202
		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
L
Linus Torvalds 已提交
203 204 205
	}
}

A
Alan Cox 已提交
206
static int pty_open(struct tty_struct *tty, struct file *filp)
L
Linus Torvalds 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
{
	int	retval = -ENODEV;

	if (!tty || !tty->link)
		goto out;

	retval = -EIO;
	if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
		goto out;
	if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
		goto out;
	if (tty->link->count != 1)
		goto out;

	clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
	set_bit(TTY_THROTTLED, &tty->flags);
	retval = 0;
out:
	return retval;
}

A
Alan Cox 已提交
228 229
static void pty_set_termios(struct tty_struct *tty,
					struct ktermios *old_termios)
L
Linus Torvalds 已提交
230
{
A
Alan Cox 已提交
231 232
	tty->termios->c_cflag &= ~(CSIZE | PARENB);
	tty->termios->c_cflag |= (CS8 | CREAD);
L
Linus Torvalds 已提交
233 234
}

A
Alan Cox 已提交
235 236 237
/**
 *	pty_do_resize		-	resize event
 *	@tty: tty being resized
A
Alan Cox 已提交
238
 *	@ws: window size being set.
A
Alan Cox 已提交
239
 *
D
Daniel Mack 已提交
240
 *	Update the termios variables and send the necessary signals to
A
Alan Cox 已提交
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
 *	peform a terminal resize correctly
 */

int pty_resize(struct tty_struct *tty,  struct winsize *ws)
{
	struct pid *pgrp, *rpgrp;
	unsigned long flags;
	struct tty_struct *pty = tty->link;

	/* For a PTY we need to lock the tty side */
	mutex_lock(&tty->termios_mutex);
	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
		goto done;

	/* Get the PID values and reference them so we can
	   avoid holding the tty ctrl lock while sending signals.
	   We need to lock these individually however. */

	spin_lock_irqsave(&tty->ctrl_lock, flags);
	pgrp = get_pid(tty->pgrp);
	spin_unlock_irqrestore(&tty->ctrl_lock, flags);

	spin_lock_irqsave(&pty->ctrl_lock, flags);
	rpgrp = get_pid(pty->pgrp);
	spin_unlock_irqrestore(&pty->ctrl_lock, flags);

	if (pgrp)
		kill_pgrp(pgrp, SIGWINCH, 1);
	if (rpgrp != pgrp && rpgrp)
		kill_pgrp(rpgrp, SIGWINCH, 1);

	put_pid(pgrp);
	put_pid(rpgrp);

	tty->winsize = *ws;
	pty->winsize = *ws;	/* Never used so will go away soon */
done:
	mutex_unlock(&tty->termios_mutex);
	return 0;
}

282 283 284
/* Traditional BSD devices */
#ifdef CONFIG_LEGACY_PTYS

285 286 287 288 289 290 291 292 293 294 295
static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
{
	struct tty_struct *o_tty;
	int idx = tty->index;
	int retval;

	o_tty = alloc_tty_struct();
	if (!o_tty)
		return -ENOMEM;
	if (!try_module_get(driver->other->owner)) {
		/* This cannot in fact currently happen */
296 297
		retval = -ENOMEM;
		goto err_free_tty;
298 299 300 301 302 303 304
	}
	initialize_tty_struct(o_tty, driver->other, idx);

	/* We always use new tty termios data so we can do this
	   the easy way .. */
	retval = tty_init_termios(tty);
	if (retval)
305
		goto err_deinit_tty;
306 307

	retval = tty_init_termios(o_tty);
308 309
	if (retval)
		goto err_free_termios;
A
Alan Cox 已提交
310

311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
	/*
	 * Everything allocated ... set up the o_tty structure.
	 */
	driver->other->ttys[idx] = o_tty;
	tty_driver_kref_get(driver->other);
	if (driver->subtype == PTY_TYPE_MASTER)
		o_tty->count++;
	/* Establish the links in both directions */
	tty->link   = o_tty;
	o_tty->link = tty;

	tty_driver_kref_get(driver);
	tty->count++;
	driver->ttys[idx] = tty;
	return 0;
326 327
err_free_termios:
	tty_free_termios(tty);
328 329
err_deinit_tty:
	deinitialize_tty_struct(o_tty);
330
	module_put(o_tty->driver->owner);
331
err_free_tty:
332
	free_tty_struct(o_tty);
333
	return retval;
334 335
}

336
static int pty_bsd_ioctl(struct tty_struct *tty,
L
Linus Torvalds 已提交
337 338 339 340 341
			 unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
		return pty_set_lock(tty, (int __user *) arg);
342 343
	case TIOCSIG:    /* Send signal to other side of pty */
		return pty_signal(tty, (int) arg);
L
Linus Torvalds 已提交
344 345 346 347
	}
	return -ENOIOCTLCMD;
}

348 349 350
static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
module_param(legacy_count, int, 0);

351 352 353 354 355 356
/*
 * The master side of a pty can do TIOCSPTLCK and thus
 * has pty_bsd_ioctl.
 */
static const struct tty_operations master_pty_ops_bsd = {
	.install = pty_install,
A
Alan Cox 已提交
357 358 359 360 361 362 363 364 365
	.open = pty_open,
	.close = pty_close,
	.write = pty_write,
	.write_room = pty_write_room,
	.flush_buffer = pty_flush_buffer,
	.chars_in_buffer = pty_chars_in_buffer,
	.unthrottle = pty_unthrottle,
	.set_termios = pty_set_termios,
	.ioctl = pty_bsd_ioctl,
A
Alan Cox 已提交
366
	.resize = pty_resize
A
Alan Cox 已提交
367 368
};

369 370 371 372 373 374 375 376 377 378 379 380 381
static const struct tty_operations slave_pty_ops_bsd = {
	.install = pty_install,
	.open = pty_open,
	.close = pty_close,
	.write = pty_write,
	.write_room = pty_write_room,
	.flush_buffer = pty_flush_buffer,
	.chars_in_buffer = pty_chars_in_buffer,
	.unthrottle = pty_unthrottle,
	.set_termios = pty_set_termios,
	.resize = pty_resize
};

L
Linus Torvalds 已提交
382 383
static void __init legacy_pty_init(void)
{
384 385
	struct tty_driver *pty_driver, *pty_slave_driver;

386 387
	if (legacy_count <= 0)
		return;
L
Linus Torvalds 已提交
388

389
	pty_driver = alloc_tty_driver(legacy_count);
L
Linus Torvalds 已提交
390 391 392
	if (!pty_driver)
		panic("Couldn't allocate pty driver");

393
	pty_slave_driver = alloc_tty_driver(legacy_count);
L
Linus Torvalds 已提交
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
	if (!pty_slave_driver)
		panic("Couldn't allocate pty slave driver");

	pty_driver->owner = THIS_MODULE;
	pty_driver->driver_name = "pty_master";
	pty_driver->name = "pty";
	pty_driver->major = PTY_MASTER_MAJOR;
	pty_driver->minor_start = 0;
	pty_driver->type = TTY_DRIVER_TYPE_PTY;
	pty_driver->subtype = PTY_TYPE_MASTER;
	pty_driver->init_termios = tty_std_termios;
	pty_driver->init_termios.c_iflag = 0;
	pty_driver->init_termios.c_oflag = 0;
	pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
	pty_driver->init_termios.c_lflag = 0;
A
Alan Cox 已提交
409 410
	pty_driver->init_termios.c_ispeed = 38400;
	pty_driver->init_termios.c_ospeed = 38400;
L
Linus Torvalds 已提交
411 412
	pty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
	pty_driver->other = pty_slave_driver;
413
	tty_set_operations(pty_driver, &master_pty_ops_bsd);
L
Linus Torvalds 已提交
414 415 416 417 418 419 420 421 422 423

	pty_slave_driver->owner = THIS_MODULE;
	pty_slave_driver->driver_name = "pty_slave";
	pty_slave_driver->name = "ttyp";
	pty_slave_driver->major = PTY_SLAVE_MAJOR;
	pty_slave_driver->minor_start = 0;
	pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
	pty_slave_driver->subtype = PTY_TYPE_SLAVE;
	pty_slave_driver->init_termios = tty_std_termios;
	pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
A
Alan Cox 已提交
424 425
	pty_slave_driver->init_termios.c_ispeed = 38400;
	pty_slave_driver->init_termios.c_ospeed = 38400;
L
Linus Torvalds 已提交
426 427 428
	pty_slave_driver->flags = TTY_DRIVER_RESET_TERMIOS |
					TTY_DRIVER_REAL_RAW;
	pty_slave_driver->other = pty_driver;
429
	tty_set_operations(pty_slave_driver, &slave_pty_ops_bsd);
L
Linus Torvalds 已提交
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446

	if (tty_register_driver(pty_driver))
		panic("Couldn't register pty driver");
	if (tty_register_driver(pty_slave_driver))
		panic("Couldn't register pty slave driver");
}
#else
static inline void legacy_pty_init(void) { }
#endif

/* Unix98 devices */
#ifdef CONFIG_UNIX98_PTYS
/*
 * sysctl support for setting limits on the number of Unix98 ptys allocated.
 * Otherwise one can eat up all kernel memory by opening /dev/ptmx repeatedly.
 */
int pty_limit = NR_UNIX98_PTY_DEFAULT;
A
Alan Cox 已提交
447
static int pty_limit_min;
L
Linus Torvalds 已提交
448
static int pty_limit_max = NR_UNIX98_PTY_MAX;
A
Alan Cox 已提交
449
static int pty_count;
L
Linus Torvalds 已提交
450

451 452
static struct cdev ptmx_cdev;

453
static struct ctl_table pty_table[] = {
L
Linus Torvalds 已提交
454 455 456 457 458
	{
		.procname	= "max",
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.data		= &pty_limit,
459
		.proc_handler	= proc_dointvec_minmax,
L
Linus Torvalds 已提交
460 461 462 463 464 465
		.extra1		= &pty_limit_min,
		.extra2		= &pty_limit_max,
	}, {
		.procname	= "nr",
		.maxlen		= sizeof(int),
		.mode		= 0444,
466
		.data		= &pty_count,
467
		.proc_handler	= proc_dointvec,
468 469
	}, 
	{}
L
Linus Torvalds 已提交
470 471
};

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
static struct ctl_table pty_kern_table[] = {
	{
		.procname	= "pty",
		.mode		= 0555,
		.child		= pty_table,
	},
	{}
};

static struct ctl_table pty_root_table[] = {
	{
		.procname	= "kernel",
		.mode		= 0555,
		.child		= pty_kern_table,
	},
	{}
};


491
static int pty_unix98_ioctl(struct tty_struct *tty,
L
Linus Torvalds 已提交
492 493 494 495 496 497 498
			    unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
		return pty_set_lock(tty, (int __user *)arg);
	case TIOCGPTN: /* Get PT Number */
		return put_user(tty->index, (unsigned int __user *)arg);
499 500
	case TIOCSIG:    /* Send signal to other side of pty */
		return pty_signal(tty, (int) arg);
L
Linus Torvalds 已提交
501 502 503 504 505
	}

	return -ENOIOCTLCMD;
}

506 507 508 509 510 511 512 513 514
/**
 *	ptm_unix98_lookup	-	find a pty master
 *	@driver: ptm driver
 *	@idx: tty index
 *
 *	Look up a pty master device. Called under the tty_mutex for now.
 *	This provides our locking.
 */

515 516
static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
		struct inode *ptm_inode, int idx)
517
{
518
	struct tty_struct *tty = devpts_get_tty(ptm_inode, idx);
519 520 521 522 523 524 525 526 527 528 529 530 531 532
	if (tty)
		tty = tty->link;
	return tty;
}

/**
 *	pts_unix98_lookup	-	find a pty slave
 *	@driver: pts driver
 *	@idx: tty index
 *
 *	Look up a pty master device. Called under the tty_mutex for now.
 *	This provides our locking.
 */

533 534
static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
		struct inode *pts_inode, int idx)
535
{
536
	struct tty_struct *tty = devpts_get_tty(pts_inode, idx);
537 538 539 540 541 542
	/* Master must be open before slave */
	if (!tty)
		return ERR_PTR(-EIO);
	return tty;
}

543
static void pty_unix98_shutdown(struct tty_struct *tty)
A
Alan Cox 已提交
544 545 546 547 548
{
	/* We have our own method as we don't use the tty index */
	kfree(tty->termios);
}

A
Alan Cox 已提交
549 550 551
/* We have no need to install and remove our tty objects as devpts does all
   the work for us */

552
static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
A
Alan Cox 已提交
553
{
554 555 556 557 558 559 560 561
	struct tty_struct *o_tty;
	int idx = tty->index;

	o_tty = alloc_tty_struct();
	if (!o_tty)
		return -ENOMEM;
	if (!try_module_get(driver->other->owner)) {
		/* This cannot in fact currently happen */
562
		goto err_free_tty;
563 564 565
	}
	initialize_tty_struct(o_tty, driver->other, idx);

A
Alan Cox 已提交
566
	tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
567
	if (tty->termios == NULL)
568
		goto err_free_mem;
569
	*tty->termios = driver->init_termios;
A
Alan Cox 已提交
570 571 572
	tty->termios_locked = tty->termios + 1;

	o_tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
573
	if (o_tty->termios == NULL)
574
		goto err_free_mem;
575
	*o_tty->termios = driver->other->init_termios;
A
Alan Cox 已提交
576
	o_tty->termios_locked = o_tty->termios + 1;
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591

	tty_driver_kref_get(driver->other);
	if (driver->subtype == PTY_TYPE_MASTER)
		o_tty->count++;
	/* Establish the links in both directions */
	tty->link   = o_tty;
	o_tty->link = tty;
	/*
	 * All structures have been allocated, so now we install them.
	 * Failures after this point use release_tty to clean up, so
	 * there's no need to null out the local pointers.
	 */
	tty_driver_kref_get(driver);
	tty->count++;
	pty_count++;
A
Alan Cox 已提交
592
	return 0;
593
err_free_mem:
594
	deinitialize_tty_struct(o_tty);
A
Alan Cox 已提交
595
	kfree(o_tty->termios);
596
	kfree(tty->termios);
597
	module_put(o_tty->driver->owner);
598
err_free_tty:
599 600
	free_tty_struct(o_tty);
	return -ENOMEM;
A
Alan Cox 已提交
601 602
}

603
static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
A
Alan Cox 已提交
604
{
605
	pty_count--;
A
Alan Cox 已提交
606 607
}

A
Alan Cox 已提交
608
static const struct tty_operations ptm_unix98_ops = {
609
	.lookup = ptm_unix98_lookup,
610 611
	.install = pty_unix98_install,
	.remove = pty_unix98_remove,
A
Alan Cox 已提交
612 613 614 615 616 617 618 619
	.open = pty_open,
	.close = pty_close,
	.write = pty_write,
	.write_room = pty_write_room,
	.flush_buffer = pty_flush_buffer,
	.chars_in_buffer = pty_chars_in_buffer,
	.unthrottle = pty_unthrottle,
	.set_termios = pty_set_termios,
A
Alan Cox 已提交
620
	.ioctl = pty_unix98_ioctl,
A
Alan Cox 已提交
621 622
	.shutdown = pty_unix98_shutdown,
	.resize = pty_resize
A
Alan Cox 已提交
623 624
};

625 626
static const struct tty_operations pty_unix98_ops = {
	.lookup = pts_unix98_lookup,
627 628
	.install = pty_unix98_install,
	.remove = pty_unix98_remove,
629 630 631 632 633 634 635 636
	.open = pty_open,
	.close = pty_close,
	.write = pty_write,
	.write_room = pty_write_room,
	.flush_buffer = pty_flush_buffer,
	.chars_in_buffer = pty_chars_in_buffer,
	.unthrottle = pty_unthrottle,
	.set_termios = pty_set_termios,
637
	.shutdown = pty_unix98_shutdown
638
};
639 640 641 642 643 644 645 646 647 648 649 650 651

/**
 *	ptmx_open		-	open a unix 98 pty master
 *	@inode: inode of device file
 *	@filp: file pointer to tty
 *
 *	Allocate a unix98 pty master device from the ptmx driver.
 *
 *	Locking: tty_mutex protects the init_dev work. tty->count should
 * 		protect the rest.
 *		allocated_ptys_lock handles the list of free pty numbers
 */

652
static int ptmx_open(struct inode *inode, struct file *filp)
653 654 655 656 657 658 659 660
{
	struct tty_struct *tty;
	int retval;
	int index;

	nonseekable_open(inode, filp);

	/* find a device that is not in use. */
661
	tty_lock();
662
	index = devpts_new_index(inode);
663
	tty_unlock();
664 665 666 667
	if (index < 0)
		return index;

	mutex_lock(&tty_mutex);
668
	tty_lock();
669
	tty = tty_init_dev(ptm_driver, index, 1);
670 671
	mutex_unlock(&tty_mutex);

672 673
	if (IS_ERR(tty)) {
		retval = PTR_ERR(tty);
674
		goto out;
675
	}
676 677

	set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
N
Nick Piggin 已提交
678

679 680 681
	retval = tty_add_file(tty, filp);
	if (retval)
		goto out;
682

683
	retval = devpts_pty_new(inode, tty->link);
684 685 686 687
	if (retval)
		goto out1;

	retval = ptm_driver->ops->open(tty, filp);
688 689
	if (retval)
		goto out2;
690
out1:
691 692 693 694
	tty_unlock();
	return retval;
out2:
	tty_unlock();
695
	tty_release(inode, filp);
696 697
	return retval;
out:
698
	devpts_kill_index(inode, index);
699
	tty_unlock();
700
	return retval;
701 702 703 704
}

static struct file_operations ptmx_fops;

L
Linus Torvalds 已提交
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
static void __init unix98_pty_init(void)
{
	ptm_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
	if (!ptm_driver)
		panic("Couldn't allocate Unix98 ptm driver");
	pts_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
	if (!pts_driver)
		panic("Couldn't allocate Unix98 pts driver");

	ptm_driver->owner = THIS_MODULE;
	ptm_driver->driver_name = "pty_master";
	ptm_driver->name = "ptm";
	ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
	ptm_driver->minor_start = 0;
	ptm_driver->type = TTY_DRIVER_TYPE_PTY;
	ptm_driver->subtype = PTY_TYPE_MASTER;
	ptm_driver->init_termios = tty_std_termios;
	ptm_driver->init_termios.c_iflag = 0;
	ptm_driver->init_termios.c_oflag = 0;
	ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
	ptm_driver->init_termios.c_lflag = 0;
A
Alan Cox 已提交
726 727
	ptm_driver->init_termios.c_ispeed = 38400;
	ptm_driver->init_termios.c_ospeed = 38400;
L
Linus Torvalds 已提交
728
	ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
729
		TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
L
Linus Torvalds 已提交
730
	ptm_driver->other = pts_driver;
A
Alan Cox 已提交
731
	tty_set_operations(ptm_driver, &ptm_unix98_ops);
L
Linus Torvalds 已提交
732 733 734 735 736 737 738 739 740 741

	pts_driver->owner = THIS_MODULE;
	pts_driver->driver_name = "pty_slave";
	pts_driver->name = "pts";
	pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
	pts_driver->minor_start = 0;
	pts_driver->type = TTY_DRIVER_TYPE_PTY;
	pts_driver->subtype = PTY_TYPE_SLAVE;
	pts_driver->init_termios = tty_std_termios;
	pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
A
Alan Cox 已提交
742 743
	pts_driver->init_termios.c_ispeed = 38400;
	pts_driver->init_termios.c_ospeed = 38400;
L
Linus Torvalds 已提交
744
	pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
745
		TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
L
Linus Torvalds 已提交
746
	pts_driver->other = ptm_driver;
747
	tty_set_operations(pts_driver, &pty_unix98_ops);
A
Alan Cox 已提交
748

L
Linus Torvalds 已提交
749 750 751 752 753
	if (tty_register_driver(ptm_driver))
		panic("Couldn't register Unix98 ptm driver");
	if (tty_register_driver(pts_driver))
		panic("Couldn't register Unix98 pts driver");

A
Alan Cox 已提交
754
	register_sysctl_table(pty_root_table);
755 756 757 758 759 760 761 762 763 764

	/* Now create the /dev/ptmx special device */
	tty_default_fops(&ptmx_fops);
	ptmx_fops.open = ptmx_open;

	cdev_init(&ptmx_cdev, &ptmx_fops);
	if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
	    register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
		panic("Couldn't register /dev/ptmx driver\n");
	device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
L
Linus Torvalds 已提交
765
}
766

L
Linus Torvalds 已提交
767 768 769 770 771 772 773 774 775 776 777
#else
static inline void unix98_pty_init(void) { }
#endif

static int __init pty_init(void)
{
	legacy_pty_init();
	unix98_pty_init();
	return 0;
}
module_init(pty_init);