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.
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
149 * -ENOMEM if allocation failure
151 * Otherwise, returns a pointer to the discipline and bumps the
155 * takes tty_ldiscs_lock to guard against ldisc races
158 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
160 struct tty_ldisc *ld;
161 struct tty_ldisc_ops *ldops;
163 if (disc < N_TTY || disc >= NR_LDISCS)
164 return ERR_PTR(-EINVAL);
167 * Get the ldisc ops - we may need to request them to be loaded
168 * dynamically and try again.
170 ldops = get_ldops(disc);
172 request_module("tty-ldisc-%d", disc);
173 ldops = get_ldops(disc);
175 return ERR_CAST(ldops);
179 * There is no way to handle allocation failure of only 16 bytes.
180 * Let's simplify error handling and save more memory.
182 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL | __GFP_NOFAIL);
190 * tty_ldisc_put - release the ldisc
192 * Complement of tty_ldisc_get().
194 static void tty_ldisc_put(struct tty_ldisc *ld)
196 if (WARN_ON_ONCE(!ld))
203 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
205 return (*pos < NR_LDISCS) ? pos : NULL;
208 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
211 return (*pos < NR_LDISCS) ? pos : NULL;
214 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
218 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
220 int i = *(loff_t *)v;
221 struct tty_ldisc_ops *ldops;
223 ldops = get_ldops(i);
226 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
231 static const struct seq_operations tty_ldiscs_seq_ops = {
232 .start = tty_ldiscs_seq_start,
233 .next = tty_ldiscs_seq_next,
234 .stop = tty_ldiscs_seq_stop,
235 .show = tty_ldiscs_seq_show,
238 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
240 return seq_open(file, &tty_ldiscs_seq_ops);
243 const struct file_operations tty_ldiscs_proc_fops = {
244 .owner = THIS_MODULE,
245 .open = proc_tty_ldiscs_open,
248 .release = seq_release,
252 * tty_ldisc_ref_wait - wait for the tty ldisc
255 * Dereference the line discipline for the terminal and take a
256 * reference to it. If the line discipline is in flux then
257 * wait patiently until it changes.
259 * Returns: NULL if the tty has been hungup and not re-opened with
260 * a new file descriptor, otherwise valid ldisc reference
262 * Note: Must not be called from an IRQ/timer context. The caller
263 * must also be careful not to hold other locks that will deadlock
264 * against a discipline change, such as an existing ldisc reference
265 * (which we check for)
267 * Note: a file_operations routine (read/poll/write) should use this
268 * function to wait for any ldisc lifetime events to finish.
271 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
273 struct tty_ldisc *ld;
275 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
278 ldsem_up_read(&tty->ldisc_sem);
281 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
284 * tty_ldisc_ref - get the tty ldisc
287 * Dereference the line discipline for the terminal and take a
288 * reference to it. If the line discipline is in flux then
289 * return NULL. Can be called from IRQ and timer functions.
292 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
294 struct tty_ldisc *ld = NULL;
296 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
299 ldsem_up_read(&tty->ldisc_sem);
303 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
306 * tty_ldisc_deref - free a tty ldisc reference
307 * @ld: reference to free up
309 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
310 * be called in IRQ context.
313 void tty_ldisc_deref(struct tty_ldisc *ld)
315 ldsem_up_read(&ld->tty->ldisc_sem);
317 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
321 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
323 return ldsem_down_write(&tty->ldisc_sem, timeout);
327 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
329 return ldsem_down_write_nested(&tty->ldisc_sem,
330 LDISC_SEM_OTHER, timeout);
333 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
335 ldsem_up_write(&tty->ldisc_sem);
338 int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
342 ret = __tty_ldisc_lock(tty, timeout);
345 set_bit(TTY_LDISC_HALTED, &tty->flags);
349 void tty_ldisc_unlock(struct tty_struct *tty)
351 clear_bit(TTY_LDISC_HALTED, &tty->flags);
352 __tty_ldisc_unlock(tty);
356 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
357 unsigned long timeout)
362 ret = __tty_ldisc_lock(tty, timeout);
364 ret = __tty_ldisc_lock_nested(tty2, timeout);
366 __tty_ldisc_unlock(tty);
369 /* if this is possible, it has lots of implications */
370 WARN_ON_ONCE(tty == tty2);
371 if (tty2 && tty != tty2) {
372 ret = __tty_ldisc_lock(tty2, timeout);
374 ret = __tty_ldisc_lock_nested(tty, timeout);
376 __tty_ldisc_unlock(tty2);
379 ret = __tty_ldisc_lock(tty, timeout);
385 set_bit(TTY_LDISC_HALTED, &tty->flags);
387 set_bit(TTY_LDISC_HALTED, &tty2->flags);
391 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
393 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
396 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
397 struct tty_struct *tty2)
399 __tty_ldisc_unlock(tty);
401 __tty_ldisc_unlock(tty2);
405 * tty_ldisc_flush - flush line discipline queue
408 * Flush the line discipline queue (if any) and the tty flip buffers
412 void tty_ldisc_flush(struct tty_struct *tty)
414 struct tty_ldisc *ld = tty_ldisc_ref(tty);
416 tty_buffer_flush(tty, ld);
420 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
423 * tty_set_termios_ldisc - set ldisc field
424 * @tty: tty structure
425 * @disc: line discipline number
427 * This is probably overkill for real world processors but
428 * they are not on hot paths so a little discipline won't do
431 * The line discipline-related tty_struct fields are reset to
432 * prevent the ldisc driver from re-using stale information for
433 * the new ldisc instance.
435 * Locking: takes termios_rwsem
438 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
440 down_write(&tty->termios_rwsem);
441 tty->termios.c_line = disc;
442 up_write(&tty->termios_rwsem);
444 tty->disc_data = NULL;
445 tty->receive_room = 0;
449 * tty_ldisc_open - open a line discipline
450 * @tty: tty we are opening the ldisc on
451 * @ld: discipline to open
453 * A helper opening method. Also a convenient debugging and check
456 * Locking: always called with BTM already held.
459 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
461 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
464 /* BTM here locks versus a hangup event */
465 ret = ld->ops->open(tty);
467 clear_bit(TTY_LDISC_OPEN, &tty->flags);
469 tty_ldisc_debug(tty, "%p: opened\n", ld);
476 * tty_ldisc_close - close a line discipline
477 * @tty: tty we are opening the ldisc on
478 * @ld: discipline to close
480 * A helper close method. Also a convenient debugging and check
484 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
486 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
487 clear_bit(TTY_LDISC_OPEN, &tty->flags);
490 tty_ldisc_debug(tty, "%p: closed\n", ld);
494 * tty_ldisc_failto - helper for ldisc failback
495 * @tty: tty to open the ldisc on
496 * @ld: ldisc we are trying to fail back to
498 * Helper to try and recover a tty when switching back to the old
499 * ldisc fails and we need something attached.
502 static int tty_ldisc_failto(struct tty_struct *tty, int ld)
504 struct tty_ldisc *disc = tty_ldisc_get(tty, ld);
508 return PTR_ERR(disc);
510 tty_set_termios_ldisc(tty, ld);
511 if ((r = tty_ldisc_open(tty, disc)) < 0)
517 * tty_ldisc_restore - helper for tty ldisc change
518 * @tty: tty to recover
519 * @old: previous ldisc
521 * Restore the previous line discipline or N_TTY when a line discipline
522 * change fails due to an open error
525 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
527 /* There is an outstanding reference here so this is safe */
528 if (tty_ldisc_failto(tty, old->ops->num) < 0) {
529 const char *name = tty_name(tty);
531 pr_warn("Falling back ldisc for %s.\n", name);
532 /* The traditional behaviour is to fall back to N_TTY, we
533 want to avoid falling back to N_NULL unless we have no
534 choice to avoid the risk of breaking anything */
535 if (tty_ldisc_failto(tty, N_TTY) < 0 &&
536 tty_ldisc_failto(tty, N_NULL) < 0)
537 panic("Couldn't open N_NULL ldisc for %s.", name);
542 * tty_set_ldisc - set line discipline
543 * @tty: the terminal to set
544 * @ldisc: the line discipline
546 * Set the discipline of a tty line. Must be called from a process
547 * context. The ldisc change logic has to protect itself against any
548 * overlapping ldisc change (including on the other end of pty pairs),
549 * the close of one side of a tty/pty pair, and eventually hangup.
552 int tty_set_ldisc(struct tty_struct *tty, int disc)
555 struct tty_ldisc *old_ldisc, *new_ldisc;
557 new_ldisc = tty_ldisc_get(tty, disc);
558 if (IS_ERR(new_ldisc))
559 return PTR_ERR(new_ldisc);
562 retval = tty_ldisc_lock(tty, 5 * HZ);
571 /* Check the no-op case */
572 if (tty->ldisc->ops->num == disc)
575 if (test_bit(TTY_HUPPED, &tty->flags)) {
576 /* We were raced by hangup */
581 old_ldisc = tty->ldisc;
583 /* Shutdown the old discipline. */
584 tty_ldisc_close(tty, old_ldisc);
586 /* Now set up the new line discipline. */
587 tty->ldisc = new_ldisc;
588 tty_set_termios_ldisc(tty, disc);
590 retval = tty_ldisc_open(tty, new_ldisc);
592 /* Back to the old one or N_TTY if we can't */
593 tty_ldisc_put(new_ldisc);
594 tty_ldisc_restore(tty, old_ldisc);
597 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
598 down_read(&tty->termios_rwsem);
599 tty->ops->set_ldisc(tty);
600 up_read(&tty->termios_rwsem);
603 /* At this point we hold a reference to the new ldisc and a
604 reference to the old ldisc, or we hold two references to
605 the old ldisc (if it was restored as part of error cleanup
606 above). In either case, releasing a single reference from
607 the old ldisc is correct. */
608 new_ldisc = old_ldisc;
610 tty_ldisc_unlock(tty);
612 /* Restart the work queue in case no characters kick it off. Safe if
614 tty_buffer_restart_work(tty->port);
616 tty_ldisc_put(new_ldisc); /* drop the extra reference */
620 EXPORT_SYMBOL_GPL(tty_set_ldisc);
623 * tty_ldisc_kill - teardown ldisc
624 * @tty: tty being released
626 * Perform final close of the ldisc and reset tty->ldisc
628 static void tty_ldisc_kill(struct tty_struct *tty)
633 * Now kill off the ldisc
635 tty_ldisc_close(tty, tty->ldisc);
636 tty_ldisc_put(tty->ldisc);
637 /* Force an oops if we mess this up */
642 * tty_reset_termios - reset terminal state
645 * Restore a terminal to the driver default state.
648 static void tty_reset_termios(struct tty_struct *tty)
650 down_write(&tty->termios_rwsem);
651 tty->termios = tty->driver->init_termios;
652 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
653 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
654 up_write(&tty->termios_rwsem);
659 * tty_ldisc_reinit - reinitialise the tty ldisc
660 * @tty: tty to reinit
661 * @disc: line discipline to reinitialize
663 * Completely reinitialize the line discipline state, by closing the
664 * current instance, if there is one, and opening a new instance. If
665 * an error occurs opening the new non-N_TTY instance, the instance
666 * is dropped and tty->ldisc reset to NULL. The caller can then retry
667 * with N_TTY instead.
669 * Returns 0 if successful, otherwise error code < 0
672 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
674 struct tty_ldisc *ld;
677 ld = tty_ldisc_get(tty, disc);
679 BUG_ON(disc == N_TTY);
684 tty_ldisc_close(tty, tty->ldisc);
685 tty_ldisc_put(tty->ldisc);
688 /* switch the line discipline */
690 tty_set_termios_ldisc(tty, disc);
691 retval = tty_ldisc_open(tty, tty->ldisc);
693 tty_ldisc_put(tty->ldisc);
700 * tty_ldisc_hangup - hangup ldisc reset
701 * @tty: tty being hung up
703 * Some tty devices reset their termios when they receive a hangup
704 * event. In that situation we must also switch back to N_TTY properly
705 * before we reset the termios data.
707 * Locking: We can take the ldisc mutex as the rest of the code is
708 * careful to allow for this.
710 * In the pty pair case this occurs in the close() path of the
711 * tty itself so we must be careful about locking rules.
714 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
716 struct tty_ldisc *ld;
718 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
720 ld = tty_ldisc_ref(tty);
722 if (ld->ops->flush_buffer)
723 ld->ops->flush_buffer(tty);
724 tty_driver_flush_buffer(tty);
725 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
726 ld->ops->write_wakeup)
727 ld->ops->write_wakeup(tty);
729 ld->ops->hangup(tty);
733 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
734 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
737 * Shutdown the current line discipline, and reset it to
740 * Avoid racing set_ldisc or tty_ldisc_release
742 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
744 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
745 tty_reset_termios(tty);
749 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0 &&
750 tty_ldisc_reinit(tty, N_TTY) < 0)
751 WARN_ON(tty_ldisc_reinit(tty, N_NULL) < 0);
755 tty_ldisc_unlock(tty);
759 * tty_ldisc_setup - open line discipline
760 * @tty: tty being shut down
761 * @o_tty: pair tty for pty/tty pairs
763 * Called during the initial open of a tty/pty pair in order to set up the
764 * line disciplines and bind them to the tty. This has no locking issues
765 * as the device isn't yet active.
768 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
770 int retval = tty_ldisc_open(tty, tty->ldisc);
775 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
777 tty_ldisc_close(tty, tty->ldisc);
785 * tty_ldisc_release - release line discipline
786 * @tty: tty being shut down (or one end of pty pair)
788 * Called during the final close of a tty or a pty pair in order to shut
789 * down the line discpline layer. On exit, each tty's ldisc is NULL.
792 void tty_ldisc_release(struct tty_struct *tty)
794 struct tty_struct *o_tty = tty->link;
797 * Shutdown this line discipline. As this is the final close,
798 * it does not race with the set_ldisc code path.
801 tty_ldisc_lock_pair(tty, o_tty);
804 tty_ldisc_kill(o_tty);
805 tty_ldisc_unlock_pair(tty, o_tty);
807 /* And the memory resources remaining (buffers, termios) will be
808 disposed of when the kref hits zero */
810 tty_ldisc_debug(tty, "released\n");
812 EXPORT_SYMBOL_GPL(tty_ldisc_release);
815 * tty_ldisc_init - ldisc setup for new tty
816 * @tty: tty being allocated
818 * Set up the line discipline objects for a newly allocated tty. Note that
819 * the tty structure is not completely set up when this call is made.
822 int tty_ldisc_init(struct tty_struct *tty)
824 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
832 * tty_ldisc_deinit - ldisc cleanup for new tty
833 * @tty: tty that was allocated recently
835 * The tty structure must not becompletely set up (tty_ldisc_setup) when
838 void tty_ldisc_deinit(struct tty_struct *tty)
841 tty_ldisc_put(tty->ldisc);