Loading...
1#include <linux/types.h>
2#include <linux/major.h>
3#include <linux/errno.h>
4#include <linux/signal.h>
5#include <linux/fcntl.h>
6#include <linux/sched.h>
7#include <linux/interrupt.h>
8#include <linux/tty.h>
9#include <linux/tty_driver.h>
10#include <linux/tty_flip.h>
11#include <linux/devpts_fs.h>
12#include <linux/file.h>
13#include <linux/console.h>
14#include <linux/timer.h>
15#include <linux/ctype.h>
16#include <linux/kd.h>
17#include <linux/mm.h>
18#include <linux/string.h>
19#include <linux/slab.h>
20#include <linux/poll.h>
21#include <linux/proc_fs.h>
22#include <linux/init.h>
23#include <linux/module.h>
24#include <linux/device.h>
25#include <linux/wait.h>
26#include <linux/bitops.h>
27#include <linux/delay.h>
28#include <linux/seq_file.h>
29
30#include <linux/uaccess.h>
31#include <asm/system.h>
32
33#include <linux/kbd_kern.h>
34#include <linux/vt_kern.h>
35#include <linux/selection.h>
36
37#include <linux/kmod.h>
38#include <linux/nsproxy.h>
39
40/*
41 * This guards the refcounted line discipline lists. The lock
42 * must be taken with irqs off because there are hangup path
43 * callers who will do ldisc lookups and cannot sleep.
44 */
45
46static DEFINE_SPINLOCK(tty_ldisc_lock);
47static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
48static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_idle);
49/* Line disc dispatch table */
50static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
51
52static inline struct tty_ldisc *get_ldisc(struct tty_ldisc *ld)
53{
54 if (ld)
55 atomic_inc(&ld->users);
56 return ld;
57}
58
59static void put_ldisc(struct tty_ldisc *ld)
60{
61 unsigned long flags;
62
63 if (WARN_ON_ONCE(!ld))
64 return;
65
66 /*
67 * If this is the last user, free the ldisc, and
68 * release the ldisc ops.
69 *
70 * We really want an "atomic_dec_and_lock_irqsave()",
71 * but we don't have it, so this does it by hand.
72 */
73 local_irq_save(flags);
74 if (atomic_dec_and_lock(&ld->users, &tty_ldisc_lock)) {
75 struct tty_ldisc_ops *ldo = ld->ops;
76
77 ldo->refcount--;
78 module_put(ldo->owner);
79 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
80
81 kfree(ld);
82 return;
83 }
84 local_irq_restore(flags);
85 wake_up(&tty_ldisc_idle);
86}
87
88/**
89 * tty_register_ldisc - install a line discipline
90 * @disc: ldisc number
91 * @new_ldisc: pointer to the ldisc object
92 *
93 * Installs a new line discipline into the kernel. The discipline
94 * is set up as unreferenced and then made available to the kernel
95 * from this point onwards.
96 *
97 * Locking:
98 * takes tty_ldisc_lock to guard against ldisc races
99 */
100
101int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
102{
103 unsigned long flags;
104 int ret = 0;
105
106 if (disc < N_TTY || disc >= NR_LDISCS)
107 return -EINVAL;
108
109 spin_lock_irqsave(&tty_ldisc_lock, flags);
110 tty_ldiscs[disc] = new_ldisc;
111 new_ldisc->num = disc;
112 new_ldisc->refcount = 0;
113 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
114
115 return ret;
116}
117EXPORT_SYMBOL(tty_register_ldisc);
118
119/**
120 * tty_unregister_ldisc - unload a line discipline
121 * @disc: ldisc number
122 * @new_ldisc: pointer to the ldisc object
123 *
124 * Remove a line discipline from the kernel providing it is not
125 * currently in use.
126 *
127 * Locking:
128 * takes tty_ldisc_lock to guard against ldisc races
129 */
130
131int tty_unregister_ldisc(int disc)
132{
133 unsigned long flags;
134 int ret = 0;
135
136 if (disc < N_TTY || disc >= NR_LDISCS)
137 return -EINVAL;
138
139 spin_lock_irqsave(&tty_ldisc_lock, flags);
140 if (tty_ldiscs[disc]->refcount)
141 ret = -EBUSY;
142 else
143 tty_ldiscs[disc] = NULL;
144 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
145
146 return ret;
147}
148EXPORT_SYMBOL(tty_unregister_ldisc);
149
150static struct tty_ldisc_ops *get_ldops(int disc)
151{
152 unsigned long flags;
153 struct tty_ldisc_ops *ldops, *ret;
154
155 spin_lock_irqsave(&tty_ldisc_lock, flags);
156 ret = ERR_PTR(-EINVAL);
157 ldops = tty_ldiscs[disc];
158 if (ldops) {
159 ret = ERR_PTR(-EAGAIN);
160 if (try_module_get(ldops->owner)) {
161 ldops->refcount++;
162 ret = ldops;
163 }
164 }
165 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
166 return ret;
167}
168
169static void put_ldops(struct tty_ldisc_ops *ldops)
170{
171 unsigned long flags;
172
173 spin_lock_irqsave(&tty_ldisc_lock, flags);
174 ldops->refcount--;
175 module_put(ldops->owner);
176 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
177}
178
179/**
180 * tty_ldisc_get - take a reference to an ldisc
181 * @disc: ldisc number
182 *
183 * Takes a reference to a line discipline. Deals with refcounts and
184 * module locking counts. Returns NULL if the discipline is not available.
185 * Returns a pointer to the discipline and bumps the ref count if it is
186 * available
187 *
188 * Locking:
189 * takes tty_ldisc_lock to guard against ldisc races
190 */
191
192static struct tty_ldisc *tty_ldisc_get(int disc)
193{
194 struct tty_ldisc *ld;
195 struct tty_ldisc_ops *ldops;
196
197 if (disc < N_TTY || disc >= NR_LDISCS)
198 return ERR_PTR(-EINVAL);
199
200 /*
201 * Get the ldisc ops - we may need to request them to be loaded
202 * dynamically and try again.
203 */
204 ldops = get_ldops(disc);
205 if (IS_ERR(ldops)) {
206 request_module("tty-ldisc-%d", disc);
207 ldops = get_ldops(disc);
208 if (IS_ERR(ldops))
209 return ERR_CAST(ldops);
210 }
211
212 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
213 if (ld == NULL) {
214 put_ldops(ldops);
215 return ERR_PTR(-ENOMEM);
216 }
217
218 ld->ops = ldops;
219 atomic_set(&ld->users, 1);
220 return ld;
221}
222
223static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
224{
225 return (*pos < NR_LDISCS) ? pos : NULL;
226}
227
228static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
229{
230 (*pos)++;
231 return (*pos < NR_LDISCS) ? pos : NULL;
232}
233
234static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
235{
236}
237
238static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
239{
240 int i = *(loff_t *)v;
241 struct tty_ldisc_ops *ldops;
242
243 ldops = get_ldops(i);
244 if (IS_ERR(ldops))
245 return 0;
246 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
247 put_ldops(ldops);
248 return 0;
249}
250
251static const struct seq_operations tty_ldiscs_seq_ops = {
252 .start = tty_ldiscs_seq_start,
253 .next = tty_ldiscs_seq_next,
254 .stop = tty_ldiscs_seq_stop,
255 .show = tty_ldiscs_seq_show,
256};
257
258static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
259{
260 return seq_open(file, &tty_ldiscs_seq_ops);
261}
262
263const struct file_operations tty_ldiscs_proc_fops = {
264 .owner = THIS_MODULE,
265 .open = proc_tty_ldiscs_open,
266 .read = seq_read,
267 .llseek = seq_lseek,
268 .release = seq_release,
269};
270
271/**
272 * tty_ldisc_assign - set ldisc on a tty
273 * @tty: tty to assign
274 * @ld: line discipline
275 *
276 * Install an instance of a line discipline into a tty structure. The
277 * ldisc must have a reference count above zero to ensure it remains.
278 * The tty instance refcount starts at zero.
279 *
280 * Locking:
281 * Caller must hold references
282 */
283
284static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
285{
286 tty->ldisc = ld;
287}
288
289/**
290 * tty_ldisc_try - internal helper
291 * @tty: the tty
292 *
293 * Make a single attempt to grab and bump the refcount on
294 * the tty ldisc. Return 0 on failure or 1 on success. This is
295 * used to implement both the waiting and non waiting versions
296 * of tty_ldisc_ref
297 *
298 * Locking: takes tty_ldisc_lock
299 */
300
301static struct tty_ldisc *tty_ldisc_try(struct tty_struct *tty)
302{
303 unsigned long flags;
304 struct tty_ldisc *ld;
305
306 spin_lock_irqsave(&tty_ldisc_lock, flags);
307 ld = NULL;
308 if (test_bit(TTY_LDISC, &tty->flags))
309 ld = get_ldisc(tty->ldisc);
310 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
311 return ld;
312}
313
314/**
315 * tty_ldisc_ref_wait - wait for the tty ldisc
316 * @tty: tty device
317 *
318 * Dereference the line discipline for the terminal and take a
319 * reference to it. If the line discipline is in flux then
320 * wait patiently until it changes.
321 *
322 * Note: Must not be called from an IRQ/timer context. The caller
323 * must also be careful not to hold other locks that will deadlock
324 * against a discipline change, such as an existing ldisc reference
325 * (which we check for)
326 *
327 * Locking: call functions take tty_ldisc_lock
328 */
329
330struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
331{
332 struct tty_ldisc *ld;
333
334 /* wait_event is a macro */
335 wait_event(tty_ldisc_wait, (ld = tty_ldisc_try(tty)) != NULL);
336 return ld;
337}
338EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
339
340/**
341 * tty_ldisc_ref - get the tty ldisc
342 * @tty: tty device
343 *
344 * Dereference the line discipline for the terminal and take a
345 * reference to it. If the line discipline is in flux then
346 * return NULL. Can be called from IRQ and timer functions.
347 *
348 * Locking: called functions take tty_ldisc_lock
349 */
350
351struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
352{
353 return tty_ldisc_try(tty);
354}
355EXPORT_SYMBOL_GPL(tty_ldisc_ref);
356
357/**
358 * tty_ldisc_deref - free a tty ldisc reference
359 * @ld: reference to free up
360 *
361 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
362 * be called in IRQ context.
363 *
364 * Locking: takes tty_ldisc_lock
365 */
366
367void tty_ldisc_deref(struct tty_ldisc *ld)
368{
369 put_ldisc(ld);
370}
371EXPORT_SYMBOL_GPL(tty_ldisc_deref);
372
373static inline void tty_ldisc_put(struct tty_ldisc *ld)
374{
375 put_ldisc(ld);
376}
377
378/**
379 * tty_ldisc_enable - allow ldisc use
380 * @tty: terminal to activate ldisc on
381 *
382 * Set the TTY_LDISC flag when the line discipline can be called
383 * again. Do necessary wakeups for existing sleepers. Clear the LDISC
384 * changing flag to indicate any ldisc change is now over.
385 *
386 * Note: nobody should set the TTY_LDISC bit except via this function.
387 * Clearing directly is allowed.
388 */
389
390void tty_ldisc_enable(struct tty_struct *tty)
391{
392 set_bit(TTY_LDISC, &tty->flags);
393 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
394 wake_up(&tty_ldisc_wait);
395}
396
397/**
398 * tty_ldisc_flush - flush line discipline queue
399 * @tty: tty
400 *
401 * Flush the line discipline queue (if any) for this tty. If there
402 * is no line discipline active this is a no-op.
403 */
404
405void tty_ldisc_flush(struct tty_struct *tty)
406{
407 struct tty_ldisc *ld = tty_ldisc_ref(tty);
408 if (ld) {
409 if (ld->ops->flush_buffer)
410 ld->ops->flush_buffer(tty);
411 tty_ldisc_deref(ld);
412 }
413 tty_buffer_flush(tty);
414}
415EXPORT_SYMBOL_GPL(tty_ldisc_flush);
416
417/**
418 * tty_set_termios_ldisc - set ldisc field
419 * @tty: tty structure
420 * @num: line discipline number
421 *
422 * This is probably overkill for real world processors but
423 * they are not on hot paths so a little discipline won't do
424 * any harm.
425 *
426 * Locking: takes termios_mutex
427 */
428
429static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
430{
431 mutex_lock(&tty->termios_mutex);
432 tty->termios->c_line = num;
433 mutex_unlock(&tty->termios_mutex);
434}
435
436/**
437 * tty_ldisc_open - open a line discipline
438 * @tty: tty we are opening the ldisc on
439 * @ld: discipline to open
440 *
441 * A helper opening method. Also a convenient debugging and check
442 * point.
443 *
444 * Locking: always called with BTM already held.
445 */
446
447static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
448{
449 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
450 if (ld->ops->open) {
451 int ret;
452 /* BTM here locks versus a hangup event */
453 WARN_ON(!tty_locked());
454 ret = ld->ops->open(tty);
455 if (ret)
456 clear_bit(TTY_LDISC_OPEN, &tty->flags);
457 return ret;
458 }
459 return 0;
460}
461
462/**
463 * tty_ldisc_close - close a line discipline
464 * @tty: tty we are opening the ldisc on
465 * @ld: discipline to close
466 *
467 * A helper close method. Also a convenient debugging and check
468 * point.
469 */
470
471static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
472{
473 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
474 clear_bit(TTY_LDISC_OPEN, &tty->flags);
475 if (ld->ops->close)
476 ld->ops->close(tty);
477}
478
479/**
480 * tty_ldisc_restore - helper for tty ldisc change
481 * @tty: tty to recover
482 * @old: previous ldisc
483 *
484 * Restore the previous line discipline or N_TTY when a line discipline
485 * change fails due to an open error
486 */
487
488static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
489{
490 char buf[64];
491 struct tty_ldisc *new_ldisc;
492 int r;
493
494 /* There is an outstanding reference here so this is safe */
495 old = tty_ldisc_get(old->ops->num);
496 WARN_ON(IS_ERR(old));
497 tty_ldisc_assign(tty, old);
498 tty_set_termios_ldisc(tty, old->ops->num);
499 if (tty_ldisc_open(tty, old) < 0) {
500 tty_ldisc_put(old);
501 /* This driver is always present */
502 new_ldisc = tty_ldisc_get(N_TTY);
503 if (IS_ERR(new_ldisc))
504 panic("n_tty: get");
505 tty_ldisc_assign(tty, new_ldisc);
506 tty_set_termios_ldisc(tty, N_TTY);
507 r = tty_ldisc_open(tty, new_ldisc);
508 if (r < 0)
509 panic("Couldn't open N_TTY ldisc for "
510 "%s --- error %d.",
511 tty_name(tty, buf), r);
512 }
513}
514
515/**
516 * tty_ldisc_halt - shut down the line discipline
517 * @tty: tty device
518 *
519 * Shut down the line discipline and work queue for this tty device.
520 * The TTY_LDISC flag being cleared ensures no further references can
521 * be obtained while the delayed work queue halt ensures that no more
522 * data is fed to the ldisc.
523 *
524 * You need to do a 'flush_scheduled_work()' (outside the ldisc_mutex)
525 * in order to make sure any currently executing ldisc work is also
526 * flushed.
527 */
528
529static int tty_ldisc_halt(struct tty_struct *tty)
530{
531 clear_bit(TTY_LDISC, &tty->flags);
532 return cancel_work_sync(&tty->buf.work);
533}
534
535/**
536 * tty_ldisc_flush_works - flush all works of a tty
537 * @tty: tty device to flush works for
538 *
539 * Sync flush all works belonging to @tty.
540 */
541static void tty_ldisc_flush_works(struct tty_struct *tty)
542{
543 flush_work_sync(&tty->hangup_work);
544 flush_work_sync(&tty->SAK_work);
545 flush_work_sync(&tty->buf.work);
546}
547
548/**
549 * tty_ldisc_wait_idle - wait for the ldisc to become idle
550 * @tty: tty to wait for
551 *
552 * Wait for the line discipline to become idle. The discipline must
553 * have been halted for this to guarantee it remains idle.
554 */
555static int tty_ldisc_wait_idle(struct tty_struct *tty)
556{
557 int ret;
558 ret = wait_event_timeout(tty_ldisc_idle,
559 atomic_read(&tty->ldisc->users) == 1, 5 * HZ);
560 if (ret < 0)
561 return ret;
562 return ret > 0 ? 0 : -EBUSY;
563}
564
565/**
566 * tty_set_ldisc - set line discipline
567 * @tty: the terminal to set
568 * @ldisc: the line discipline
569 *
570 * Set the discipline of a tty line. Must be called from a process
571 * context. The ldisc change logic has to protect itself against any
572 * overlapping ldisc change (including on the other end of pty pairs),
573 * the close of one side of a tty/pty pair, and eventually hangup.
574 *
575 * Locking: takes tty_ldisc_lock, termios_mutex
576 */
577
578int tty_set_ldisc(struct tty_struct *tty, int ldisc)
579{
580 int retval;
581 struct tty_ldisc *o_ldisc, *new_ldisc;
582 int work, o_work = 0;
583 struct tty_struct *o_tty;
584
585 new_ldisc = tty_ldisc_get(ldisc);
586 if (IS_ERR(new_ldisc))
587 return PTR_ERR(new_ldisc);
588
589 tty_lock();
590 /*
591 * We need to look at the tty locking here for pty/tty pairs
592 * when both sides try to change in parallel.
593 */
594
595 o_tty = tty->link; /* o_tty is the pty side or NULL */
596
597
598 /*
599 * Check the no-op case
600 */
601
602 if (tty->ldisc->ops->num == ldisc) {
603 tty_unlock();
604 tty_ldisc_put(new_ldisc);
605 return 0;
606 }
607
608 tty_unlock();
609 /*
610 * Problem: What do we do if this blocks ?
611 * We could deadlock here
612 */
613
614 tty_wait_until_sent(tty, 0);
615
616 tty_lock();
617 mutex_lock(&tty->ldisc_mutex);
618
619 /*
620 * We could be midstream of another ldisc change which has
621 * dropped the lock during processing. If so we need to wait.
622 */
623
624 while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
625 mutex_unlock(&tty->ldisc_mutex);
626 tty_unlock();
627 wait_event(tty_ldisc_wait,
628 test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0);
629 tty_lock();
630 mutex_lock(&tty->ldisc_mutex);
631 }
632
633 set_bit(TTY_LDISC_CHANGING, &tty->flags);
634
635 /*
636 * No more input please, we are switching. The new ldisc
637 * will update this value in the ldisc open function
638 */
639
640 tty->receive_room = 0;
641
642 o_ldisc = tty->ldisc;
643
644 tty_unlock();
645 /*
646 * Make sure we don't change while someone holds a
647 * reference to the line discipline. The TTY_LDISC bit
648 * prevents anyone taking a reference once it is clear.
649 * We need the lock to avoid racing reference takers.
650 *
651 * We must clear the TTY_LDISC bit here to avoid a livelock
652 * with a userspace app continually trying to use the tty in
653 * parallel to the change and re-referencing the tty.
654 */
655
656 work = tty_ldisc_halt(tty);
657 if (o_tty)
658 o_work = tty_ldisc_halt(o_tty);
659
660 /*
661 * Wait for ->hangup_work and ->buf.work handlers to terminate.
662 * We must drop the mutex here in case a hangup is also in process.
663 */
664
665 mutex_unlock(&tty->ldisc_mutex);
666
667 tty_ldisc_flush_works(tty);
668
669 retval = tty_ldisc_wait_idle(tty);
670
671 tty_lock();
672 mutex_lock(&tty->ldisc_mutex);
673
674 /* handle wait idle failure locked */
675 if (retval) {
676 tty_ldisc_put(new_ldisc);
677 goto enable;
678 }
679
680 if (test_bit(TTY_HUPPED, &tty->flags)) {
681 /* We were raced by the hangup method. It will have stomped
682 the ldisc data and closed the ldisc down */
683 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
684 mutex_unlock(&tty->ldisc_mutex);
685 tty_ldisc_put(new_ldisc);
686 tty_unlock();
687 return -EIO;
688 }
689
690 /* Shutdown the current discipline. */
691 tty_ldisc_close(tty, o_ldisc);
692
693 /* Now set up the new line discipline. */
694 tty_ldisc_assign(tty, new_ldisc);
695 tty_set_termios_ldisc(tty, ldisc);
696
697 retval = tty_ldisc_open(tty, new_ldisc);
698 if (retval < 0) {
699 /* Back to the old one or N_TTY if we can't */
700 tty_ldisc_put(new_ldisc);
701 tty_ldisc_restore(tty, o_ldisc);
702 }
703
704 /* At this point we hold a reference to the new ldisc and a
705 a reference to the old ldisc. If we ended up flipping back
706 to the existing ldisc we have two references to it */
707
708 if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc)
709 tty->ops->set_ldisc(tty);
710
711 tty_ldisc_put(o_ldisc);
712
713enable:
714 /*
715 * Allow ldisc referencing to occur again
716 */
717
718 tty_ldisc_enable(tty);
719 if (o_tty)
720 tty_ldisc_enable(o_tty);
721
722 /* Restart the work queue in case no characters kick it off. Safe if
723 already running */
724 if (work)
725 schedule_work(&tty->buf.work);
726 if (o_work)
727 schedule_work(&o_tty->buf.work);
728 mutex_unlock(&tty->ldisc_mutex);
729 tty_unlock();
730 return retval;
731}
732
733/**
734 * tty_reset_termios - reset terminal state
735 * @tty: tty to reset
736 *
737 * Restore a terminal to the driver default state.
738 */
739
740static void tty_reset_termios(struct tty_struct *tty)
741{
742 mutex_lock(&tty->termios_mutex);
743 *tty->termios = tty->driver->init_termios;
744 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
745 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
746 mutex_unlock(&tty->termios_mutex);
747}
748
749
750/**
751 * tty_ldisc_reinit - reinitialise the tty ldisc
752 * @tty: tty to reinit
753 * @ldisc: line discipline to reinitialize
754 *
755 * Switch the tty to a line discipline and leave the ldisc
756 * state closed
757 */
758
759static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
760{
761 struct tty_ldisc *ld = tty_ldisc_get(ldisc);
762
763 if (IS_ERR(ld))
764 return -1;
765
766 WARN_ON_ONCE(tty_ldisc_wait_idle(tty));
767
768 tty_ldisc_close(tty, tty->ldisc);
769 tty_ldisc_put(tty->ldisc);
770 tty->ldisc = NULL;
771 /*
772 * Switch the line discipline back
773 */
774 tty_ldisc_assign(tty, ld);
775 tty_set_termios_ldisc(tty, ldisc);
776
777 return 0;
778}
779
780/**
781 * tty_ldisc_hangup - hangup ldisc reset
782 * @tty: tty being hung up
783 *
784 * Some tty devices reset their termios when they receive a hangup
785 * event. In that situation we must also switch back to N_TTY properly
786 * before we reset the termios data.
787 *
788 * Locking: We can take the ldisc mutex as the rest of the code is
789 * careful to allow for this.
790 *
791 * In the pty pair case this occurs in the close() path of the
792 * tty itself so we must be careful about locking rules.
793 */
794
795void tty_ldisc_hangup(struct tty_struct *tty)
796{
797 struct tty_ldisc *ld;
798 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
799 int err = 0;
800
801 /*
802 * FIXME! What are the locking issues here? This may me overdoing
803 * things... This question is especially important now that we've
804 * removed the irqlock.
805 */
806 ld = tty_ldisc_ref(tty);
807 if (ld != NULL) {
808 /* We may have no line discipline at this point */
809 if (ld->ops->flush_buffer)
810 ld->ops->flush_buffer(tty);
811 tty_driver_flush_buffer(tty);
812 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
813 ld->ops->write_wakeup)
814 ld->ops->write_wakeup(tty);
815 if (ld->ops->hangup)
816 ld->ops->hangup(tty);
817 tty_ldisc_deref(ld);
818 }
819 /*
820 * FIXME: Once we trust the LDISC code better we can wait here for
821 * ldisc completion and fix the driver call race
822 */
823 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
824 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
825 /*
826 * Shutdown the current line discipline, and reset it to
827 * N_TTY if need be.
828 *
829 * Avoid racing set_ldisc or tty_ldisc_release
830 */
831 mutex_lock(&tty->ldisc_mutex);
832
833 /*
834 * this is like tty_ldisc_halt, but we need to give up
835 * the BTM before calling cancel_work_sync, which may
836 * need to wait for another function taking the BTM
837 */
838 clear_bit(TTY_LDISC, &tty->flags);
839 tty_unlock();
840 cancel_work_sync(&tty->buf.work);
841 mutex_unlock(&tty->ldisc_mutex);
842
843 tty_lock();
844 mutex_lock(&tty->ldisc_mutex);
845
846 /* At this point we have a closed ldisc and we want to
847 reopen it. We could defer this to the next open but
848 it means auditing a lot of other paths so this is
849 a FIXME */
850 if (tty->ldisc) { /* Not yet closed */
851 if (reset == 0) {
852
853 if (!tty_ldisc_reinit(tty, tty->termios->c_line))
854 err = tty_ldisc_open(tty, tty->ldisc);
855 else
856 err = 1;
857 }
858 /* If the re-open fails or we reset then go to N_TTY. The
859 N_TTY open cannot fail */
860 if (reset || err) {
861 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
862 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
863 }
864 tty_ldisc_enable(tty);
865 }
866 mutex_unlock(&tty->ldisc_mutex);
867 if (reset)
868 tty_reset_termios(tty);
869}
870
871/**
872 * tty_ldisc_setup - open line discipline
873 * @tty: tty being shut down
874 * @o_tty: pair tty for pty/tty pairs
875 *
876 * Called during the initial open of a tty/pty pair in order to set up the
877 * line disciplines and bind them to the tty. This has no locking issues
878 * as the device isn't yet active.
879 */
880
881int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
882{
883 struct tty_ldisc *ld = tty->ldisc;
884 int retval;
885
886 retval = tty_ldisc_open(tty, ld);
887 if (retval)
888 return retval;
889
890 if (o_tty) {
891 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
892 if (retval) {
893 tty_ldisc_close(tty, ld);
894 return retval;
895 }
896 tty_ldisc_enable(o_tty);
897 }
898 tty_ldisc_enable(tty);
899 return 0;
900}
901/**
902 * tty_ldisc_release - release line discipline
903 * @tty: tty being shut down
904 * @o_tty: pair tty for pty/tty pairs
905 *
906 * Called during the final close of a tty/pty pair in order to shut down
907 * the line discpline layer. On exit the ldisc assigned is N_TTY and the
908 * ldisc has not been opened.
909 */
910
911void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
912{
913 /*
914 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
915 * kill any delayed work. As this is the final close it does not
916 * race with the set_ldisc code path.
917 */
918
919 tty_unlock();
920 tty_ldisc_halt(tty);
921 tty_ldisc_flush_works(tty);
922 tty_lock();
923
924 mutex_lock(&tty->ldisc_mutex);
925 /*
926 * Now kill off the ldisc
927 */
928 tty_ldisc_close(tty, tty->ldisc);
929 tty_ldisc_put(tty->ldisc);
930 /* Force an oops if we mess this up */
931 tty->ldisc = NULL;
932
933 /* Ensure the next open requests the N_TTY ldisc */
934 tty_set_termios_ldisc(tty, N_TTY);
935 mutex_unlock(&tty->ldisc_mutex);
936
937 /* This will need doing differently if we need to lock */
938 if (o_tty)
939 tty_ldisc_release(o_tty, NULL);
940
941 /* And the memory resources remaining (buffers, termios) will be
942 disposed of when the kref hits zero */
943}
944
945/**
946 * tty_ldisc_init - ldisc setup for new tty
947 * @tty: tty being allocated
948 *
949 * Set up the line discipline objects for a newly allocated tty. Note that
950 * the tty structure is not completely set up when this call is made.
951 */
952
953void tty_ldisc_init(struct tty_struct *tty)
954{
955 struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
956 if (IS_ERR(ld))
957 panic("n_tty: init_tty");
958 tty_ldisc_assign(tty, ld);
959}
960
961/**
962 * tty_ldisc_init - ldisc cleanup for new tty
963 * @tty: tty that was allocated recently
964 *
965 * The tty structure must not becompletely set up (tty_ldisc_setup) when
966 * this call is made.
967 */
968void tty_ldisc_deinit(struct tty_struct *tty)
969{
970 put_ldisc(tty->ldisc);
971 tty_ldisc_assign(tty, NULL);
972}
973
974void tty_ldisc_begin(void)
975{
976 /* Setup the default TTY line discipline. */
977 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
978}
1#include <linux/types.h>
2#include <linux/errno.h>
3#include <linux/kmod.h>
4#include <linux/sched.h>
5#include <linux/interrupt.h>
6#include <linux/tty.h>
7#include <linux/tty_driver.h>
8#include <linux/file.h>
9#include <linux/mm.h>
10#include <linux/string.h>
11#include <linux/slab.h>
12#include <linux/poll.h>
13#include <linux/proc_fs.h>
14#include <linux/module.h>
15#include <linux/device.h>
16#include <linux/wait.h>
17#include <linux/bitops.h>
18#include <linux/seq_file.h>
19#include <linux/uaccess.h>
20#include <linux/ratelimit.h>
21
22#undef LDISC_DEBUG_HANGUP
23
24#ifdef LDISC_DEBUG_HANGUP
25#define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args)
26#else
27#define tty_ldisc_debug(tty, f, args...)
28#endif
29
30/* lockdep nested classes for tty->ldisc_sem */
31enum {
32 LDISC_SEM_NORMAL,
33 LDISC_SEM_OTHER,
34};
35
36
37/*
38 * This guards the refcounted line discipline lists. The lock
39 * must be taken with irqs off because there are hangup path
40 * callers who will do ldisc lookups and cannot sleep.
41 */
42
43static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
44/* Line disc dispatch table */
45static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
46
47/**
48 * tty_register_ldisc - install a line discipline
49 * @disc: ldisc number
50 * @new_ldisc: pointer to the ldisc object
51 *
52 * Installs a new line discipline into the kernel. The discipline
53 * is set up as unreferenced and then made available to the kernel
54 * from this point onwards.
55 *
56 * Locking:
57 * takes tty_ldiscs_lock to guard against ldisc races
58 */
59
60int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
61{
62 unsigned long flags;
63 int ret = 0;
64
65 if (disc < N_TTY || disc >= NR_LDISCS)
66 return -EINVAL;
67
68 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
69 tty_ldiscs[disc] = new_ldisc;
70 new_ldisc->num = disc;
71 new_ldisc->refcount = 0;
72 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
73
74 return ret;
75}
76EXPORT_SYMBOL(tty_register_ldisc);
77
78/**
79 * tty_unregister_ldisc - unload a line discipline
80 * @disc: ldisc number
81 * @new_ldisc: pointer to the ldisc object
82 *
83 * Remove a line discipline from the kernel providing it is not
84 * currently in use.
85 *
86 * Locking:
87 * takes tty_ldiscs_lock to guard against ldisc races
88 */
89
90int tty_unregister_ldisc(int disc)
91{
92 unsigned long flags;
93 int ret = 0;
94
95 if (disc < N_TTY || disc >= NR_LDISCS)
96 return -EINVAL;
97
98 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
99 if (tty_ldiscs[disc]->refcount)
100 ret = -EBUSY;
101 else
102 tty_ldiscs[disc] = NULL;
103 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
104
105 return ret;
106}
107EXPORT_SYMBOL(tty_unregister_ldisc);
108
109static struct tty_ldisc_ops *get_ldops(int disc)
110{
111 unsigned long flags;
112 struct tty_ldisc_ops *ldops, *ret;
113
114 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
115 ret = ERR_PTR(-EINVAL);
116 ldops = tty_ldiscs[disc];
117 if (ldops) {
118 ret = ERR_PTR(-EAGAIN);
119 if (try_module_get(ldops->owner)) {
120 ldops->refcount++;
121 ret = ldops;
122 }
123 }
124 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
125 return ret;
126}
127
128static void put_ldops(struct tty_ldisc_ops *ldops)
129{
130 unsigned long flags;
131
132 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
133 ldops->refcount--;
134 module_put(ldops->owner);
135 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
136}
137
138/**
139 * tty_ldisc_get - take a reference to an ldisc
140 * @disc: ldisc number
141 *
142 * Takes a reference to a line discipline. Deals with refcounts and
143 * module locking counts.
144 *
145 * Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or
146 * if the discipline is not registered
147 * -EAGAIN if request_module() failed to load or register the
148 * the discipline
149 * -ENOMEM if allocation failure
150 *
151 * Otherwise, returns a pointer to the discipline and bumps the
152 * ref count
153 *
154 * Locking:
155 * takes tty_ldiscs_lock to guard against ldisc races
156 */
157
158static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
159{
160 struct tty_ldisc *ld;
161 struct tty_ldisc_ops *ldops;
162
163 if (disc < N_TTY || disc >= NR_LDISCS)
164 return ERR_PTR(-EINVAL);
165
166 /*
167 * Get the ldisc ops - we may need to request them to be loaded
168 * dynamically and try again.
169 */
170 ldops = get_ldops(disc);
171 if (IS_ERR(ldops)) {
172 request_module("tty-ldisc-%d", disc);
173 ldops = get_ldops(disc);
174 if (IS_ERR(ldops))
175 return ERR_CAST(ldops);
176 }
177
178 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
179 if (ld == NULL) {
180 put_ldops(ldops);
181 return ERR_PTR(-ENOMEM);
182 }
183
184 ld->ops = ldops;
185 ld->tty = tty;
186
187 return ld;
188}
189
190/**
191 * tty_ldisc_put - release the ldisc
192 *
193 * Complement of tty_ldisc_get().
194 */
195static void tty_ldisc_put(struct tty_ldisc *ld)
196{
197 if (WARN_ON_ONCE(!ld))
198 return;
199
200 put_ldops(ld->ops);
201 kfree(ld);
202}
203
204static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
205{
206 return (*pos < NR_LDISCS) ? pos : NULL;
207}
208
209static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
210{
211 (*pos)++;
212 return (*pos < NR_LDISCS) ? pos : NULL;
213}
214
215static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
216{
217}
218
219static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
220{
221 int i = *(loff_t *)v;
222 struct tty_ldisc_ops *ldops;
223
224 ldops = get_ldops(i);
225 if (IS_ERR(ldops))
226 return 0;
227 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
228 put_ldops(ldops);
229 return 0;
230}
231
232static const struct seq_operations tty_ldiscs_seq_ops = {
233 .start = tty_ldiscs_seq_start,
234 .next = tty_ldiscs_seq_next,
235 .stop = tty_ldiscs_seq_stop,
236 .show = tty_ldiscs_seq_show,
237};
238
239static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
240{
241 return seq_open(file, &tty_ldiscs_seq_ops);
242}
243
244const struct file_operations tty_ldiscs_proc_fops = {
245 .owner = THIS_MODULE,
246 .open = proc_tty_ldiscs_open,
247 .read = seq_read,
248 .llseek = seq_lseek,
249 .release = seq_release,
250};
251
252/**
253 * tty_ldisc_ref_wait - wait for the tty ldisc
254 * @tty: tty device
255 *
256 * Dereference the line discipline for the terminal and take a
257 * reference to it. If the line discipline is in flux then
258 * wait patiently until it changes.
259 *
260 * Returns: NULL if the tty has been hungup and not re-opened with
261 * a new file descriptor, otherwise valid ldisc reference
262 *
263 * Note: Must not be called from an IRQ/timer context. The caller
264 * must also be careful not to hold other locks that will deadlock
265 * against a discipline change, such as an existing ldisc reference
266 * (which we check for)
267 *
268 * Note: a file_operations routine (read/poll/write) should use this
269 * function to wait for any ldisc lifetime events to finish.
270 */
271
272struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
273{
274 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
275 if (!tty->ldisc)
276 ldsem_up_read(&tty->ldisc_sem);
277 return tty->ldisc;
278}
279EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
280
281/**
282 * tty_ldisc_ref - get the tty ldisc
283 * @tty: tty device
284 *
285 * Dereference the line discipline for the terminal and take a
286 * reference to it. If the line discipline is in flux then
287 * return NULL. Can be called from IRQ and timer functions.
288 */
289
290struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
291{
292 struct tty_ldisc *ld = NULL;
293
294 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
295 ld = tty->ldisc;
296 if (!ld)
297 ldsem_up_read(&tty->ldisc_sem);
298 }
299 return ld;
300}
301EXPORT_SYMBOL_GPL(tty_ldisc_ref);
302
303/**
304 * tty_ldisc_deref - free a tty ldisc reference
305 * @ld: reference to free up
306 *
307 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
308 * be called in IRQ context.
309 */
310
311void tty_ldisc_deref(struct tty_ldisc *ld)
312{
313 ldsem_up_read(&ld->tty->ldisc_sem);
314}
315EXPORT_SYMBOL_GPL(tty_ldisc_deref);
316
317
318static inline int
319__tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
320{
321 return ldsem_down_write(&tty->ldisc_sem, timeout);
322}
323
324static inline int
325__tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
326{
327 return ldsem_down_write_nested(&tty->ldisc_sem,
328 LDISC_SEM_OTHER, timeout);
329}
330
331static inline void __tty_ldisc_unlock(struct tty_struct *tty)
332{
333 ldsem_up_write(&tty->ldisc_sem);
334}
335
336static int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
337{
338 int ret;
339
340 ret = __tty_ldisc_lock(tty, timeout);
341 if (!ret)
342 return -EBUSY;
343 set_bit(TTY_LDISC_HALTED, &tty->flags);
344 return 0;
345}
346
347static void tty_ldisc_unlock(struct tty_struct *tty)
348{
349 clear_bit(TTY_LDISC_HALTED, &tty->flags);
350 __tty_ldisc_unlock(tty);
351}
352
353static int
354tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
355 unsigned long timeout)
356{
357 int ret;
358
359 if (tty < tty2) {
360 ret = __tty_ldisc_lock(tty, timeout);
361 if (ret) {
362 ret = __tty_ldisc_lock_nested(tty2, timeout);
363 if (!ret)
364 __tty_ldisc_unlock(tty);
365 }
366 } else {
367 /* if this is possible, it has lots of implications */
368 WARN_ON_ONCE(tty == tty2);
369 if (tty2 && tty != tty2) {
370 ret = __tty_ldisc_lock(tty2, timeout);
371 if (ret) {
372 ret = __tty_ldisc_lock_nested(tty, timeout);
373 if (!ret)
374 __tty_ldisc_unlock(tty2);
375 }
376 } else
377 ret = __tty_ldisc_lock(tty, timeout);
378 }
379
380 if (!ret)
381 return -EBUSY;
382
383 set_bit(TTY_LDISC_HALTED, &tty->flags);
384 if (tty2)
385 set_bit(TTY_LDISC_HALTED, &tty2->flags);
386 return 0;
387}
388
389static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
390{
391 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
392}
393
394static void tty_ldisc_unlock_pair(struct tty_struct *tty,
395 struct tty_struct *tty2)
396{
397 __tty_ldisc_unlock(tty);
398 if (tty2)
399 __tty_ldisc_unlock(tty2);
400}
401
402/**
403 * tty_ldisc_flush - flush line discipline queue
404 * @tty: tty
405 *
406 * Flush the line discipline queue (if any) and the tty flip buffers
407 * for this tty.
408 */
409
410void tty_ldisc_flush(struct tty_struct *tty)
411{
412 struct tty_ldisc *ld = tty_ldisc_ref(tty);
413
414 tty_buffer_flush(tty, ld);
415 if (ld)
416 tty_ldisc_deref(ld);
417}
418EXPORT_SYMBOL_GPL(tty_ldisc_flush);
419
420/**
421 * tty_set_termios_ldisc - set ldisc field
422 * @tty: tty structure
423 * @disc: line discipline number
424 *
425 * This is probably overkill for real world processors but
426 * they are not on hot paths so a little discipline won't do
427 * any harm.
428 *
429 * The line discipline-related tty_struct fields are reset to
430 * prevent the ldisc driver from re-using stale information for
431 * the new ldisc instance.
432 *
433 * Locking: takes termios_rwsem
434 */
435
436static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
437{
438 down_write(&tty->termios_rwsem);
439 tty->termios.c_line = disc;
440 up_write(&tty->termios_rwsem);
441
442 tty->disc_data = NULL;
443 tty->receive_room = 0;
444}
445
446/**
447 * tty_ldisc_open - open a line discipline
448 * @tty: tty we are opening the ldisc on
449 * @ld: discipline to open
450 *
451 * A helper opening method. Also a convenient debugging and check
452 * point.
453 *
454 * Locking: always called with BTM already held.
455 */
456
457static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
458{
459 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
460 if (ld->ops->open) {
461 int ret;
462 /* BTM here locks versus a hangup event */
463 ret = ld->ops->open(tty);
464 if (ret)
465 clear_bit(TTY_LDISC_OPEN, &tty->flags);
466
467 tty_ldisc_debug(tty, "%p: opened\n", ld);
468 return ret;
469 }
470 return 0;
471}
472
473/**
474 * tty_ldisc_close - close a line discipline
475 * @tty: tty we are opening the ldisc on
476 * @ld: discipline to close
477 *
478 * A helper close method. Also a convenient debugging and check
479 * point.
480 */
481
482static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
483{
484 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
485 clear_bit(TTY_LDISC_OPEN, &tty->flags);
486 if (ld->ops->close)
487 ld->ops->close(tty);
488 tty_ldisc_debug(tty, "%p: closed\n", ld);
489}
490
491/**
492 * tty_ldisc_restore - helper for tty ldisc change
493 * @tty: tty to recover
494 * @old: previous ldisc
495 *
496 * Restore the previous line discipline or N_TTY when a line discipline
497 * change fails due to an open error
498 */
499
500static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
501{
502 struct tty_ldisc *new_ldisc;
503 int r;
504
505 /* There is an outstanding reference here so this is safe */
506 old = tty_ldisc_get(tty, old->ops->num);
507 WARN_ON(IS_ERR(old));
508 tty->ldisc = old;
509 tty_set_termios_ldisc(tty, old->ops->num);
510 if (tty_ldisc_open(tty, old) < 0) {
511 tty_ldisc_put(old);
512 /* This driver is always present */
513 new_ldisc = tty_ldisc_get(tty, N_TTY);
514 if (IS_ERR(new_ldisc))
515 panic("n_tty: get");
516 tty->ldisc = new_ldisc;
517 tty_set_termios_ldisc(tty, N_TTY);
518 r = tty_ldisc_open(tty, new_ldisc);
519 if (r < 0)
520 panic("Couldn't open N_TTY ldisc for "
521 "%s --- error %d.",
522 tty_name(tty), r);
523 }
524}
525
526/**
527 * tty_set_ldisc - set line discipline
528 * @tty: the terminal to set
529 * @ldisc: the line discipline
530 *
531 * Set the discipline of a tty line. Must be called from a process
532 * context. The ldisc change logic has to protect itself against any
533 * overlapping ldisc change (including on the other end of pty pairs),
534 * the close of one side of a tty/pty pair, and eventually hangup.
535 */
536
537int tty_set_ldisc(struct tty_struct *tty, int disc)
538{
539 int retval;
540 struct tty_ldisc *old_ldisc, *new_ldisc;
541
542 new_ldisc = tty_ldisc_get(tty, disc);
543 if (IS_ERR(new_ldisc))
544 return PTR_ERR(new_ldisc);
545
546 tty_lock(tty);
547 retval = tty_ldisc_lock(tty, 5 * HZ);
548 if (retval)
549 goto err;
550
551 if (!tty->ldisc) {
552 retval = -EIO;
553 goto out;
554 }
555
556 /* Check the no-op case */
557 if (tty->ldisc->ops->num == disc)
558 goto out;
559
560 if (test_bit(TTY_HUPPED, &tty->flags)) {
561 /* We were raced by hangup */
562 retval = -EIO;
563 goto out;
564 }
565
566 old_ldisc = tty->ldisc;
567
568 /* Shutdown the old discipline. */
569 tty_ldisc_close(tty, old_ldisc);
570
571 /* Now set up the new line discipline. */
572 tty->ldisc = new_ldisc;
573 tty_set_termios_ldisc(tty, disc);
574
575 retval = tty_ldisc_open(tty, new_ldisc);
576 if (retval < 0) {
577 /* Back to the old one or N_TTY if we can't */
578 tty_ldisc_put(new_ldisc);
579 tty_ldisc_restore(tty, old_ldisc);
580 }
581
582 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
583 down_read(&tty->termios_rwsem);
584 tty->ops->set_ldisc(tty);
585 up_read(&tty->termios_rwsem);
586 }
587
588 /* At this point we hold a reference to the new ldisc and a
589 reference to the old ldisc, or we hold two references to
590 the old ldisc (if it was restored as part of error cleanup
591 above). In either case, releasing a single reference from
592 the old ldisc is correct. */
593 new_ldisc = old_ldisc;
594out:
595 tty_ldisc_unlock(tty);
596
597 /* Restart the work queue in case no characters kick it off. Safe if
598 already running */
599 tty_buffer_restart_work(tty->port);
600err:
601 tty_ldisc_put(new_ldisc); /* drop the extra reference */
602 tty_unlock(tty);
603 return retval;
604}
605
606/**
607 * tty_ldisc_kill - teardown ldisc
608 * @tty: tty being released
609 *
610 * Perform final close of the ldisc and reset tty->ldisc
611 */
612static void tty_ldisc_kill(struct tty_struct *tty)
613{
614 if (!tty->ldisc)
615 return;
616 /*
617 * Now kill off the ldisc
618 */
619 tty_ldisc_close(tty, tty->ldisc);
620 tty_ldisc_put(tty->ldisc);
621 /* Force an oops if we mess this up */
622 tty->ldisc = NULL;
623}
624
625/**
626 * tty_reset_termios - reset terminal state
627 * @tty: tty to reset
628 *
629 * Restore a terminal to the driver default state.
630 */
631
632static void tty_reset_termios(struct tty_struct *tty)
633{
634 down_write(&tty->termios_rwsem);
635 tty->termios = tty->driver->init_termios;
636 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
637 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
638 up_write(&tty->termios_rwsem);
639}
640
641
642/**
643 * tty_ldisc_reinit - reinitialise the tty ldisc
644 * @tty: tty to reinit
645 * @disc: line discipline to reinitialize
646 *
647 * Completely reinitialize the line discipline state, by closing the
648 * current instance, if there is one, and opening a new instance. If
649 * an error occurs opening the new non-N_TTY instance, the instance
650 * is dropped and tty->ldisc reset to NULL. The caller can then retry
651 * with N_TTY instead.
652 *
653 * Returns 0 if successful, otherwise error code < 0
654 */
655
656int tty_ldisc_reinit(struct tty_struct *tty, int disc)
657{
658 struct tty_ldisc *ld;
659 int retval;
660
661 ld = tty_ldisc_get(tty, disc);
662 if (IS_ERR(ld)) {
663 BUG_ON(disc == N_TTY);
664 return PTR_ERR(ld);
665 }
666
667 if (tty->ldisc) {
668 tty_ldisc_close(tty, tty->ldisc);
669 tty_ldisc_put(tty->ldisc);
670 }
671
672 /* switch the line discipline */
673 tty->ldisc = ld;
674 tty_set_termios_ldisc(tty, disc);
675 retval = tty_ldisc_open(tty, tty->ldisc);
676 if (retval) {
677 if (!WARN_ON(disc == N_TTY)) {
678 tty_ldisc_put(tty->ldisc);
679 tty->ldisc = NULL;
680 }
681 }
682 return retval;
683}
684
685/**
686 * tty_ldisc_hangup - hangup ldisc reset
687 * @tty: tty being hung up
688 *
689 * Some tty devices reset their termios when they receive a hangup
690 * event. In that situation we must also switch back to N_TTY properly
691 * before we reset the termios data.
692 *
693 * Locking: We can take the ldisc mutex as the rest of the code is
694 * careful to allow for this.
695 *
696 * In the pty pair case this occurs in the close() path of the
697 * tty itself so we must be careful about locking rules.
698 */
699
700void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
701{
702 struct tty_ldisc *ld;
703
704 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
705
706 ld = tty_ldisc_ref(tty);
707 if (ld != NULL) {
708 if (ld->ops->flush_buffer)
709 ld->ops->flush_buffer(tty);
710 tty_driver_flush_buffer(tty);
711 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
712 ld->ops->write_wakeup)
713 ld->ops->write_wakeup(tty);
714 if (ld->ops->hangup)
715 ld->ops->hangup(tty);
716 tty_ldisc_deref(ld);
717 }
718
719 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
720 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
721
722 /*
723 * Shutdown the current line discipline, and reset it to
724 * N_TTY if need be.
725 *
726 * Avoid racing set_ldisc or tty_ldisc_release
727 */
728 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
729
730 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
731 tty_reset_termios(tty);
732
733 if (tty->ldisc) {
734 if (reinit) {
735 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0)
736 tty_ldisc_reinit(tty, N_TTY);
737 } else
738 tty_ldisc_kill(tty);
739 }
740 tty_ldisc_unlock(tty);
741}
742
743/**
744 * tty_ldisc_setup - open line discipline
745 * @tty: tty being shut down
746 * @o_tty: pair tty for pty/tty pairs
747 *
748 * Called during the initial open of a tty/pty pair in order to set up the
749 * line disciplines and bind them to the tty. This has no locking issues
750 * as the device isn't yet active.
751 */
752
753int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
754{
755 int retval = tty_ldisc_open(tty, tty->ldisc);
756 if (retval)
757 return retval;
758
759 if (o_tty) {
760 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
761 if (retval) {
762 tty_ldisc_close(tty, tty->ldisc);
763 return retval;
764 }
765 }
766 return 0;
767}
768
769/**
770 * tty_ldisc_release - release line discipline
771 * @tty: tty being shut down (or one end of pty pair)
772 *
773 * Called during the final close of a tty or a pty pair in order to shut
774 * down the line discpline layer. On exit, each tty's ldisc is NULL.
775 */
776
777void tty_ldisc_release(struct tty_struct *tty)
778{
779 struct tty_struct *o_tty = tty->link;
780
781 /*
782 * Shutdown this line discipline. As this is the final close,
783 * it does not race with the set_ldisc code path.
784 */
785
786 tty_ldisc_lock_pair(tty, o_tty);
787 tty_ldisc_kill(tty);
788 if (o_tty)
789 tty_ldisc_kill(o_tty);
790 tty_ldisc_unlock_pair(tty, o_tty);
791
792 /* And the memory resources remaining (buffers, termios) will be
793 disposed of when the kref hits zero */
794
795 tty_ldisc_debug(tty, "released\n");
796}
797
798/**
799 * tty_ldisc_init - ldisc setup for new tty
800 * @tty: tty being allocated
801 *
802 * Set up the line discipline objects for a newly allocated tty. Note that
803 * the tty structure is not completely set up when this call is made.
804 */
805
806void tty_ldisc_init(struct tty_struct *tty)
807{
808 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
809 if (IS_ERR(ld))
810 panic("n_tty: init_tty");
811 tty->ldisc = ld;
812}
813
814/**
815 * tty_ldisc_deinit - ldisc cleanup for new tty
816 * @tty: tty that was allocated recently
817 *
818 * The tty structure must not becompletely set up (tty_ldisc_setup) when
819 * this call is made.
820 */
821void tty_ldisc_deinit(struct tty_struct *tty)
822{
823 if (tty->ldisc)
824 tty_ldisc_put(tty->ldisc);
825 tty->ldisc = NULL;
826}