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