tty_ldisc.c 23.6 KB
Newer Older
1 2
#include <linux/types.h>
#include <linux/errno.h>
3
#include <linux/kmod.h>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/file.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/wait.h>
#include <linux/bitops.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
21
#include <linux/ratelimit.h>
22 23 24 25 26 27 28 29 30 31 32 33

/*
 *	This guards the refcounted line discipline lists. The lock
 *	must be taken with irqs off because there are hangup path
 *	callers who will do ldisc lookups and cannot sleep.
 */

static DEFINE_SPINLOCK(tty_ldisc_lock);
static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
/* Line disc dispatch table */
static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];

34 35 36 37 38 39 40
static inline struct tty_ldisc *get_ldisc(struct tty_ldisc *ld)
{
	if (ld)
		atomic_inc(&ld->users);
	return ld;
}

41
static void put_ldisc(struct tty_ldisc *ld)
42
{
43 44
	unsigned long flags;

45 46 47 48 49 50
	if (WARN_ON_ONCE(!ld))
		return;

	/*
	 * If this is the last user, free the ldisc, and
	 * release the ldisc ops.
51 52 53
	 *
	 * We really want an "atomic_dec_and_lock_irqsave()",
	 * but we don't have it, so this does it by hand.
54
	 */
55 56
	local_irq_save(flags);
	if (atomic_dec_and_lock(&ld->users, &tty_ldisc_lock)) {
57 58 59 60 61
		struct tty_ldisc_ops *ldo = ld->ops;

		ldo->refcount--;
		module_put(ldo->owner);
		spin_unlock_irqrestore(&tty_ldisc_lock, flags);
62 63 64

		kfree(ld);
		return;
65
	}
66
	local_irq_restore(flags);
67
	wake_up(&ld->wq_idle);
68 69
}

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/**
 *	tty_register_ldisc	-	install a line discipline
 *	@disc: ldisc number
 *	@new_ldisc: pointer to the ldisc object
 *
 *	Installs a new line discipline into the kernel. The discipline
 *	is set up as unreferenced and then made available to the kernel
 *	from this point onwards.
 *
 *	Locking:
 *		takes tty_ldisc_lock to guard against ldisc races
 */

int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
{
	unsigned long flags;
	int ret = 0;

	if (disc < N_TTY || disc >= NR_LDISCS)
		return -EINVAL;

	spin_lock_irqsave(&tty_ldisc_lock, flags);
	tty_ldiscs[disc] = new_ldisc;
	new_ldisc->num = disc;
	new_ldisc->refcount = 0;
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);

	return ret;
}
EXPORT_SYMBOL(tty_register_ldisc);

/**
 *	tty_unregister_ldisc	-	unload a line discipline
 *	@disc: ldisc number
 *	@new_ldisc: pointer to the ldisc object
 *
 *	Remove a line discipline from the kernel providing it is not
 *	currently in use.
 *
 *	Locking:
 *		takes tty_ldisc_lock to guard against ldisc races
 */

int tty_unregister_ldisc(int disc)
{
	unsigned long flags;
	int ret = 0;

	if (disc < N_TTY || disc >= NR_LDISCS)
		return -EINVAL;

	spin_lock_irqsave(&tty_ldisc_lock, flags);
	if (tty_ldiscs[disc]->refcount)
		ret = -EBUSY;
	else
		tty_ldiscs[disc] = NULL;
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);

	return ret;
}
EXPORT_SYMBOL(tty_unregister_ldisc);

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
static struct tty_ldisc_ops *get_ldops(int disc)
{
	unsigned long flags;
	struct tty_ldisc_ops *ldops, *ret;

	spin_lock_irqsave(&tty_ldisc_lock, flags);
	ret = ERR_PTR(-EINVAL);
	ldops = tty_ldiscs[disc];
	if (ldops) {
		ret = ERR_PTR(-EAGAIN);
		if (try_module_get(ldops->owner)) {
			ldops->refcount++;
			ret = ldops;
		}
	}
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
	return ret;
}

static void put_ldops(struct tty_ldisc_ops *ldops)
{
	unsigned long flags;

	spin_lock_irqsave(&tty_ldisc_lock, flags);
	ldops->refcount--;
	module_put(ldops->owner);
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
}
160 161 162 163 164 165 166 167 168 169 170 171 172 173

/**
 *	tty_ldisc_get		-	take a reference to an ldisc
 *	@disc: ldisc number
 *
 *	Takes a reference to a line discipline. Deals with refcounts and
 *	module locking counts. Returns NULL if the discipline is not available.
 *	Returns a pointer to the discipline and bumps the ref count if it is
 *	available
 *
 *	Locking:
 *		takes tty_ldisc_lock to guard against ldisc races
 */

Alan Cox's avatar
Alan Cox committed
174
static struct tty_ldisc *tty_ldisc_get(int disc)
175
{
Alan Cox's avatar
Alan Cox committed
176
	struct tty_ldisc *ld;
177
	struct tty_ldisc_ops *ldops;
178 179

	if (disc < N_TTY || disc >= NR_LDISCS)
Alan Cox's avatar
Alan Cox committed
180
		return ERR_PTR(-EINVAL);
181 182 183 184 185 186 187

	/*
	 * Get the ldisc ops - we may need to request them to be loaded
	 * dynamically and try again.
	 */
	ldops = get_ldops(disc);
	if (IS_ERR(ldops)) {
188
		request_module("tty-ldisc-%d", disc);
189 190 191 192 193 194 195 196 197
		ldops = get_ldops(disc);
		if (IS_ERR(ldops))
			return ERR_CAST(ldops);
	}

	ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
	if (ld == NULL) {
		put_ldops(ldops);
		return ERR_PTR(-ENOMEM);
198
	}
199 200 201

	ld->ops = ldops;
	atomic_set(&ld->users, 1);
202 203
	init_waitqueue_head(&ld->wq_idle);

Alan Cox's avatar
Alan Cox committed
204
	return ld;
205 206
}

Alan Cox's avatar
Alan Cox committed
207
static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
208 209 210 211
{
	return (*pos < NR_LDISCS) ? pos : NULL;
}

Alan Cox's avatar
Alan Cox committed
212
static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
213 214 215 216 217 218 219 220 221 222 223 224
{
	(*pos)++;
	return (*pos < NR_LDISCS) ? pos : NULL;
}

static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
{
}

static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
{
	int i = *(loff_t *)v;
225
	struct tty_ldisc_ops *ldops;
Alan Cox's avatar
Alan Cox committed
226

227 228
	ldops = get_ldops(i);
	if (IS_ERR(ldops))
229
		return 0;
230 231
	seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
	put_ldops(ldops);
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
	return 0;
}

static const struct seq_operations tty_ldiscs_seq_ops = {
	.start	= tty_ldiscs_seq_start,
	.next	= tty_ldiscs_seq_next,
	.stop	= tty_ldiscs_seq_stop,
	.show	= tty_ldiscs_seq_show,
};

static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &tty_ldiscs_seq_ops);
}

const struct file_operations tty_ldiscs_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= proc_tty_ldiscs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};

/**
 *	tty_ldisc_assign	-	set ldisc on a tty
 *	@tty: tty to assign
 *	@ld: line discipline
 *
 *	Install an instance of a line discipline into a tty structure. The
261
 *	ldisc must have a reference count above zero to ensure it remains.
262 263 264 265 266 267 268 269
 *	The tty instance refcount starts at zero.
 *
 *	Locking:
 *		Caller must hold references
 */

static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
{
Alan Cox's avatar
Alan Cox committed
270
	tty->ldisc = ld;
271 272 273 274 275 276 277 278 279 280 281 282 283 284
}

/**
 *	tty_ldisc_try		-	internal helper
 *	@tty: the tty
 *
 *	Make a single attempt to grab and bump the refcount on
 *	the tty ldisc. Return 0 on failure or 1 on success. This is
 *	used to implement both the waiting and non waiting versions
 *	of tty_ldisc_ref
 *
 *	Locking: takes tty_ldisc_lock
 */

285
static struct tty_ldisc *tty_ldisc_try(struct tty_struct *tty)
286 287 288 289 290
{
	unsigned long flags;
	struct tty_ldisc *ld;

	spin_lock_irqsave(&tty_ldisc_lock, flags);
291 292 293
	ld = NULL;
	if (test_bit(TTY_LDISC, &tty->flags))
		ld = get_ldisc(tty->ldisc);
294
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
295
	return ld;
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
}

/**
 *	tty_ldisc_ref_wait	-	wait for the tty ldisc
 *	@tty: tty device
 *
 *	Dereference the line discipline for the terminal and take a
 *	reference to it. If the line discipline is in flux then
 *	wait patiently until it changes.
 *
 *	Note: Must not be called from an IRQ/timer context. The caller
 *	must also be careful not to hold other locks that will deadlock
 *	against a discipline change, such as an existing ldisc reference
 *	(which we check for)
 *
 *	Locking: call functions take tty_ldisc_lock
 */

struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
{
316 317
	struct tty_ldisc *ld;

318
	/* wait_event is a macro */
319 320
	wait_event(tty_ldisc_wait, (ld = tty_ldisc_try(tty)) != NULL);
	return ld;
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
}
EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);

/**
 *	tty_ldisc_ref		-	get the tty ldisc
 *	@tty: tty device
 *
 *	Dereference the line discipline for the terminal and take a
 *	reference to it. If the line discipline is in flux then
 *	return NULL. Can be called from IRQ and timer functions.
 *
 *	Locking: called functions take tty_ldisc_lock
 */

struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
{
337
	return tty_ldisc_try(tty);
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
}
EXPORT_SYMBOL_GPL(tty_ldisc_ref);

/**
 *	tty_ldisc_deref		-	free a tty ldisc reference
 *	@ld: reference to free up
 *
 *	Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
 *	be called in IRQ context.
 *
 *	Locking: takes tty_ldisc_lock
 */

void tty_ldisc_deref(struct tty_ldisc *ld)
{
353
	put_ldisc(ld);
354 355 356
}
EXPORT_SYMBOL_GPL(tty_ldisc_deref);

357 358 359 360 361
static inline void tty_ldisc_put(struct tty_ldisc *ld)
{
	put_ldisc(ld);
}

362 363 364 365 366
/**
 *	tty_ldisc_enable	-	allow ldisc use
 *	@tty: terminal to activate ldisc on
 *
 *	Set the TTY_LDISC flag when the line discipline can be called
Alan Cox's avatar
Alan Cox committed
367 368
 *	again. Do necessary wakeups for existing sleepers. Clear the LDISC
 *	changing flag to indicate any ldisc change is now over.
369
 *
Alan Cox's avatar
Alan Cox committed
370 371
 *	Note: nobody should set the TTY_LDISC bit except via this function.
 *	Clearing directly is allowed.
372 373 374 375 376
 */

void tty_ldisc_enable(struct tty_struct *tty)
{
	set_bit(TTY_LDISC, &tty->flags);
Alan Cox's avatar
Alan Cox committed
377
	clear_bit(TTY_LDISC_CHANGING, &tty->flags);
378 379 380
	wake_up(&tty_ldisc_wait);
}

Alan Cox's avatar
Alan Cox committed
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
/**
 *	tty_ldisc_flush	-	flush line discipline queue
 *	@tty: tty
 *
 *	Flush the line discipline queue (if any) for this tty. If there
 *	is no line discipline active this is a no-op.
 */

void tty_ldisc_flush(struct tty_struct *tty)
{
	struct tty_ldisc *ld = tty_ldisc_ref(tty);
	if (ld) {
		if (ld->ops->flush_buffer)
			ld->ops->flush_buffer(tty);
		tty_ldisc_deref(ld);
	}
	tty_buffer_flush(tty);
}
EXPORT_SYMBOL_GPL(tty_ldisc_flush);

401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
/**
 *	tty_set_termios_ldisc		-	set ldisc field
 *	@tty: tty structure
 *	@num: line discipline number
 *
 *	This is probably overkill for real world processors but
 *	they are not on hot paths so a little discipline won't do
 *	any harm.
 *
 *	Locking: takes termios_mutex
 */

static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
{
	mutex_lock(&tty->termios_mutex);
416
	tty->termios.c_line = num;
417 418 419
	mutex_unlock(&tty->termios_mutex);
}

Alan Cox's avatar
Alan Cox committed
420 421 422 423 424 425 426
/**
 *	tty_ldisc_open		-	open a line discipline
 *	@tty: tty we are opening the ldisc on
 *	@ld: discipline to open
 *
 *	A helper opening method. Also a convenient debugging and check
 *	point.
427 428
 *
 *	Locking: always called with BTM already held.
Alan Cox's avatar
Alan Cox committed
429 430 431 432 433
 */

static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
{
	WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
434 435
	if (ld->ops->open) {
		int ret;
436
                /* BTM here locks versus a hangup event */
437
		ret = ld->ops->open(tty);
438 439
		if (ret)
			clear_bit(TTY_LDISC_OPEN, &tty->flags);
440 441
		return ret;
	}
Alan Cox's avatar
Alan Cox committed
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
	return 0;
}

/**
 *	tty_ldisc_close		-	close a line discipline
 *	@tty: tty we are opening the ldisc on
 *	@ld: discipline to close
 *
 *	A helper close method. Also a convenient debugging and check
 *	point.
 */

static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
{
	WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
	clear_bit(TTY_LDISC_OPEN, &tty->flags);
	if (ld->ops->close)
		ld->ops->close(tty);
}
461 462 463 464 465 466 467 468 469 470 471 472 473

/**
 *	tty_ldisc_restore	-	helper for tty ldisc change
 *	@tty: tty to recover
 *	@old: previous ldisc
 *
 *	Restore the previous line discipline or N_TTY when a line discipline
 *	change fails due to an open error
 */

static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
{
	char buf[64];
Alan Cox's avatar
Alan Cox committed
474 475
	struct tty_ldisc *new_ldisc;
	int r;
476 477

	/* There is an outstanding reference here so this is safe */
Alan Cox's avatar
Alan Cox committed
478 479
	old = tty_ldisc_get(old->ops->num);
	WARN_ON(IS_ERR(old));
480 481
	tty_ldisc_assign(tty, old);
	tty_set_termios_ldisc(tty, old->ops->num);
Alan Cox's avatar
Alan Cox committed
482 483
	if (tty_ldisc_open(tty, old) < 0) {
		tty_ldisc_put(old);
484
		/* This driver is always present */
Alan Cox's avatar
Alan Cox committed
485
		new_ldisc = tty_ldisc_get(N_TTY);
Alan Cox's avatar
Alan Cox committed
486
		if (IS_ERR(new_ldisc))
487
			panic("n_tty: get");
Alan Cox's avatar
Alan Cox committed
488
		tty_ldisc_assign(tty, new_ldisc);
489
		tty_set_termios_ldisc(tty, N_TTY);
Alan Cox's avatar
Alan Cox committed
490 491 492 493 494
		r = tty_ldisc_open(tty, new_ldisc);
		if (r < 0)
			panic("Couldn't open N_TTY ldisc for "
			      "%s --- error %d.",
			      tty_name(tty, buf), r);
495 496 497
	}
}

498
/**
Alan Cox's avatar
Alan Cox committed
499
 *	tty_ldisc_halt		-	shut down the line discipline
500 501 502 503 504 505 506
 *	@tty: tty device
 *
 *	Shut down the line discipline and work queue for this tty device.
 *	The TTY_LDISC flag being cleared ensures no further references can
 *	be obtained while the delayed work queue halt ensures that no more
 *	data is fed to the ldisc.
 *
507 508 509
 *	You need to do a 'flush_scheduled_work()' (outside the ldisc_mutex)
 *	in order to make sure any currently executing ldisc work is also
 *	flushed.
510 511
 */

Alan Cox's avatar
Alan Cox committed
512
static int tty_ldisc_halt(struct tty_struct *tty)
513 514
{
	clear_bit(TTY_LDISC, &tty->flags);
515
	return cancel_work_sync(&tty->buf.work);
516 517
}

518 519 520 521 522 523 524 525 526 527
/**
 *	tty_ldisc_flush_works	-	flush all works of a tty
 *	@tty: tty device to flush works for
 *
 *	Sync flush all works belonging to @tty.
 */
static void tty_ldisc_flush_works(struct tty_struct *tty)
{
	flush_work_sync(&tty->hangup_work);
	flush_work_sync(&tty->SAK_work);
528
	flush_work_sync(&tty->buf.work);
529 530
}

Jiri Slaby's avatar
Jiri Slaby committed
531 532 533
/**
 *	tty_ldisc_wait_idle	-	wait for the ldisc to become idle
 *	@tty: tty to wait for
534
 *	@timeout: for how long to wait at most
Jiri Slaby's avatar
Jiri Slaby committed
535 536 537 538
 *
 *	Wait for the line discipline to become idle. The discipline must
 *	have been halted for this to guarantee it remains idle.
 */
539
static int tty_ldisc_wait_idle(struct tty_struct *tty, long timeout)
Jiri Slaby's avatar
Jiri Slaby committed
540
{
541
	long ret;
542
	ret = wait_event_timeout(tty->ldisc->wq_idle,
543
			atomic_read(&tty->ldisc->users) == 1, timeout);
Jiri Slaby's avatar
Jiri Slaby committed
544 545 546
	return ret > 0 ? 0 : -EBUSY;
}

547 548 549 550 551 552
/**
 *	tty_set_ldisc		-	set line discipline
 *	@tty: the terminal to set
 *	@ldisc: the line discipline
 *
 *	Set the discipline of a tty line. Must be called from a process
Alan Cox's avatar
Alan Cox committed
553 554 555
 *	context. The ldisc change logic has to protect itself against any
 *	overlapping ldisc change (including on the other end of pty pairs),
 *	the close of one side of a tty/pty pair, and eventually hangup.
556
 *
Alan Cox's avatar
Alan Cox committed
557
 *	Locking: takes tty_ldisc_lock, termios_mutex
558 559 560 561 562
 */

int tty_set_ldisc(struct tty_struct *tty, int ldisc)
{
	int retval;
Alan Cox's avatar
Alan Cox committed
563 564
	struct tty_ldisc *o_ldisc, *new_ldisc;
	int work, o_work = 0;
565 566
	struct tty_struct *o_tty;

Alan Cox's avatar
Alan Cox committed
567 568 569
	new_ldisc = tty_ldisc_get(ldisc);
	if (IS_ERR(new_ldisc))
		return PTR_ERR(new_ldisc);
570

Alan Cox's avatar
Alan Cox committed
571
	tty_lock(tty);
572
	/*
Alan Cox's avatar
Alan Cox committed
573 574
	 *	We need to look at the tty locking here for pty/tty pairs
	 *	when both sides try to change in parallel.
575 576
	 */

Alan Cox's avatar
Alan Cox committed
577 578
	o_tty = tty->link;	/* o_tty is the pty side or NULL */

579

Alan Cox's avatar
Alan Cox committed
580 581 582 583 584
	/*
	 *	Check the no-op case
	 */

	if (tty->ldisc->ops->num == ldisc) {
Alan Cox's avatar
Alan Cox committed
585
		tty_unlock(tty);
Alan Cox's avatar
Alan Cox committed
586
		tty_ldisc_put(new_ldisc);
587 588 589
		return 0;
	}

Alan Cox's avatar
Alan Cox committed
590
	tty_unlock(tty);
Alan Cox's avatar
Alan Cox committed
591 592 593 594 595 596 597
	/*
	 *	Problem: What do we do if this blocks ?
	 *	We could deadlock here
	 */

	tty_wait_until_sent(tty, 0);

Alan Cox's avatar
Alan Cox committed
598
	tty_lock(tty);
Alan Cox's avatar
Alan Cox committed
599 600 601 602 603 604 605 606 607
	mutex_lock(&tty->ldisc_mutex);

	/*
	 *	We could be midstream of another ldisc change which has
	 *	dropped the lock during processing. If so we need to wait.
	 */

	while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
		mutex_unlock(&tty->ldisc_mutex);
Alan Cox's avatar
Alan Cox committed
608
		tty_unlock(tty);
Alan Cox's avatar
Alan Cox committed
609 610
		wait_event(tty_ldisc_wait,
			test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0);
Alan Cox's avatar
Alan Cox committed
611
		tty_lock(tty);
Alan Cox's avatar
Alan Cox committed
612 613
		mutex_lock(&tty->ldisc_mutex);
	}
614

Alan Cox's avatar
Alan Cox committed
615
	set_bit(TTY_LDISC_CHANGING, &tty->flags);
Alan Cox's avatar
Alan Cox committed
616

617 618 619 620 621 622 623 624
	/*
	 *	No more input please, we are switching. The new ldisc
	 *	will update this value in the ldisc open function
	 */

	tty->receive_room = 0;

	o_ldisc = tty->ldisc;
625

Alan Cox's avatar
Alan Cox committed
626
	tty_unlock(tty);
627 628 629 630 631
	/*
	 *	Make sure we don't change while someone holds a
	 *	reference to the line discipline. The TTY_LDISC bit
	 *	prevents anyone taking a reference once it is clear.
	 *	We need the lock to avoid racing reference takers.
Alan Cox's avatar
Alan Cox committed
632 633 634 635
	 *
	 *	We must clear the TTY_LDISC bit here to avoid a livelock
	 *	with a userspace app continually trying to use the tty in
	 *	parallel to the change and re-referencing the tty.
636 637
	 */

Alan Cox's avatar
Alan Cox committed
638
	work = tty_ldisc_halt(tty);
639
	if (o_tty)
Alan Cox's avatar
Alan Cox committed
640
		o_work = tty_ldisc_halt(o_tty);
641 642

	/*
Alan Cox's avatar
Alan Cox committed
643 644
	 * Wait for ->hangup_work and ->buf.work handlers to terminate.
	 * We must drop the mutex here in case a hangup is also in process.
645
	 */
Alan Cox's avatar
Alan Cox committed
646 647 648

	mutex_unlock(&tty->ldisc_mutex);

649
	tty_ldisc_flush_works(tty);
Alan Cox's avatar
Alan Cox committed
650

651
	retval = tty_ldisc_wait_idle(tty, 5 * HZ);
Jiri Slaby's avatar
Jiri Slaby committed
652

Alan Cox's avatar
Alan Cox committed
653
	tty_lock(tty);
Arnd Bergmann's avatar
Arnd Bergmann committed
654
	mutex_lock(&tty->ldisc_mutex);
Jiri Slaby's avatar
Jiri Slaby committed
655 656 657 658 659 660 661

	/* handle wait idle failure locked */
	if (retval) {
		tty_ldisc_put(new_ldisc);
		goto enable;
	}

662
	if (test_bit(TTY_HUPPING, &tty->flags)) {
Alan Cox's avatar
Alan Cox committed
663 664 665 666 667
		/* We were raced by the hangup method. It will have stomped
		   the ldisc data and closed the ldisc down */
		clear_bit(TTY_LDISC_CHANGING, &tty->flags);
		mutex_unlock(&tty->ldisc_mutex);
		tty_ldisc_put(new_ldisc);
Alan Cox's avatar
Alan Cox committed
668
		tty_unlock(tty);
Alan Cox's avatar
Alan Cox committed
669 670 671
		return -EIO;
	}

672
	/* Shutdown the current discipline. */
Alan Cox's avatar
Alan Cox committed
673
	tty_ldisc_close(tty, o_ldisc);
674 675

	/* Now set up the new line discipline. */
Alan Cox's avatar
Alan Cox committed
676
	tty_ldisc_assign(tty, new_ldisc);
677
	tty_set_termios_ldisc(tty, ldisc);
Alan Cox's avatar
Alan Cox committed
678 679

	retval = tty_ldisc_open(tty, new_ldisc);
680
	if (retval < 0) {
Alan Cox's avatar
Alan Cox committed
681 682 683
		/* Back to the old one or N_TTY if we can't */
		tty_ldisc_put(new_ldisc);
		tty_ldisc_restore(tty, o_ldisc);
684
	}
Alan Cox's avatar
Alan Cox committed
685

686 687 688 689
	/* At this point we hold a reference to the new ldisc and a
	   a reference to the old ldisc. If we ended up flipping back
	   to the existing ldisc we have two references to it */

Alan Cox's avatar
Alan Cox committed
690
	if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc)
691 692
		tty->ops->set_ldisc(tty);

Alan Cox's avatar
Alan Cox committed
693
	tty_ldisc_put(o_ldisc);
694

Jiri Slaby's avatar
Jiri Slaby committed
695
enable:
696
	/*
Alan Cox's avatar
Alan Cox committed
697
	 *	Allow ldisc referencing to occur again
698 699 700 701 702 703
	 */

	tty_ldisc_enable(tty);
	if (o_tty)
		tty_ldisc_enable(o_tty);

Alan Cox's avatar
Alan Cox committed
704
	/* Restart the work queue in case no characters kick it off. Safe if
705 706
	   already running */
	if (work)
707
		schedule_work(&tty->buf.work);
Alan Cox's avatar
Alan Cox committed
708
	if (o_work)
709
		schedule_work(&o_tty->buf.work);
Alan Cox's avatar
Alan Cox committed
710
	mutex_unlock(&tty->ldisc_mutex);
Alan Cox's avatar
Alan Cox committed
711
	tty_unlock(tty);
712 713 714
	return retval;
}

Alan Cox's avatar
Alan Cox committed
715 716 717 718 719 720 721 722 723 724
/**
 *	tty_reset_termios	-	reset terminal state
 *	@tty: tty to reset
 *
 *	Restore a terminal to the driver default state.
 */

static void tty_reset_termios(struct tty_struct *tty)
{
	mutex_lock(&tty->termios_mutex);
725 726 727
	tty->termios = tty->driver->init_termios;
	tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
	tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Alan Cox's avatar
Alan Cox committed
728 729 730 731 732 733 734
	mutex_unlock(&tty->termios_mutex);
}


/**
 *	tty_ldisc_reinit	-	reinitialise the tty ldisc
 *	@tty: tty to reinit
Alan Cox's avatar
Alan Cox committed
735
 *	@ldisc: line discipline to reinitialize
Alan Cox's avatar
Alan Cox committed
736
 *
Alan Cox's avatar
Alan Cox committed
737 738
 *	Switch the tty to a line discipline and leave the ldisc
 *	state closed
Alan Cox's avatar
Alan Cox committed
739 740
 */

741
static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
Alan Cox's avatar
Alan Cox committed
742
{
743 744 745 746
	struct tty_ldisc *ld = tty_ldisc_get(ldisc);

	if (IS_ERR(ld))
		return -1;
Alan Cox's avatar
Alan Cox committed
747 748 749 750 751 752 753 754

	tty_ldisc_close(tty, tty->ldisc);
	tty_ldisc_put(tty->ldisc);
	tty->ldisc = NULL;
	/*
	 *	Switch the line discipline back
	 */
	tty_ldisc_assign(tty, ld);
Alan Cox's avatar
Alan Cox committed
755
	tty_set_termios_ldisc(tty, ldisc);
756 757

	return 0;
Alan Cox's avatar
Alan Cox committed
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
}

/**
 *	tty_ldisc_hangup		-	hangup ldisc reset
 *	@tty: tty being hung up
 *
 *	Some tty devices reset their termios when they receive a hangup
 *	event. In that situation we must also switch back to N_TTY properly
 *	before we reset the termios data.
 *
 *	Locking: We can take the ldisc mutex as the rest of the code is
 *	careful to allow for this.
 *
 *	In the pty pair case this occurs in the close() path of the
 *	tty itself so we must be careful about locking rules.
 */

void tty_ldisc_hangup(struct tty_struct *tty)
{
	struct tty_ldisc *ld;
Alan Cox's avatar
Alan Cox committed
778 779
	int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
	int err = 0;
Alan Cox's avatar
Alan Cox committed
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806

	/*
	 * FIXME! What are the locking issues here? This may me overdoing
	 * things... This question is especially important now that we've
	 * removed the irqlock.
	 */
	ld = tty_ldisc_ref(tty);
	if (ld != NULL) {
		/* We may have no line discipline at this point */
		if (ld->ops->flush_buffer)
			ld->ops->flush_buffer(tty);
		tty_driver_flush_buffer(tty);
		if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
		    ld->ops->write_wakeup)
			ld->ops->write_wakeup(tty);
		if (ld->ops->hangup)
			ld->ops->hangup(tty);
		tty_ldisc_deref(ld);
	}
	/*
	 * FIXME: Once we trust the LDISC code better we can wait here for
	 * ldisc completion and fix the driver call race
	 */
	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
	wake_up_interruptible_poll(&tty->read_wait, POLLIN);
	/*
	 * Shutdown the current line discipline, and reset it to
Alan Cox's avatar
Alan Cox committed
807 808 809
	 * N_TTY if need be.
	 *
	 * Avoid racing set_ldisc or tty_ldisc_release
Alan Cox's avatar
Alan Cox committed
810
	 */
Alan Cox's avatar
Alan Cox committed
811
	mutex_lock(&tty->ldisc_mutex);
Arnd Bergmann's avatar
Arnd Bergmann committed
812 813 814

	/*
	 * this is like tty_ldisc_halt, but we need to give up
815 816
	 * the BTM before calling cancel_work_sync, which may
	 * need to wait for another function taking the BTM
Arnd Bergmann's avatar
Arnd Bergmann committed
817 818
	 */
	clear_bit(TTY_LDISC, &tty->flags);
Alan Cox's avatar
Alan Cox committed
819
	tty_unlock(tty);
820
	cancel_work_sync(&tty->buf.work);
Arnd Bergmann's avatar
Arnd Bergmann committed
821
	mutex_unlock(&tty->ldisc_mutex);
822
retry:
Alan Cox's avatar
Alan Cox committed
823
	tty_lock(tty);
Arnd Bergmann's avatar
Arnd Bergmann committed
824 825
	mutex_lock(&tty->ldisc_mutex);

Alan Cox's avatar
Alan Cox committed
826 827 828 829 830
	/* At this point we have a closed ldisc and we want to
	   reopen it. We could defer this to the next open but
	   it means auditing a lot of other paths so this is
	   a FIXME */
	if (tty->ldisc) {	/* Not yet closed */
831 832 833
		if (atomic_read(&tty->ldisc->users) != 1) {
			char cur_n[TASK_COMM_LEN], tty_n[64];
			long timeout = 3 * HZ;
Alan Cox's avatar
Alan Cox committed
834
			tty_unlock(tty);
835 836 837 838 839 840 841 842 843 844 845

			while (tty_ldisc_wait_idle(tty, timeout) == -EBUSY) {
				timeout = MAX_SCHEDULE_TIMEOUT;
				printk_ratelimited(KERN_WARNING
					"%s: waiting (%s) for %s took too long, but we keep waiting...\n",
					__func__, get_task_comm(cur_n, current),
					tty_name(tty, tty_n));
			}
			mutex_unlock(&tty->ldisc_mutex);
			goto retry;
		}
846

Alan Cox's avatar
Alan Cox committed
847
		if (reset == 0) {
848

849
			if (!tty_ldisc_reinit(tty, tty->termios.c_line))
850 851 852
				err = tty_ldisc_open(tty, tty->ldisc);
			else
				err = 1;
Alan Cox's avatar
Alan Cox committed
853 854 855 856
		}
		/* If the re-open fails or we reset then go to N_TTY. The
		   N_TTY open cannot fail */
		if (reset || err) {
857
			BUG_ON(tty_ldisc_reinit(tty, N_TTY));
Alan Cox's avatar
Alan Cox committed
858 859
			WARN_ON(tty_ldisc_open(tty, tty->ldisc));
		}
Alan Cox's avatar
Alan Cox committed
860
		tty_ldisc_enable(tty);
Alan Cox's avatar
Alan Cox committed
861
	}
Alan Cox's avatar
Alan Cox committed
862 863 864
	mutex_unlock(&tty->ldisc_mutex);
	if (reset)
		tty_reset_termios(tty);
Alan Cox's avatar
Alan Cox committed
865
}
866 867 868 869 870 871 872

/**
 *	tty_ldisc_setup			-	open line discipline
 *	@tty: tty being shut down
 *	@o_tty: pair tty for pty/tty pairs
 *
 *	Called during the initial open of a tty/pty pair in order to set up the
Alan Cox's avatar
Alan Cox committed
873 874
 *	line disciplines and bind them to the tty. This has no locking issues
 *	as the device isn't yet active.
875 876 877 878
 */

int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
{
Alan Cox's avatar
Alan Cox committed
879
	struct tty_ldisc *ld = tty->ldisc;
880 881
	int retval;

Alan Cox's avatar
Alan Cox committed
882 883 884 885 886 887
	retval = tty_ldisc_open(tty, ld);
	if (retval)
		return retval;

	if (o_tty) {
		retval = tty_ldisc_open(o_tty, o_tty->ldisc);
888
		if (retval) {
Alan Cox's avatar
Alan Cox committed
889
			tty_ldisc_close(tty, ld);
890 891 892 893 894 895 896
			return retval;
		}
		tty_ldisc_enable(o_tty);
	}
	tty_ldisc_enable(tty);
	return 0;
}
Alan Cox's avatar
Alan Cox committed
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913

static void tty_ldisc_kill(struct tty_struct *tty)
{
	mutex_lock(&tty->ldisc_mutex);
	/*
	 * Now kill off the ldisc
	 */
	tty_ldisc_close(tty, tty->ldisc);
	tty_ldisc_put(tty->ldisc);
	/* Force an oops if we mess this up */
	tty->ldisc = NULL;

	/* Ensure the next open requests the N_TTY ldisc */
	tty_set_termios_ldisc(tty, N_TTY);
	mutex_unlock(&tty->ldisc_mutex);
}

914 915 916 917 918
/**
 *	tty_ldisc_release		-	release line discipline
 *	@tty: tty being shut down
 *	@o_tty: pair tty for pty/tty pairs
 *
Alan Cox's avatar
Alan Cox committed
919 920
 *	Called during the final close of a tty/pty pair in order to shut down
 *	the line discpline layer. On exit the ldisc assigned is N_TTY and the
Alan Cox's avatar
Alan Cox committed
921
 *	ldisc has not been opened.
922 923 924 925 926 927 928 929 930 931
 */

void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
{
	/*
	 * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
	 * kill any delayed work. As this is the final close it does not
	 * race with the set_ldisc code path.
	 */

Alan Cox's avatar
Alan Cox committed
932
	tty_lock_pair(tty, o_tty);
933
	tty_ldisc_halt(tty);
934
	tty_ldisc_flush_works(tty);
Alan Cox's avatar
Alan Cox committed
935 936 937 938
	if (o_tty) {
		tty_ldisc_halt(o_tty);
		tty_ldisc_flush_works(o_tty);
	}
Alan Cox's avatar
Alan Cox committed
939

940
	/* This will need doing differently if we need to lock */
Alan Cox's avatar
Alan Cox committed
941 942
	tty_ldisc_kill(tty);

Alan Cox's avatar
Alan Cox committed
943
	if (o_tty)
Alan Cox's avatar
Alan Cox committed
944
		tty_ldisc_kill(o_tty);
945

Alan Cox's avatar
Alan Cox committed
946
	tty_unlock_pair(tty, o_tty);
947 948
	/* And the memory resources remaining (buffers, termios) will be
	   disposed of when the kref hits zero */
949 950 951 952 953 954 955 956 957 958 959 960
}

/**
 *	tty_ldisc_init		-	ldisc setup for new tty
 *	@tty: tty being allocated
 *
 *	Set up the line discipline objects for a newly allocated tty. Note that
 *	the tty structure is not completely set up when this call is made.
 */

void tty_ldisc_init(struct tty_struct *tty)
{
Alan Cox's avatar
Alan Cox committed
961 962
	struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
	if (IS_ERR(ld))
963
		panic("n_tty: init_tty");
Alan Cox's avatar
Alan Cox committed
964
	tty_ldisc_assign(tty, ld);
965 966
}

967 968 969 970 971 972 973 974 975 976 977 978 979
/**
 *	tty_ldisc_init		-	ldisc cleanup for new tty
 *	@tty: tty that was allocated recently
 *
 *	The tty structure must not becompletely set up (tty_ldisc_setup) when
 *      this call is made.
 */
void tty_ldisc_deinit(struct tty_struct *tty)
{
	put_ldisc(tty->ldisc);
	tty_ldisc_assign(tty, NULL);
}

980 981 982 983 984
void tty_ldisc_begin(void)
{
	/* Setup the default TTY line discipline. */
	(void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
}