tty_ldisc.c 22.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
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
#include <linux/types.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/fcntl.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/devpts_fs.h>
#include <linux/file.h>
#include <linux/console.h>
#include <linux/timer.h>
#include <linux/ctype.h>
#include <linux/kd.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/delay.h>
#include <linux/seq_file.h>

#include <linux/uaccess.h>
#include <asm/system.h>

#include <linux/kbd_kern.h>
#include <linux/vt_kern.h>
#include <linux/selection.h>

#include <linux/kmod.h>
#include <linux/nsproxy.h>

/*
 *	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];

/**
 *	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);


/**
 *	tty_ldisc_try_get	-	try and reference an ldisc
 *	@disc: ldisc number
 *
 *	Attempt to open and lock a line discipline into place. Return
Alan Cox's avatar
Alan Cox committed
119
 *	the line discipline refcounted or an error.
120
121
 */

Alan Cox's avatar
Alan Cox committed
122
static struct tty_ldisc *tty_ldisc_try_get(int disc)
123
124
{
	unsigned long flags;
Alan Cox's avatar
Alan Cox committed
125
	struct tty_ldisc *ld;
126
127
	struct tty_ldisc_ops *ldops;
	int err = -EINVAL;
Alan Cox's avatar
Alan Cox committed
128

Alan Cox's avatar
Alan Cox committed
129
130
131
132
	ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
	if (ld == NULL)
		return ERR_PTR(-ENOMEM);

133
134
135
136
137
138
139
140
141
142
143
144
	spin_lock_irqsave(&tty_ldisc_lock, flags);
	ld->ops = NULL;
	ldops = tty_ldiscs[disc];
	/* Check the entry is defined */
	if (ldops) {
		/* If the module is being unloaded we can't use it */
		if (!try_module_get(ldops->owner))
			err = -EAGAIN;
		else {
			/* lock it */
			ldops->refcount++;
			ld->ops = ldops;
145
			atomic_set(&ld->users, 0);
146
147
148
149
			err = 0;
		}
	}
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
150
151
	if (err) {
		kfree(ld);
Alan Cox's avatar
Alan Cox committed
152
		return ERR_PTR(err);
153
	}
Alan Cox's avatar
Alan Cox committed
154
	return ld;
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
}

/**
 *	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
170
static struct tty_ldisc *tty_ldisc_get(int disc)
171
{
Alan Cox's avatar
Alan Cox committed
172
	struct tty_ldisc *ld;
173
174

	if (disc < N_TTY || disc >= NR_LDISCS)
Alan Cox's avatar
Alan Cox committed
175
176
177
		return ERR_PTR(-EINVAL);
	ld = tty_ldisc_try_get(disc);
	if (IS_ERR(ld)) {
178
		request_module("tty-ldisc-%d", disc);
Alan Cox's avatar
Alan Cox committed
179
		ld = tty_ldisc_try_get(disc);
180
	}
Alan Cox's avatar
Alan Cox committed
181
	return ld;
182
183
184
185
}

/**
 *	tty_ldisc_put		-	drop ldisc reference
Alan Cox's avatar
Alan Cox committed
186
 *	@ld: ldisc
187
188
 *
 *	Drop a reference to a line discipline. Manage refcounts and
Alan Cox's avatar
Alan Cox committed
189
 *	module usage counts. Free the ldisc once the recount hits zero.
190
191
192
193
194
 *
 *	Locking:
 *		takes tty_ldisc_lock to guard against ldisc races
 */

Alan Cox's avatar
Alan Cox committed
195
static void tty_ldisc_put(struct tty_ldisc *ld)
196
197
{
	unsigned long flags;
Alan Cox's avatar
Alan Cox committed
198
199
	int disc = ld->ops->num;
	struct tty_ldisc_ops *ldo;
200
201
202
203

	BUG_ON(disc < N_TTY || disc >= NR_LDISCS);

	spin_lock_irqsave(&tty_ldisc_lock, flags);
Alan Cox's avatar
Alan Cox committed
204
205
206
207
	ldo = tty_ldiscs[disc];
	BUG_ON(ldo->refcount == 0);
	ldo->refcount--;
	module_put(ldo->owner);
208
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
209
	WARN_ON(atomic_read(&ld->users));
Alan Cox's avatar
Alan Cox committed
210
	kfree(ld);
211
212
}

Alan Cox's avatar
Alan Cox committed
213
static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
214
215
216
217
{
	return (*pos < NR_LDISCS) ? pos : NULL;
}

Alan Cox's avatar
Alan Cox committed
218
static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
219
220
221
222
223
224
225
226
227
228
229
230
{
	(*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;
Alan Cox's avatar
Alan Cox committed
231
	struct tty_ldisc *ld;
Alan Cox's avatar
Alan Cox committed
232

Alan Cox's avatar
Alan Cox committed
233
234
	ld = tty_ldisc_try_get(i);
	if (IS_ERR(ld))
235
		return 0;
Alan Cox's avatar
Alan Cox committed
236
237
	seq_printf(m, "%-10s %2d\n", ld->ops->name ? ld->ops->name : "???", i);
	tty_ldisc_put(ld);
238
239
240
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
	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
267
 *	ldisc must have a reference count above zero to ensure it remains.
268
269
270
271
272
273
274
275
 *	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
276
	tty->ldisc = ld;
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
}

/**
 *	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
 */

static int tty_ldisc_try(struct tty_struct *tty)
{
	unsigned long flags;
	struct tty_ldisc *ld;
	int ret = 0;

	spin_lock_irqsave(&tty_ldisc_lock, flags);
Alan Cox's avatar
Alan Cox committed
298
	ld = tty->ldisc;
299
	if (test_bit(TTY_LDISC, &tty->flags)) {
300
		atomic_inc(&ld->users);
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
		ret = 1;
	}
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
	return ret;
}

/**
 *	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)
{
	/* wait_event is a macro */
	wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
327
	WARN_ON(atomic_read(&tty->ldisc->users) == 0);
Alan Cox's avatar
Alan Cox committed
328
	return tty->ldisc;
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
}
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)
{
	if (tty_ldisc_try(tty))
Alan Cox's avatar
Alan Cox committed
346
		return tty->ldisc;
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
	return NULL;
}
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)
{
	unsigned long flags;

	BUG_ON(ld == NULL);

	spin_lock_irqsave(&tty_ldisc_lock, flags);
368
	if (atomic_read(&ld->users) == 0)
369
		printk(KERN_ERR "tty_ldisc_deref: no references.\n");
370
	else if (atomic_dec_and_test(&ld->users))
371
372
373
374
375
376
377
378
379
380
		wake_up(&tty_ldisc_wait);
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
}
EXPORT_SYMBOL_GPL(tty_ldisc_deref);

/**
 *	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
381
382
 *	again. Do necessary wakeups for existing sleepers. Clear the LDISC
 *	changing flag to indicate any ldisc change is now over.
383
 *
Alan Cox's avatar
Alan Cox committed
384
385
 *	Note: nobody should set the TTY_LDISC bit except via this function.
 *	Clearing directly is allowed.
386
387
388
389
390
 */

void tty_ldisc_enable(struct tty_struct *tty)
{
	set_bit(TTY_LDISC, &tty->flags);
Alan Cox's avatar
Alan Cox committed
391
	clear_bit(TTY_LDISC_CHANGING, &tty->flags);
392
393
394
	wake_up(&tty_ldisc_wait);
}

Alan Cox's avatar
Alan Cox committed
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
/**
 *	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);

415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
/**
 *	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);
	tty->termios->c_line = num;
	mutex_unlock(&tty->termios_mutex);
}

Alan Cox's avatar
Alan Cox committed
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
/**
 *	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.
 */

static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
{
	WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
	if (ld->ops->open)
		return ld->ops->open(tty);
	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);
}
467
468
469
470
471
472
473
474
475
476
477
478
479

/**
 *	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
480
481
	struct tty_ldisc *new_ldisc;
	int r;
482
483

	/* There is an outstanding reference here so this is safe */
Alan Cox's avatar
Alan Cox committed
484
485
	old = tty_ldisc_get(old->ops->num);
	WARN_ON(IS_ERR(old));
486
487
	tty_ldisc_assign(tty, old);
	tty_set_termios_ldisc(tty, old->ops->num);
Alan Cox's avatar
Alan Cox committed
488
489
	if (tty_ldisc_open(tty, old) < 0) {
		tty_ldisc_put(old);
490
		/* This driver is always present */
Alan Cox's avatar
Alan Cox committed
491
		new_ldisc = tty_ldisc_get(N_TTY);
Alan Cox's avatar
Alan Cox committed
492
		if (IS_ERR(new_ldisc))
493
			panic("n_tty: get");
Alan Cox's avatar
Alan Cox committed
494
		tty_ldisc_assign(tty, new_ldisc);
495
		tty_set_termios_ldisc(tty, N_TTY);
Alan Cox's avatar
Alan Cox committed
496
497
498
499
500
		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);
501
502
503
	}
}

504
/**
Alan Cox's avatar
Alan Cox committed
505
 *	tty_ldisc_halt		-	shut down the line discipline
506
507
508
509
510
511
512
 *	@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.
 *
Alan Cox's avatar
Alan Cox committed
513
 *	In order to wait for any existing references to complete see
514
515
516
 *	tty_ldisc_wait_idle.
 */

Alan Cox's avatar
Alan Cox committed
517
static int tty_ldisc_halt(struct tty_struct *tty)
518
519
{
	clear_bit(TTY_LDISC, &tty->flags);
Alan Cox's avatar
Alan Cox committed
520
	return cancel_delayed_work(&tty->buf.work);
521
522
523
524
525
526
527
528
529
}

/**
 *	tty_ldisc_wait_idle	-	wait for the ldisc to become idle
 *	@tty: tty to wait for
 *
 *	Wait for the line discipline to become idle. The discipline must
 *	have been halted for this to guarantee it remains idle.
 *
Alan Cox's avatar
Alan Cox committed
530
 *	tty_ldisc_lock protects the ref counts currently.
531
532
 */

Alan Cox's avatar
Alan Cox committed
533
static int tty_ldisc_wait_idle(struct tty_struct *tty)
534
535
536
{
	unsigned long flags;
	spin_lock_irqsave(&tty_ldisc_lock, flags);
537
	while (atomic_read(&tty->ldisc->users)) {
538
		spin_unlock_irqrestore(&tty_ldisc_lock, flags);
Alan Cox's avatar
Alan Cox committed
539
		if (wait_event_timeout(tty_ldisc_wait,
540
				atomic_read(&tty->ldisc->users) == 0, 5 * HZ) == 0)
Alan Cox's avatar
Alan Cox committed
541
			return -EBUSY;
542
543
544
		spin_lock_irqsave(&tty_ldisc_lock, flags);
	}
	spin_unlock_irqrestore(&tty_ldisc_lock, flags);
Alan Cox's avatar
Alan Cox committed
545
	return 0;
546
547
}

548
549
550
551
552
553
/**
 *	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
554
555
556
 *	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.
557
 *
Alan Cox's avatar
Alan Cox committed
558
 *	Locking: takes tty_ldisc_lock, termios_mutex
559
560
561
562
563
 */

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

Alan Cox's avatar
Alan Cox committed
568
569
570
	new_ldisc = tty_ldisc_get(ldisc);
	if (IS_ERR(new_ldisc))
		return PTR_ERR(new_ldisc);
571
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
585
	/*
	 *	Check the no-op case
	 */

	if (tty->ldisc->ops->num == ldisc) {
		tty_ldisc_put(new_ldisc);
586
587
588
		return 0;
	}

Alan Cox's avatar
Alan Cox committed
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
	/*
	 *	Problem: What do we do if this blocks ?
	 *	We could deadlock here
	 */

	tty_wait_until_sent(tty, 0);

	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);
		wait_event(tty_ldisc_wait,
			test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0);
		mutex_lock(&tty->ldisc_mutex);
	}
	set_bit(TTY_LDISC_CHANGING, &tty->flags);
Alan Cox's avatar
Alan Cox committed
610

611
612
613
614
615
616
617
618
619
620
621
622
623
	/*
	 *	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;
	/*
	 *	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
624
625
626
627
	 *
	 *	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.
628
629
	 */

Alan Cox's avatar
Alan Cox committed
630
	work = tty_ldisc_halt(tty);
631
	if (o_tty)
Alan Cox's avatar
Alan Cox committed
632
		o_work = tty_ldisc_halt(o_tty);
633
634

	/*
Alan Cox's avatar
Alan Cox committed
635
636
	 * Wait for ->hangup_work and ->buf.work handlers to terminate.
	 * We must drop the mutex here in case a hangup is also in process.
637
	 */
Alan Cox's avatar
Alan Cox committed
638
639
640

	mutex_unlock(&tty->ldisc_mutex);

641
	flush_scheduled_work();
Alan Cox's avatar
Alan Cox committed
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660

	/* Let any existing reference holders finish */
	retval = tty_ldisc_wait_idle(tty);
	if (retval < 0) {
		clear_bit(TTY_LDISC_CHANGING, &tty->flags);
		tty_ldisc_put(new_ldisc);
		return retval;
	}

	mutex_lock(&tty->ldisc_mutex);
	if (test_bit(TTY_HUPPED, &tty->flags)) {
		/* 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);
		return -EIO;
	}

661
	/* Shutdown the current discipline. */
Alan Cox's avatar
Alan Cox committed
662
	tty_ldisc_close(tty, o_ldisc);
663
664

	/* Now set up the new line discipline. */
Alan Cox's avatar
Alan Cox committed
665
	tty_ldisc_assign(tty, new_ldisc);
666
	tty_set_termios_ldisc(tty, ldisc);
Alan Cox's avatar
Alan Cox committed
667
668

	retval = tty_ldisc_open(tty, new_ldisc);
669
	if (retval < 0) {
Alan Cox's avatar
Alan Cox committed
670
671
672
		/* Back to the old one or N_TTY if we can't */
		tty_ldisc_put(new_ldisc);
		tty_ldisc_restore(tty, o_ldisc);
673
	}
Alan Cox's avatar
Alan Cox committed
674

675
676
677
678
	/* 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
679
	if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc)
680
681
		tty->ops->set_ldisc(tty);

Alan Cox's avatar
Alan Cox committed
682
	tty_ldisc_put(o_ldisc);
683
684

	/*
Alan Cox's avatar
Alan Cox committed
685
	 *	Allow ldisc referencing to occur again
686
687
688
689
690
691
	 */

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

Alan Cox's avatar
Alan Cox committed
692
	/* Restart the work queue in case no characters kick it off. Safe if
693
694
695
	   already running */
	if (work)
		schedule_delayed_work(&tty->buf.work, 1);
Alan Cox's avatar
Alan Cox committed
696
697
698
	if (o_work)
		schedule_delayed_work(&o_tty->buf.work, 1);
	mutex_unlock(&tty->ldisc_mutex);
699
700
701
	return retval;
}

Alan Cox's avatar
Alan Cox committed
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
/**
 *	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);
	*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);
	mutex_unlock(&tty->termios_mutex);
}


/**
 *	tty_ldisc_reinit	-	reinitialise the tty ldisc
 *	@tty: tty to reinit
 *
 *	Switch the tty back to N_TTY line discipline and leave the
 *	ldisc state closed
 */

static void tty_ldisc_reinit(struct tty_struct *tty)
{
	struct tty_ldisc *ld;

	tty_ldisc_close(tty, tty->ldisc);
	tty_ldisc_put(tty->ldisc);
	tty->ldisc = NULL;
	/*
	 *	Switch the line discipline back
	 */
	ld = tty_ldisc_get(N_TTY);
	BUG_ON(IS_ERR(ld));
	tty_ldisc_assign(tty, ld);
	tty_set_termios_ldisc(tty, N_TTY);
}

/**
 *	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;

	/*
	 * 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
	 * N_TTY.
	 */
	if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
Alan Cox's avatar
Alan Cox committed
791
		/* Avoid racing set_ldisc or tty_ldisc_release */
Alan Cox's avatar
Alan Cox committed
792
		mutex_lock(&tty->ldisc_mutex);
Alan Cox's avatar
Alan Cox committed
793
794
795
796
797
798
799
800
801
802
803
804
		if (tty->ldisc) {	/* Not yet closed */
			/* Switch back to N_TTY */
			tty_ldisc_halt(tty);
			tty_ldisc_wait_idle(tty);
			tty_ldisc_reinit(tty);
			/* 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 */
			WARN_ON(tty_ldisc_open(tty, tty->ldisc));
			tty_ldisc_enable(tty);
		}
Alan Cox's avatar
Alan Cox committed
805
806
807
808
		mutex_unlock(&tty->ldisc_mutex);
		tty_reset_termios(tty);
	}
}
809
810
811
812
813
814
815

/**
 *	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
816
817
 *	line disciplines and bind them to the tty. This has no locking issues
 *	as the device isn't yet active.
818
819
820
821
 */

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

Alan Cox's avatar
Alan Cox committed
825
826
827
828
829
830
	retval = tty_ldisc_open(tty, ld);
	if (retval)
		return retval;

	if (o_tty) {
		retval = tty_ldisc_open(o_tty, o_tty->ldisc);
831
		if (retval) {
Alan Cox's avatar
Alan Cox committed
832
			tty_ldisc_close(tty, ld);
833
834
835
836
837
838
839
840
841
842
843
844
			return retval;
		}
		tty_ldisc_enable(o_tty);
	}
	tty_ldisc_enable(tty);
	return 0;
}
/**
 *	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
845
846
 *	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
847
 *	ldisc has not been opened.
848
849
850
851
852
853
854
855
856
857
 */

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.
	 */

858
	tty_ldisc_halt(tty);
Alan Cox's avatar
Alan Cox committed
859
	flush_scheduled_work();
860
861
862
863
864
865

	/*
	 * Wait for any short term users (we know they are just driver
	 * side waiters as the file is closing so user count on the file
	 * side is zero.
	 */
866
867
868

	tty_ldisc_wait_idle(tty);

Alan Cox's avatar
Alan Cox committed
869
	mutex_lock(&tty->ldisc_mutex);
870
	/*
871
	 * Now kill off the ldisc
872
	 */
873
874
875
876
877
878
879
	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);
Alan Cox's avatar
Alan Cox committed
880
	mutex_unlock(&tty->ldisc_mutex);
881

Alan Cox's avatar
Alan Cox committed
882
883
884
	/* This will need doing differently if we need to lock */
	if (o_tty)
		tty_ldisc_release(o_tty, NULL);
885
886
887

	/* And the memory resources remaining (buffers, termios) will be
	   disposed of when the kref hits zero */
888
889
890
891
892
893
894
895
896
897
898
899
}

/**
 *	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
900
901
	struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
	if (IS_ERR(ld))
902
		panic("n_tty: init_tty");
Alan Cox's avatar
Alan Cox committed
903
	tty_ldisc_assign(tty, ld);
904
905
906
907
908
909
910
}

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