Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / tty / tty_ldisc.c
blob050f4d650891763f96800244869821afb9d1586e
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/types.h>
3 #include <linux/errno.h>
4 #include <linux/kmod.h>
5 #include <linux/sched.h>
6 #include <linux/interrupt.h>
7 #include <linux/tty.h>
8 #include <linux/tty_driver.h>
9 #include <linux/file.h>
10 #include <linux/mm.h>
11 #include <linux/string.h>
12 #include <linux/slab.h>
13 #include <linux/poll.h>
14 #include <linux/proc_fs.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>
23 #undef LDISC_DEBUG_HANGUP
25 #ifdef LDISC_DEBUG_HANGUP
26 #define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args)
27 #else
28 #define tty_ldisc_debug(tty, f, args...)
29 #endif
31 /* lockdep nested classes for tty->ldisc_sem */
32 enum {
33 LDISC_SEM_NORMAL,
34 LDISC_SEM_OTHER,
39 * This guards the refcounted line discipline lists. The lock
40 * must be taken with irqs off because there are hangup path
41 * callers who will do ldisc lookups and cannot sleep.
44 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
45 /* Line disc dispatch table */
46 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
48 /**
49 * tty_register_ldisc - install a line discipline
50 * @disc: ldisc number
51 * @new_ldisc: pointer to the ldisc object
53 * Installs a new line discipline into the kernel. The discipline
54 * is set up as unreferenced and then made available to the kernel
55 * from this point onwards.
57 * Locking:
58 * takes tty_ldiscs_lock to guard against ldisc races
61 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
63 unsigned long flags;
64 int ret = 0;
66 if (disc < N_TTY || disc >= NR_LDISCS)
67 return -EINVAL;
69 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
70 tty_ldiscs[disc] = new_ldisc;
71 new_ldisc->num = disc;
72 new_ldisc->refcount = 0;
73 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
75 return ret;
77 EXPORT_SYMBOL(tty_register_ldisc);
79 /**
80 * tty_unregister_ldisc - unload a line discipline
81 * @disc: ldisc number
82 * @new_ldisc: pointer to the ldisc object
84 * Remove a line discipline from the kernel providing it is not
85 * currently in use.
87 * Locking:
88 * takes tty_ldiscs_lock to guard against ldisc races
91 int tty_unregister_ldisc(int disc)
93 unsigned long flags;
94 int ret = 0;
96 if (disc < N_TTY || disc >= NR_LDISCS)
97 return -EINVAL;
99 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
100 if (tty_ldiscs[disc]->refcount)
101 ret = -EBUSY;
102 else
103 tty_ldiscs[disc] = NULL;
104 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
106 return ret;
108 EXPORT_SYMBOL(tty_unregister_ldisc);
110 static struct tty_ldisc_ops *get_ldops(int disc)
112 unsigned long flags;
113 struct tty_ldisc_ops *ldops, *ret;
115 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
116 ret = ERR_PTR(-EINVAL);
117 ldops = tty_ldiscs[disc];
118 if (ldops) {
119 ret = ERR_PTR(-EAGAIN);
120 if (try_module_get(ldops->owner)) {
121 ldops->refcount++;
122 ret = ldops;
125 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
126 return ret;
129 static void put_ldops(struct tty_ldisc_ops *ldops)
131 unsigned long flags;
133 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
134 ldops->refcount--;
135 module_put(ldops->owner);
136 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
140 * tty_ldisc_get - take a reference to an ldisc
141 * @disc: ldisc number
143 * Takes a reference to a line discipline. Deals with refcounts and
144 * module locking counts.
146 * Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or
147 * if the discipline is not registered
148 * -EAGAIN if request_module() failed to load or register the
149 * the discipline
150 * -ENOMEM if allocation failure
152 * Otherwise, returns a pointer to the discipline and bumps the
153 * ref count
155 * Locking:
156 * takes tty_ldiscs_lock to guard against ldisc races
159 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
161 struct tty_ldisc *ld;
162 struct tty_ldisc_ops *ldops;
164 if (disc < N_TTY || disc >= NR_LDISCS)
165 return ERR_PTR(-EINVAL);
168 * Get the ldisc ops - we may need to request them to be loaded
169 * dynamically and try again.
171 ldops = get_ldops(disc);
172 if (IS_ERR(ldops)) {
173 request_module("tty-ldisc-%d", disc);
174 ldops = get_ldops(disc);
175 if (IS_ERR(ldops))
176 return ERR_CAST(ldops);
179 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
180 if (ld == NULL) {
181 put_ldops(ldops);
182 return ERR_PTR(-ENOMEM);
185 ld->ops = ldops;
186 ld->tty = tty;
188 return ld;
192 * tty_ldisc_put - release the ldisc
194 * Complement of tty_ldisc_get().
196 static void tty_ldisc_put(struct tty_ldisc *ld)
198 if (WARN_ON_ONCE(!ld))
199 return;
201 put_ldops(ld->ops);
202 kfree(ld);
205 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
207 return (*pos < NR_LDISCS) ? pos : NULL;
210 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
212 (*pos)++;
213 return (*pos < NR_LDISCS) ? pos : NULL;
216 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
220 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
222 int i = *(loff_t *)v;
223 struct tty_ldisc_ops *ldops;
225 ldops = get_ldops(i);
226 if (IS_ERR(ldops))
227 return 0;
228 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
229 put_ldops(ldops);
230 return 0;
233 static const struct seq_operations tty_ldiscs_seq_ops = {
234 .start = tty_ldiscs_seq_start,
235 .next = tty_ldiscs_seq_next,
236 .stop = tty_ldiscs_seq_stop,
237 .show = tty_ldiscs_seq_show,
240 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
242 return seq_open(file, &tty_ldiscs_seq_ops);
245 const struct file_operations tty_ldiscs_proc_fops = {
246 .owner = THIS_MODULE,
247 .open = proc_tty_ldiscs_open,
248 .read = seq_read,
249 .llseek = seq_lseek,
250 .release = seq_release,
254 * tty_ldisc_ref_wait - wait for the tty ldisc
255 * @tty: tty device
257 * Dereference the line discipline for the terminal and take a
258 * reference to it. If the line discipline is in flux then
259 * wait patiently until it changes.
261 * Returns: NULL if the tty has been hungup and not re-opened with
262 * a new file descriptor, otherwise valid ldisc reference
264 * Note: Must not be called from an IRQ/timer context. The caller
265 * must also be careful not to hold other locks that will deadlock
266 * against a discipline change, such as an existing ldisc reference
267 * (which we check for)
269 * Note: a file_operations routine (read/poll/write) should use this
270 * function to wait for any ldisc lifetime events to finish.
273 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
275 struct tty_ldisc *ld;
277 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
278 ld = tty->ldisc;
279 if (!ld)
280 ldsem_up_read(&tty->ldisc_sem);
281 return ld;
283 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
286 * tty_ldisc_ref - get the tty ldisc
287 * @tty: tty device
289 * Dereference the line discipline for the terminal and take a
290 * reference to it. If the line discipline is in flux then
291 * return NULL. Can be called from IRQ and timer functions.
294 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
296 struct tty_ldisc *ld = NULL;
298 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
299 ld = tty->ldisc;
300 if (!ld)
301 ldsem_up_read(&tty->ldisc_sem);
303 return ld;
305 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
308 * tty_ldisc_deref - free a tty ldisc reference
309 * @ld: reference to free up
311 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
312 * be called in IRQ context.
315 void tty_ldisc_deref(struct tty_ldisc *ld)
317 ldsem_up_read(&ld->tty->ldisc_sem);
319 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
322 static inline int
323 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
325 return ldsem_down_write(&tty->ldisc_sem, timeout);
328 static inline int
329 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
331 return ldsem_down_write_nested(&tty->ldisc_sem,
332 LDISC_SEM_OTHER, timeout);
335 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
337 ldsem_up_write(&tty->ldisc_sem);
340 int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
342 int ret;
344 ret = __tty_ldisc_lock(tty, timeout);
345 if (!ret)
346 return -EBUSY;
347 set_bit(TTY_LDISC_HALTED, &tty->flags);
348 return 0;
351 void tty_ldisc_unlock(struct tty_struct *tty)
353 clear_bit(TTY_LDISC_HALTED, &tty->flags);
354 __tty_ldisc_unlock(tty);
357 static int
358 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
359 unsigned long timeout)
361 int ret;
363 if (tty < tty2) {
364 ret = __tty_ldisc_lock(tty, timeout);
365 if (ret) {
366 ret = __tty_ldisc_lock_nested(tty2, timeout);
367 if (!ret)
368 __tty_ldisc_unlock(tty);
370 } else {
371 /* if this is possible, it has lots of implications */
372 WARN_ON_ONCE(tty == tty2);
373 if (tty2 && tty != tty2) {
374 ret = __tty_ldisc_lock(tty2, timeout);
375 if (ret) {
376 ret = __tty_ldisc_lock_nested(tty, timeout);
377 if (!ret)
378 __tty_ldisc_unlock(tty2);
380 } else
381 ret = __tty_ldisc_lock(tty, timeout);
384 if (!ret)
385 return -EBUSY;
387 set_bit(TTY_LDISC_HALTED, &tty->flags);
388 if (tty2)
389 set_bit(TTY_LDISC_HALTED, &tty2->flags);
390 return 0;
393 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
395 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
398 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
399 struct tty_struct *tty2)
401 __tty_ldisc_unlock(tty);
402 if (tty2)
403 __tty_ldisc_unlock(tty2);
407 * tty_ldisc_flush - flush line discipline queue
408 * @tty: tty
410 * Flush the line discipline queue (if any) and the tty flip buffers
411 * for this tty.
414 void tty_ldisc_flush(struct tty_struct *tty)
416 struct tty_ldisc *ld = tty_ldisc_ref(tty);
418 tty_buffer_flush(tty, ld);
419 if (ld)
420 tty_ldisc_deref(ld);
422 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
425 * tty_set_termios_ldisc - set ldisc field
426 * @tty: tty structure
427 * @disc: line discipline number
429 * This is probably overkill for real world processors but
430 * they are not on hot paths so a little discipline won't do
431 * any harm.
433 * The line discipline-related tty_struct fields are reset to
434 * prevent the ldisc driver from re-using stale information for
435 * the new ldisc instance.
437 * Locking: takes termios_rwsem
440 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
442 down_write(&tty->termios_rwsem);
443 tty->termios.c_line = disc;
444 up_write(&tty->termios_rwsem);
446 tty->disc_data = NULL;
447 tty->receive_room = 0;
451 * tty_ldisc_open - open a line discipline
452 * @tty: tty we are opening the ldisc on
453 * @ld: discipline to open
455 * A helper opening method. Also a convenient debugging and check
456 * point.
458 * Locking: always called with BTM already held.
461 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
463 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
464 if (ld->ops->open) {
465 int ret;
466 /* BTM here locks versus a hangup event */
467 ret = ld->ops->open(tty);
468 if (ret)
469 clear_bit(TTY_LDISC_OPEN, &tty->flags);
471 tty_ldisc_debug(tty, "%p: opened\n", ld);
472 return ret;
474 return 0;
478 * tty_ldisc_close - close a line discipline
479 * @tty: tty we are opening the ldisc on
480 * @ld: discipline to close
482 * A helper close method. Also a convenient debugging and check
483 * point.
486 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
488 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
489 clear_bit(TTY_LDISC_OPEN, &tty->flags);
490 if (ld->ops->close)
491 ld->ops->close(tty);
492 tty_ldisc_debug(tty, "%p: closed\n", ld);
496 * tty_ldisc_failto - helper for ldisc failback
497 * @tty: tty to open the ldisc on
498 * @ld: ldisc we are trying to fail back to
500 * Helper to try and recover a tty when switching back to the old
501 * ldisc fails and we need something attached.
504 static int tty_ldisc_failto(struct tty_struct *tty, int ld)
506 struct tty_ldisc *disc = tty_ldisc_get(tty, ld);
507 int r;
509 if (IS_ERR(disc))
510 return PTR_ERR(disc);
511 tty->ldisc = disc;
512 tty_set_termios_ldisc(tty, ld);
513 if ((r = tty_ldisc_open(tty, disc)) < 0)
514 tty_ldisc_put(disc);
515 return r;
519 * tty_ldisc_restore - helper for tty ldisc change
520 * @tty: tty to recover
521 * @old: previous ldisc
523 * Restore the previous line discipline or N_TTY when a line discipline
524 * change fails due to an open error
527 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
529 /* There is an outstanding reference here so this is safe */
530 old = tty_ldisc_get(tty, old->ops->num);
531 WARN_ON(IS_ERR(old));
532 tty->ldisc = old;
533 tty_set_termios_ldisc(tty, old->ops->num);
534 if (tty_ldisc_open(tty, old) < 0) {
535 tty_ldisc_put(old);
536 /* The traditional behaviour is to fall back to N_TTY, we
537 want to avoid falling back to N_NULL unless we have no
538 choice to avoid the risk of breaking anything */
539 if (tty_ldisc_failto(tty, N_TTY) < 0 &&
540 tty_ldisc_failto(tty, N_NULL) < 0)
541 panic("Couldn't open N_NULL ldisc for %s.",
542 tty_name(tty));
547 * tty_set_ldisc - set line discipline
548 * @tty: the terminal to set
549 * @ldisc: the line discipline
551 * Set the discipline of a tty line. Must be called from a process
552 * context. The ldisc change logic has to protect itself against any
553 * overlapping ldisc change (including on the other end of pty pairs),
554 * the close of one side of a tty/pty pair, and eventually hangup.
557 int tty_set_ldisc(struct tty_struct *tty, int disc)
559 int retval;
560 struct tty_ldisc *old_ldisc, *new_ldisc;
562 new_ldisc = tty_ldisc_get(tty, disc);
563 if (IS_ERR(new_ldisc))
564 return PTR_ERR(new_ldisc);
566 tty_lock(tty);
567 retval = tty_ldisc_lock(tty, 5 * HZ);
568 if (retval)
569 goto err;
571 if (!tty->ldisc) {
572 retval = -EIO;
573 goto out;
576 /* Check the no-op case */
577 if (tty->ldisc->ops->num == disc)
578 goto out;
580 if (test_bit(TTY_HUPPED, &tty->flags)) {
581 /* We were raced by hangup */
582 retval = -EIO;
583 goto out;
586 old_ldisc = tty->ldisc;
588 /* Shutdown the old discipline. */
589 tty_ldisc_close(tty, old_ldisc);
591 /* Now set up the new line discipline. */
592 tty->ldisc = new_ldisc;
593 tty_set_termios_ldisc(tty, disc);
595 retval = tty_ldisc_open(tty, new_ldisc);
596 if (retval < 0) {
597 /* Back to the old one or N_TTY if we can't */
598 tty_ldisc_put(new_ldisc);
599 tty_ldisc_restore(tty, old_ldisc);
602 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
603 down_read(&tty->termios_rwsem);
604 tty->ops->set_ldisc(tty);
605 up_read(&tty->termios_rwsem);
608 /* At this point we hold a reference to the new ldisc and a
609 reference to the old ldisc, or we hold two references to
610 the old ldisc (if it was restored as part of error cleanup
611 above). In either case, releasing a single reference from
612 the old ldisc is correct. */
613 new_ldisc = old_ldisc;
614 out:
615 tty_ldisc_unlock(tty);
617 /* Restart the work queue in case no characters kick it off. Safe if
618 already running */
619 tty_buffer_restart_work(tty->port);
620 err:
621 tty_ldisc_put(new_ldisc); /* drop the extra reference */
622 tty_unlock(tty);
623 return retval;
625 EXPORT_SYMBOL_GPL(tty_set_ldisc);
628 * tty_ldisc_kill - teardown ldisc
629 * @tty: tty being released
631 * Perform final close of the ldisc and reset tty->ldisc
633 static void tty_ldisc_kill(struct tty_struct *tty)
635 if (!tty->ldisc)
636 return;
638 * Now kill off the ldisc
640 tty_ldisc_close(tty, tty->ldisc);
641 tty_ldisc_put(tty->ldisc);
642 /* Force an oops if we mess this up */
643 tty->ldisc = NULL;
647 * tty_reset_termios - reset terminal state
648 * @tty: tty to reset
650 * Restore a terminal to the driver default state.
653 static void tty_reset_termios(struct tty_struct *tty)
655 down_write(&tty->termios_rwsem);
656 tty->termios = tty->driver->init_termios;
657 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
658 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
659 up_write(&tty->termios_rwsem);
664 * tty_ldisc_reinit - reinitialise the tty ldisc
665 * @tty: tty to reinit
666 * @disc: line discipline to reinitialize
668 * Completely reinitialize the line discipline state, by closing the
669 * current instance, if there is one, and opening a new instance. If
670 * an error occurs opening the new non-N_TTY instance, the instance
671 * is dropped and tty->ldisc reset to NULL. The caller can then retry
672 * with N_TTY instead.
674 * Returns 0 if successful, otherwise error code < 0
677 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
679 struct tty_ldisc *ld;
680 int retval;
682 ld = tty_ldisc_get(tty, disc);
683 if (IS_ERR(ld)) {
684 BUG_ON(disc == N_TTY);
685 return PTR_ERR(ld);
688 if (tty->ldisc) {
689 tty_ldisc_close(tty, tty->ldisc);
690 tty_ldisc_put(tty->ldisc);
693 /* switch the line discipline */
694 tty->ldisc = ld;
695 tty_set_termios_ldisc(tty, disc);
696 retval = tty_ldisc_open(tty, tty->ldisc);
697 if (retval) {
698 tty_ldisc_put(tty->ldisc);
699 tty->ldisc = NULL;
701 return retval;
705 * tty_ldisc_hangup - hangup ldisc reset
706 * @tty: tty being hung up
708 * Some tty devices reset their termios when they receive a hangup
709 * event. In that situation we must also switch back to N_TTY properly
710 * before we reset the termios data.
712 * Locking: We can take the ldisc mutex as the rest of the code is
713 * careful to allow for this.
715 * In the pty pair case this occurs in the close() path of the
716 * tty itself so we must be careful about locking rules.
719 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
721 struct tty_ldisc *ld;
723 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
725 ld = tty_ldisc_ref(tty);
726 if (ld != NULL) {
727 if (ld->ops->flush_buffer)
728 ld->ops->flush_buffer(tty);
729 tty_driver_flush_buffer(tty);
730 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
731 ld->ops->write_wakeup)
732 ld->ops->write_wakeup(tty);
733 if (ld->ops->hangup)
734 ld->ops->hangup(tty);
735 tty_ldisc_deref(ld);
738 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
739 wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
742 * Shutdown the current line discipline, and reset it to
743 * N_TTY if need be.
745 * Avoid racing set_ldisc or tty_ldisc_release
747 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
749 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
750 tty_reset_termios(tty);
752 if (tty->ldisc) {
753 if (reinit) {
754 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0 &&
755 tty_ldisc_reinit(tty, N_TTY) < 0)
756 WARN_ON(tty_ldisc_reinit(tty, N_NULL) < 0);
757 } else
758 tty_ldisc_kill(tty);
760 tty_ldisc_unlock(tty);
764 * tty_ldisc_setup - open line discipline
765 * @tty: tty being shut down
766 * @o_tty: pair tty for pty/tty pairs
768 * Called during the initial open of a tty/pty pair in order to set up the
769 * line disciplines and bind them to the tty. This has no locking issues
770 * as the device isn't yet active.
773 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
775 int retval = tty_ldisc_open(tty, tty->ldisc);
776 if (retval)
777 return retval;
779 if (o_tty) {
780 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
781 if (retval) {
782 tty_ldisc_close(tty, tty->ldisc);
783 return retval;
786 return 0;
790 * tty_ldisc_release - release line discipline
791 * @tty: tty being shut down (or one end of pty pair)
793 * Called during the final close of a tty or a pty pair in order to shut
794 * down the line discpline layer. On exit, each tty's ldisc is NULL.
797 void tty_ldisc_release(struct tty_struct *tty)
799 struct tty_struct *o_tty = tty->link;
802 * Shutdown this line discipline. As this is the final close,
803 * it does not race with the set_ldisc code path.
806 tty_ldisc_lock_pair(tty, o_tty);
807 tty_ldisc_kill(tty);
808 if (o_tty)
809 tty_ldisc_kill(o_tty);
810 tty_ldisc_unlock_pair(tty, o_tty);
812 /* And the memory resources remaining (buffers, termios) will be
813 disposed of when the kref hits zero */
815 tty_ldisc_debug(tty, "released\n");
817 EXPORT_SYMBOL_GPL(tty_ldisc_release);
820 * tty_ldisc_init - ldisc setup for new tty
821 * @tty: tty being allocated
823 * Set up the line discipline objects for a newly allocated tty. Note that
824 * the tty structure is not completely set up when this call is made.
827 void tty_ldisc_init(struct tty_struct *tty)
829 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
830 if (IS_ERR(ld))
831 panic("n_tty: init_tty");
832 tty->ldisc = ld;
836 * tty_ldisc_deinit - ldisc cleanup for new tty
837 * @tty: tty that was allocated recently
839 * The tty structure must not becompletely set up (tty_ldisc_setup) when
840 * this call is made.
842 void tty_ldisc_deinit(struct tty_struct *tty)
844 if (tty->ldisc)
845 tty_ldisc_put(tty->ldisc);
846 tty->ldisc = NULL;