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>
7 #include <linux/tty_driver.h>
8 #include <linux/file.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>
22 #undef LDISC_DEBUG_HANGUP
24 #ifdef LDISC_DEBUG_HANGUP
25 #define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args)
27 #define tty_ldisc_debug(tty, f, args...)
30 /* lockdep nested classes for tty->ldisc_sem */
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.
43 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
44 /* Line disc dispatch table */
45 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
48 * tty_register_ldisc - install a line discipline
50 * @new_ldisc: pointer to the ldisc object
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.
57 * takes tty_ldiscs_lock to guard against ldisc races
60 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
65 if (disc < N_TTY || disc >= NR_LDISCS)
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);
76 EXPORT_SYMBOL(tty_register_ldisc);
79 * tty_unregister_ldisc - unload a line discipline
81 * @new_ldisc: pointer to the ldisc object
83 * Remove a line discipline from the kernel providing it is not
87 * takes tty_ldiscs_lock to guard against ldisc races
90 int tty_unregister_ldisc(int disc)
95 if (disc < N_TTY || disc >= NR_LDISCS)
98 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
99 if (tty_ldiscs[disc]->refcount)
102 tty_ldiscs[disc] = NULL;
103 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
107 EXPORT_SYMBOL(tty_unregister_ldisc);
109 static struct tty_ldisc_ops *get_ldops(int disc)
112 struct tty_ldisc_ops *ldops, *ret;
114 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
115 ret = ERR_PTR(-EINVAL);
116 ldops = tty_ldiscs[disc];
118 ret = ERR_PTR(-EAGAIN);
119 if (try_module_get(ldops->owner)) {
124 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
128 static void put_ldops(struct tty_ldisc_ops *ldops)
132 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
134 module_put(ldops->owner);
135 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
139 * tty_ldisc_get - take a reference to an ldisc
140 * @disc: ldisc number
142 * Takes a reference to a line discipline. Deals with refcounts and
143 * module locking counts. Returns NULL if the discipline is not available.
144 * Returns a pointer to the discipline and bumps the ref count if it is
148 * takes tty_ldiscs_lock to guard against ldisc races
151 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
153 struct tty_ldisc *ld;
154 struct tty_ldisc_ops *ldops;
156 if (disc < N_TTY || disc >= NR_LDISCS)
157 return ERR_PTR(-EINVAL);
160 * Get the ldisc ops - we may need to request them to be loaded
161 * dynamically and try again.
163 ldops = get_ldops(disc);
165 request_module("tty-ldisc-%d", disc);
166 ldops = get_ldops(disc);
168 return ERR_CAST(ldops);
171 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
174 return ERR_PTR(-ENOMEM);
184 * tty_ldisc_put - release the ldisc
186 * Complement of tty_ldisc_get().
188 static inline void tty_ldisc_put(struct tty_ldisc *ld)
190 if (WARN_ON_ONCE(!ld))
197 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
199 return (*pos < NR_LDISCS) ? pos : NULL;
202 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
205 return (*pos < NR_LDISCS) ? pos : NULL;
208 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
212 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
214 int i = *(loff_t *)v;
215 struct tty_ldisc_ops *ldops;
217 ldops = get_ldops(i);
220 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
225 static const struct seq_operations tty_ldiscs_seq_ops = {
226 .start = tty_ldiscs_seq_start,
227 .next = tty_ldiscs_seq_next,
228 .stop = tty_ldiscs_seq_stop,
229 .show = tty_ldiscs_seq_show,
232 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
234 return seq_open(file, &tty_ldiscs_seq_ops);
237 const struct file_operations tty_ldiscs_proc_fops = {
238 .owner = THIS_MODULE,
239 .open = proc_tty_ldiscs_open,
242 .release = seq_release,
246 * tty_ldisc_ref_wait - wait for the tty ldisc
249 * Dereference the line discipline for the terminal and take a
250 * reference to it. If the line discipline is in flux then
251 * wait patiently until it changes.
253 * Note: Must not be called from an IRQ/timer context. The caller
254 * must also be careful not to hold other locks that will deadlock
255 * against a discipline change, such as an existing ldisc reference
256 * (which we check for)
258 * Note: only callable from a file_operations routine (which
259 * guarantees tty->ldisc != NULL when the lock is acquired).
262 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
264 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
265 WARN_ON(!tty->ldisc);
268 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
271 * tty_ldisc_ref - get the tty ldisc
274 * Dereference the line discipline for the terminal and take a
275 * reference to it. If the line discipline is in flux then
276 * return NULL. Can be called from IRQ and timer functions.
279 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
281 struct tty_ldisc *ld = NULL;
283 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
286 ldsem_up_read(&tty->ldisc_sem);
290 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
293 * tty_ldisc_deref - free a tty ldisc reference
294 * @ld: reference to free up
296 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
297 * be called in IRQ context.
300 void tty_ldisc_deref(struct tty_ldisc *ld)
302 ldsem_up_read(&ld->tty->ldisc_sem);
304 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
307 static inline int __lockfunc
308 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
310 return ldsem_down_write(&tty->ldisc_sem, timeout);
313 static inline int __lockfunc
314 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
316 return ldsem_down_write_nested(&tty->ldisc_sem,
317 LDISC_SEM_OTHER, timeout);
320 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
322 ldsem_up_write(&tty->ldisc_sem);
325 static int __lockfunc
326 tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
330 ret = __tty_ldisc_lock(tty, timeout);
333 set_bit(TTY_LDISC_HALTED, &tty->flags);
337 static void tty_ldisc_unlock(struct tty_struct *tty)
339 clear_bit(TTY_LDISC_HALTED, &tty->flags);
340 __tty_ldisc_unlock(tty);
343 static int __lockfunc
344 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
345 unsigned long timeout)
350 ret = __tty_ldisc_lock(tty, timeout);
352 ret = __tty_ldisc_lock_nested(tty2, timeout);
354 __tty_ldisc_unlock(tty);
357 /* if this is possible, it has lots of implications */
358 WARN_ON_ONCE(tty == tty2);
359 if (tty2 && tty != tty2) {
360 ret = __tty_ldisc_lock(tty2, timeout);
362 ret = __tty_ldisc_lock_nested(tty, timeout);
364 __tty_ldisc_unlock(tty2);
367 ret = __tty_ldisc_lock(tty, timeout);
373 set_bit(TTY_LDISC_HALTED, &tty->flags);
375 set_bit(TTY_LDISC_HALTED, &tty2->flags);
379 static void __lockfunc
380 tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
382 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
385 static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
386 struct tty_struct *tty2)
388 __tty_ldisc_unlock(tty);
390 __tty_ldisc_unlock(tty2);
394 * tty_ldisc_flush - flush line discipline queue
397 * Flush the line discipline queue (if any) and the tty flip buffers
401 void tty_ldisc_flush(struct tty_struct *tty)
403 struct tty_ldisc *ld = tty_ldisc_ref(tty);
405 tty_buffer_flush(tty, ld);
409 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
412 * tty_set_termios_ldisc - set ldisc field
413 * @tty: tty structure
414 * @num: line discipline number
416 * This is probably overkill for real world processors but
417 * they are not on hot paths so a little discipline won't do
420 * The line discipline-related tty_struct fields are reset to
421 * prevent the ldisc driver from re-using stale information for
422 * the new ldisc instance.
424 * Locking: takes termios_rwsem
427 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
429 down_write(&tty->termios_rwsem);
430 tty->termios.c_line = num;
431 up_write(&tty->termios_rwsem);
433 tty->disc_data = NULL;
434 tty->receive_room = 0;
438 * tty_ldisc_open - open a line discipline
439 * @tty: tty we are opening the ldisc on
440 * @ld: discipline to open
442 * A helper opening method. Also a convenient debugging and check
445 * Locking: always called with BTM already held.
448 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
450 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
453 /* BTM here locks versus a hangup event */
454 ret = ld->ops->open(tty);
456 clear_bit(TTY_LDISC_OPEN, &tty->flags);
458 tty_ldisc_debug(tty, "%p: opened\n", tty->ldisc);
465 * tty_ldisc_close - close a line discipline
466 * @tty: tty we are opening the ldisc on
467 * @ld: discipline to close
469 * A helper close method. Also a convenient debugging and check
473 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
475 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
476 clear_bit(TTY_LDISC_OPEN, &tty->flags);
479 tty_ldisc_debug(tty, "%p: closed\n", tty->ldisc);
483 * tty_ldisc_restore - helper for tty ldisc change
484 * @tty: tty to recover
485 * @old: previous ldisc
487 * Restore the previous line discipline or N_TTY when a line discipline
488 * change fails due to an open error
491 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
493 struct tty_ldisc *new_ldisc;
496 /* There is an outstanding reference here so this is safe */
497 old = tty_ldisc_get(tty, old->ops->num);
498 WARN_ON(IS_ERR(old));
500 tty_set_termios_ldisc(tty, old->ops->num);
501 if (tty_ldisc_open(tty, old) < 0) {
503 /* This driver is always present */
504 new_ldisc = tty_ldisc_get(tty, N_TTY);
505 if (IS_ERR(new_ldisc))
507 tty->ldisc = new_ldisc;
508 tty_set_termios_ldisc(tty, N_TTY);
509 r = tty_ldisc_open(tty, new_ldisc);
511 panic("Couldn't open N_TTY ldisc for "
518 * tty_set_ldisc - set line discipline
519 * @tty: the terminal to set
520 * @ldisc: the line discipline
522 * Set the discipline of a tty line. Must be called from a process
523 * context. The ldisc change logic has to protect itself against any
524 * overlapping ldisc change (including on the other end of pty pairs),
525 * the close of one side of a tty/pty pair, and eventually hangup.
528 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
531 struct tty_ldisc *old_ldisc, *new_ldisc;
533 new_ldisc = tty_ldisc_get(tty, ldisc);
534 if (IS_ERR(new_ldisc))
535 return PTR_ERR(new_ldisc);
538 retval = tty_ldisc_lock(tty, 5 * HZ);
540 tty_ldisc_put(new_ldisc);
546 * Check the no-op case
549 if (tty->ldisc->ops->num == ldisc) {
550 tty_ldisc_unlock(tty);
551 tty_ldisc_put(new_ldisc);
556 old_ldisc = tty->ldisc;
558 if (test_bit(TTY_HUPPED, &tty->flags)) {
559 /* We were raced by the hangup method. It will have stomped
560 the ldisc data and closed the ldisc down */
561 tty_ldisc_unlock(tty);
562 tty_ldisc_put(new_ldisc);
567 /* Shutdown the old discipline. */
568 tty_ldisc_close(tty, old_ldisc);
570 /* Now set up the new line discipline. */
571 tty->ldisc = new_ldisc;
572 tty_set_termios_ldisc(tty, ldisc);
574 retval = tty_ldisc_open(tty, new_ldisc);
576 /* Back to the old one or N_TTY if we can't */
577 tty_ldisc_put(new_ldisc);
578 tty_ldisc_restore(tty, old_ldisc);
581 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
582 down_read(&tty->termios_rwsem);
583 tty->ops->set_ldisc(tty);
584 up_read(&tty->termios_rwsem);
587 /* At this point we hold a reference to the new ldisc and a
588 reference to the old ldisc, or we hold two references to
589 the old ldisc (if it was restored as part of error cleanup
590 above). In either case, releasing a single reference from
591 the old ldisc is correct. */
593 tty_ldisc_put(old_ldisc);
596 * Allow ldisc referencing to occur again
598 tty_ldisc_unlock(tty);
600 /* Restart the work queue in case no characters kick it off. Safe if
602 tty_buffer_restart_work(tty->port);
609 * tty_reset_termios - reset terminal state
612 * Restore a terminal to the driver default state.
615 static void tty_reset_termios(struct tty_struct *tty)
617 down_write(&tty->termios_rwsem);
618 tty->termios = tty->driver->init_termios;
619 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
620 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
621 up_write(&tty->termios_rwsem);
626 * tty_ldisc_reinit - reinitialise the tty ldisc
627 * @tty: tty to reinit
628 * @ldisc: line discipline to reinitialize
630 * Switch the tty to a line discipline and leave the ldisc
634 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
636 struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
641 tty_ldisc_close(tty, tty->ldisc);
642 tty_ldisc_put(tty->ldisc);
644 * Switch the line discipline back
647 tty_set_termios_ldisc(tty, ldisc);
653 * tty_ldisc_hangup - hangup ldisc reset
654 * @tty: tty being hung up
656 * Some tty devices reset their termios when they receive a hangup
657 * event. In that situation we must also switch back to N_TTY properly
658 * before we reset the termios data.
660 * Locking: We can take the ldisc mutex as the rest of the code is
661 * careful to allow for this.
663 * In the pty pair case this occurs in the close() path of the
664 * tty itself so we must be careful about locking rules.
667 void tty_ldisc_hangup(struct tty_struct *tty)
669 struct tty_ldisc *ld;
670 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
673 tty_ldisc_debug(tty, "%p: closing\n", tty->ldisc);
675 ld = tty_ldisc_ref(tty);
677 if (ld->ops->flush_buffer)
678 ld->ops->flush_buffer(tty);
679 tty_driver_flush_buffer(tty);
680 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
681 ld->ops->write_wakeup)
682 ld->ops->write_wakeup(tty);
684 ld->ops->hangup(tty);
688 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
689 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
692 * Shutdown the current line discipline, and reset it to
695 * Avoid racing set_ldisc or tty_ldisc_release
697 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
701 /* At this point we have a halted ldisc; we want to close it and
702 reopen a new ldisc. We could defer the reopen to the next
703 open but it means auditing a lot of other paths so this is
707 if (!tty_ldisc_reinit(tty, tty->termios.c_line))
708 err = tty_ldisc_open(tty, tty->ldisc);
712 /* If the re-open fails or we reset then go to N_TTY. The
713 N_TTY open cannot fail */
715 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
716 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
719 tty_ldisc_unlock(tty);
721 tty_reset_termios(tty);
723 tty_ldisc_debug(tty, "%p: re-opened\n", tty->ldisc);
727 * tty_ldisc_setup - open line discipline
728 * @tty: tty being shut down
729 * @o_tty: pair tty for pty/tty pairs
731 * Called during the initial open of a tty/pty pair in order to set up the
732 * line disciplines and bind them to the tty. This has no locking issues
733 * as the device isn't yet active.
736 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
738 struct tty_ldisc *ld = tty->ldisc;
741 retval = tty_ldisc_open(tty, ld);
746 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
748 tty_ldisc_close(tty, ld);
755 static void tty_ldisc_kill(struct tty_struct *tty)
758 * Now kill off the ldisc
760 tty_ldisc_close(tty, tty->ldisc);
761 tty_ldisc_put(tty->ldisc);
762 /* Force an oops if we mess this up */
765 /* Ensure the next open requests the N_TTY ldisc */
766 tty_set_termios_ldisc(tty, N_TTY);
770 * tty_ldisc_release - release line discipline
771 * @tty: tty being shut down (or one end of pty pair)
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 ldisc assigned is N_TTY and
775 * each ldisc has not been opened.
778 void tty_ldisc_release(struct tty_struct *tty)
780 struct tty_struct *o_tty = tty->link;
783 * Shutdown this line discipline. As this is the final close,
784 * it does not race with the set_ldisc code path.
787 tty_ldisc_lock_pair(tty, o_tty);
790 tty_ldisc_kill(o_tty);
791 tty_ldisc_unlock_pair(tty, o_tty);
793 /* And the memory resources remaining (buffers, termios) will be
794 disposed of when the kref hits zero */
796 tty_ldisc_debug(tty, "released\n");
800 * tty_ldisc_init - ldisc setup for new tty
801 * @tty: tty being allocated
803 * Set up the line discipline objects for a newly allocated tty. Note that
804 * the tty structure is not completely set up when this call is made.
807 void tty_ldisc_init(struct tty_struct *tty)
809 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
811 panic("n_tty: init_tty");
816 * tty_ldisc_init - ldisc cleanup for new tty
817 * @tty: tty that was allocated recently
819 * The tty structure must not becompletely set up (tty_ldisc_setup) when
822 void tty_ldisc_deinit(struct tty_struct *tty)
824 tty_ldisc_put(tty->ldisc);
828 void tty_ldisc_begin(void)
830 /* Setup the default TTY line discipline. */
831 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);