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/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>
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.
29 static DEFINE_RAW_SPINLOCK(tty_ldisc_lock
);
30 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait
);
31 /* Line disc dispatch table */
32 static struct tty_ldisc_ops
*tty_ldiscs
[NR_LDISCS
];
34 static inline struct tty_ldisc
*get_ldisc(struct tty_ldisc
*ld
)
37 atomic_inc(&ld
->users
);
41 static void put_ldisc(struct tty_ldisc
*ld
)
45 if (WARN_ON_ONCE(!ld
))
49 * If this is the last user, free the ldisc, and
50 * release the ldisc ops.
52 * We really want an "atomic_dec_and_raw_lock_irqsave()",
53 * but we don't have it, so this does it by hand.
55 raw_spin_lock_irqsave(&tty_ldisc_lock
, flags
);
56 if (atomic_dec_and_test(&ld
->users
)) {
57 struct tty_ldisc_ops
*ldo
= ld
->ops
;
60 module_put(ldo
->owner
);
61 raw_spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
66 raw_spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
68 if (waitqueue_active(&ld
->wq_idle
))
69 wake_up(&ld
->wq_idle
);
73 * tty_register_ldisc - install a line discipline
75 * @new_ldisc: pointer to the ldisc object
77 * Installs a new line discipline into the kernel. The discipline
78 * is set up as unreferenced and then made available to the kernel
79 * from this point onwards.
82 * takes tty_ldisc_lock to guard against ldisc races
85 int tty_register_ldisc(int disc
, struct tty_ldisc_ops
*new_ldisc
)
90 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
93 raw_spin_lock_irqsave(&tty_ldisc_lock
, flags
);
94 tty_ldiscs
[disc
] = new_ldisc
;
95 new_ldisc
->num
= disc
;
96 new_ldisc
->refcount
= 0;
97 raw_spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
101 EXPORT_SYMBOL(tty_register_ldisc
);
104 * tty_unregister_ldisc - unload a line discipline
105 * @disc: ldisc number
106 * @new_ldisc: pointer to the ldisc object
108 * Remove a line discipline from the kernel providing it is not
112 * takes tty_ldisc_lock to guard against ldisc races
115 int tty_unregister_ldisc(int disc
)
120 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
123 raw_spin_lock_irqsave(&tty_ldisc_lock
, flags
);
124 if (tty_ldiscs
[disc
]->refcount
)
127 tty_ldiscs
[disc
] = NULL
;
128 raw_spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
132 EXPORT_SYMBOL(tty_unregister_ldisc
);
134 static struct tty_ldisc_ops
*get_ldops(int disc
)
137 struct tty_ldisc_ops
*ldops
, *ret
;
139 raw_spin_lock_irqsave(&tty_ldisc_lock
, flags
);
140 ret
= ERR_PTR(-EINVAL
);
141 ldops
= tty_ldiscs
[disc
];
143 ret
= ERR_PTR(-EAGAIN
);
144 if (try_module_get(ldops
->owner
)) {
149 raw_spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
153 static void put_ldops(struct tty_ldisc_ops
*ldops
)
157 raw_spin_lock_irqsave(&tty_ldisc_lock
, flags
);
159 module_put(ldops
->owner
);
160 raw_spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
164 * tty_ldisc_get - take a reference to an ldisc
165 * @disc: ldisc number
167 * Takes a reference to a line discipline. Deals with refcounts and
168 * module locking counts. Returns NULL if the discipline is not available.
169 * Returns a pointer to the discipline and bumps the ref count if it is
173 * takes tty_ldisc_lock to guard against ldisc races
176 static struct tty_ldisc
*tty_ldisc_get(int disc
)
178 struct tty_ldisc
*ld
;
179 struct tty_ldisc_ops
*ldops
;
181 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
182 return ERR_PTR(-EINVAL
);
185 * Get the ldisc ops - we may need to request them to be loaded
186 * dynamically and try again.
188 ldops
= get_ldops(disc
);
190 request_module("tty-ldisc-%d", disc
);
191 ldops
= get_ldops(disc
);
193 return ERR_CAST(ldops
);
196 ld
= kmalloc(sizeof(struct tty_ldisc
), GFP_KERNEL
);
199 return ERR_PTR(-ENOMEM
);
203 atomic_set(&ld
->users
, 1);
204 init_waitqueue_head(&ld
->wq_idle
);
209 static void *tty_ldiscs_seq_start(struct seq_file
*m
, loff_t
*pos
)
211 return (*pos
< NR_LDISCS
) ? pos
: NULL
;
214 static void *tty_ldiscs_seq_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
217 return (*pos
< NR_LDISCS
) ? pos
: NULL
;
220 static void tty_ldiscs_seq_stop(struct seq_file
*m
, void *v
)
224 static int tty_ldiscs_seq_show(struct seq_file
*m
, void *v
)
226 int i
= *(loff_t
*)v
;
227 struct tty_ldisc_ops
*ldops
;
229 ldops
= get_ldops(i
);
232 seq_printf(m
, "%-10s %2d\n", ldops
->name
? ldops
->name
: "???", i
);
237 static const struct seq_operations tty_ldiscs_seq_ops
= {
238 .start
= tty_ldiscs_seq_start
,
239 .next
= tty_ldiscs_seq_next
,
240 .stop
= tty_ldiscs_seq_stop
,
241 .show
= tty_ldiscs_seq_show
,
244 static int proc_tty_ldiscs_open(struct inode
*inode
, struct file
*file
)
246 return seq_open(file
, &tty_ldiscs_seq_ops
);
249 const struct file_operations tty_ldiscs_proc_fops
= {
250 .owner
= THIS_MODULE
,
251 .open
= proc_tty_ldiscs_open
,
254 .release
= seq_release
,
258 * tty_ldisc_assign - set ldisc on a tty
259 * @tty: tty to assign
260 * @ld: line discipline
262 * Install an instance of a line discipline into a tty structure. The
263 * ldisc must have a reference count above zero to ensure it remains.
264 * The tty instance refcount starts at zero.
267 * Caller must hold references
270 static void tty_ldisc_assign(struct tty_struct
*tty
, struct tty_ldisc
*ld
)
276 * tty_ldisc_try - internal helper
279 * Make a single attempt to grab and bump the refcount on
280 * the tty ldisc. Return 0 on failure or 1 on success. This is
281 * used to implement both the waiting and non waiting versions
284 * Locking: takes tty_ldisc_lock
287 static struct tty_ldisc
*tty_ldisc_try(struct tty_struct
*tty
)
290 struct tty_ldisc
*ld
;
292 raw_spin_lock_irqsave(&tty_ldisc_lock
, flags
);
294 if (test_bit(TTY_LDISC
, &tty
->flags
))
295 ld
= get_ldisc(tty
->ldisc
);
296 raw_spin_unlock_irqrestore(&tty_ldisc_lock
, flags
);
301 * tty_ldisc_ref_wait - wait for the tty ldisc
304 * Dereference the line discipline for the terminal and take a
305 * reference to it. If the line discipline is in flux then
306 * wait patiently until it changes.
308 * Note: Must not be called from an IRQ/timer context. The caller
309 * must also be careful not to hold other locks that will deadlock
310 * against a discipline change, such as an existing ldisc reference
311 * (which we check for)
313 * Locking: call functions take tty_ldisc_lock
316 struct tty_ldisc
*tty_ldisc_ref_wait(struct tty_struct
*tty
)
318 struct tty_ldisc
*ld
;
320 /* wait_event is a macro */
321 wait_event(tty_ldisc_wait
, (ld
= tty_ldisc_try(tty
)) != NULL
);
324 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait
);
327 * tty_ldisc_ref - get the tty ldisc
330 * Dereference the line discipline for the terminal and take a
331 * reference to it. If the line discipline is in flux then
332 * return NULL. Can be called from IRQ and timer functions.
334 * Locking: called functions take tty_ldisc_lock
337 struct tty_ldisc
*tty_ldisc_ref(struct tty_struct
*tty
)
339 return tty_ldisc_try(tty
);
341 EXPORT_SYMBOL_GPL(tty_ldisc_ref
);
344 * tty_ldisc_deref - free a tty ldisc reference
345 * @ld: reference to free up
347 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
348 * be called in IRQ context.
350 * Locking: takes tty_ldisc_lock
353 void tty_ldisc_deref(struct tty_ldisc
*ld
)
357 EXPORT_SYMBOL_GPL(tty_ldisc_deref
);
359 static inline void tty_ldisc_put(struct tty_ldisc
*ld
)
365 * tty_ldisc_enable - allow ldisc use
366 * @tty: terminal to activate ldisc on
368 * Set the TTY_LDISC flag when the line discipline can be called
369 * again. Do necessary wakeups for existing sleepers. Clear the LDISC
370 * changing flag to indicate any ldisc change is now over.
372 * Note: nobody should set the TTY_LDISC bit except via this function.
373 * Clearing directly is allowed.
376 void tty_ldisc_enable(struct tty_struct
*tty
)
378 set_bit(TTY_LDISC
, &tty
->flags
);
379 clear_bit(TTY_LDISC_CHANGING
, &tty
->flags
);
380 wake_up(&tty_ldisc_wait
);
384 * tty_ldisc_flush - flush line discipline queue
387 * Flush the line discipline queue (if any) for this tty. If there
388 * is no line discipline active this is a no-op.
391 void tty_ldisc_flush(struct tty_struct
*tty
)
393 struct tty_ldisc
*ld
= tty_ldisc_ref(tty
);
395 if (ld
->ops
->flush_buffer
)
396 ld
->ops
->flush_buffer(tty
);
399 tty_buffer_flush(tty
);
401 EXPORT_SYMBOL_GPL(tty_ldisc_flush
);
404 * tty_set_termios_ldisc - set ldisc field
405 * @tty: tty structure
406 * @num: line discipline number
408 * This is probably overkill for real world processors but
409 * they are not on hot paths so a little discipline won't do
412 * Locking: takes termios_mutex
415 static void tty_set_termios_ldisc(struct tty_struct
*tty
, int num
)
417 mutex_lock(&tty
->termios_mutex
);
418 tty
->termios
.c_line
= num
;
419 mutex_unlock(&tty
->termios_mutex
);
423 * tty_ldisc_open - open a line discipline
424 * @tty: tty we are opening the ldisc on
425 * @ld: discipline to open
427 * A helper opening method. Also a convenient debugging and check
430 * Locking: always called with BTM already held.
433 static int tty_ldisc_open(struct tty_struct
*tty
, struct tty_ldisc
*ld
)
435 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN
, &tty
->flags
));
438 /* BTM here locks versus a hangup event */
439 ret
= ld
->ops
->open(tty
);
441 clear_bit(TTY_LDISC_OPEN
, &tty
->flags
);
448 * tty_ldisc_close - close a line discipline
449 * @tty: tty we are opening the ldisc on
450 * @ld: discipline to close
452 * A helper close method. Also a convenient debugging and check
456 static void tty_ldisc_close(struct tty_struct
*tty
, struct tty_ldisc
*ld
)
458 WARN_ON(!test_bit(TTY_LDISC_OPEN
, &tty
->flags
));
459 clear_bit(TTY_LDISC_OPEN
, &tty
->flags
);
465 * tty_ldisc_restore - helper for tty ldisc change
466 * @tty: tty to recover
467 * @old: previous ldisc
469 * Restore the previous line discipline or N_TTY when a line discipline
470 * change fails due to an open error
473 static void tty_ldisc_restore(struct tty_struct
*tty
, struct tty_ldisc
*old
)
476 struct tty_ldisc
*new_ldisc
;
479 /* There is an outstanding reference here so this is safe */
480 old
= tty_ldisc_get(old
->ops
->num
);
481 WARN_ON(IS_ERR(old
));
482 tty_ldisc_assign(tty
, old
);
483 tty_set_termios_ldisc(tty
, old
->ops
->num
);
484 if (tty_ldisc_open(tty
, old
) < 0) {
486 /* This driver is always present */
487 new_ldisc
= tty_ldisc_get(N_TTY
);
488 if (IS_ERR(new_ldisc
))
490 tty_ldisc_assign(tty
, new_ldisc
);
491 tty_set_termios_ldisc(tty
, N_TTY
);
492 r
= tty_ldisc_open(tty
, new_ldisc
);
494 panic("Couldn't open N_TTY ldisc for "
496 tty_name(tty
, buf
), r
);
501 * tty_ldisc_halt - shut down the line discipline
504 * Shut down the line discipline and work queue for this tty device.
505 * The TTY_LDISC flag being cleared ensures no further references can
506 * be obtained while the delayed work queue halt ensures that no more
507 * data is fed to the ldisc.
509 * You need to do a 'flush_scheduled_work()' (outside the ldisc_mutex)
510 * in order to make sure any currently executing ldisc work is also
514 static int tty_ldisc_halt(struct tty_struct
*tty
)
516 clear_bit(TTY_LDISC
, &tty
->flags
);
517 return cancel_work_sync(&tty
->port
->buf
.work
);
521 * tty_ldisc_flush_works - flush all works of a tty
522 * @tty: tty device to flush works for
524 * Sync flush all works belonging to @tty.
526 static void tty_ldisc_flush_works(struct tty_struct
*tty
)
528 flush_work(&tty
->hangup_work
);
529 flush_work(&tty
->SAK_work
);
530 flush_work(&tty
->port
->buf
.work
);
534 * tty_ldisc_wait_idle - wait for the ldisc to become idle
535 * @tty: tty to wait for
536 * @timeout: for how long to wait at most
538 * Wait for the line discipline to become idle. The discipline must
539 * have been halted for this to guarantee it remains idle.
541 static int tty_ldisc_wait_idle(struct tty_struct
*tty
, long timeout
)
544 ret
= wait_event_timeout(tty
->ldisc
->wq_idle
,
545 atomic_read(&tty
->ldisc
->users
) == 1, timeout
);
546 return ret
> 0 ? 0 : -EBUSY
;
550 * tty_set_ldisc - set line discipline
551 * @tty: the terminal to set
552 * @ldisc: the line discipline
554 * Set the discipline of a tty line. Must be called from a process
555 * context. The ldisc change logic has to protect itself against any
556 * overlapping ldisc change (including on the other end of pty pairs),
557 * the close of one side of a tty/pty pair, and eventually hangup.
559 * Locking: takes tty_ldisc_lock, termios_mutex
562 int tty_set_ldisc(struct tty_struct
*tty
, int ldisc
)
565 struct tty_ldisc
*o_ldisc
, *new_ldisc
;
566 int work
, o_work
= 0;
567 struct tty_struct
*o_tty
;
569 new_ldisc
= tty_ldisc_get(ldisc
);
570 if (IS_ERR(new_ldisc
))
571 return PTR_ERR(new_ldisc
);
575 * We need to look at the tty locking here for pty/tty pairs
576 * when both sides try to change in parallel.
579 o_tty
= tty
->link
; /* o_tty is the pty side or NULL */
583 * Check the no-op case
586 if (tty
->ldisc
->ops
->num
== ldisc
) {
588 tty_ldisc_put(new_ldisc
);
594 * Problem: What do we do if this blocks ?
595 * We could deadlock here
598 tty_wait_until_sent(tty
, 0);
601 mutex_lock(&tty
->ldisc_mutex
);
604 * We could be midstream of another ldisc change which has
605 * dropped the lock during processing. If so we need to wait.
608 while (test_bit(TTY_LDISC_CHANGING
, &tty
->flags
)) {
609 mutex_unlock(&tty
->ldisc_mutex
);
611 wait_event(tty_ldisc_wait
,
612 test_bit(TTY_LDISC_CHANGING
, &tty
->flags
) == 0);
614 mutex_lock(&tty
->ldisc_mutex
);
617 set_bit(TTY_LDISC_CHANGING
, &tty
->flags
);
620 * No more input please, we are switching. The new ldisc
621 * will update this value in the ldisc open function
624 tty
->receive_room
= 0;
626 o_ldisc
= tty
->ldisc
;
630 * Make sure we don't change while someone holds a
631 * reference to the line discipline. The TTY_LDISC bit
632 * prevents anyone taking a reference once it is clear.
633 * We need the lock to avoid racing reference takers.
635 * We must clear the TTY_LDISC bit here to avoid a livelock
636 * with a userspace app continually trying to use the tty in
637 * parallel to the change and re-referencing the tty.
640 work
= tty_ldisc_halt(tty
);
642 o_work
= tty_ldisc_halt(o_tty
);
645 * Wait for ->hangup_work and ->buf.work handlers to terminate.
646 * We must drop the mutex here in case a hangup is also in process.
649 mutex_unlock(&tty
->ldisc_mutex
);
651 tty_ldisc_flush_works(tty
);
653 retval
= tty_ldisc_wait_idle(tty
, 5 * HZ
);
656 mutex_lock(&tty
->ldisc_mutex
);
658 /* handle wait idle failure locked */
660 tty_ldisc_put(new_ldisc
);
664 if (test_bit(TTY_HUPPING
, &tty
->flags
)) {
665 /* We were raced by the hangup method. It will have stomped
666 the ldisc data and closed the ldisc down */
667 clear_bit(TTY_LDISC_CHANGING
, &tty
->flags
);
668 mutex_unlock(&tty
->ldisc_mutex
);
669 tty_ldisc_put(new_ldisc
);
674 /* Shutdown the current discipline. */
675 tty_ldisc_close(tty
, o_ldisc
);
677 /* Now set up the new line discipline. */
678 tty_ldisc_assign(tty
, new_ldisc
);
679 tty_set_termios_ldisc(tty
, ldisc
);
681 retval
= tty_ldisc_open(tty
, new_ldisc
);
683 /* Back to the old one or N_TTY if we can't */
684 tty_ldisc_put(new_ldisc
);
685 tty_ldisc_restore(tty
, o_ldisc
);
688 /* At this point we hold a reference to the new ldisc and a
689 a reference to the old ldisc. If we ended up flipping back
690 to the existing ldisc we have two references to it */
692 if (tty
->ldisc
->ops
->num
!= o_ldisc
->ops
->num
&& tty
->ops
->set_ldisc
)
693 tty
->ops
->set_ldisc(tty
);
695 tty_ldisc_put(o_ldisc
);
699 * Allow ldisc referencing to occur again
702 tty_ldisc_enable(tty
);
704 tty_ldisc_enable(o_tty
);
706 /* Restart the work queue in case no characters kick it off. Safe if
709 schedule_work(&tty
->port
->buf
.work
);
711 schedule_work(&o_tty
->port
->buf
.work
);
712 mutex_unlock(&tty
->ldisc_mutex
);
718 * tty_reset_termios - reset terminal state
721 * Restore a terminal to the driver default state.
724 static void tty_reset_termios(struct tty_struct
*tty
)
726 mutex_lock(&tty
->termios_mutex
);
727 tty
->termios
= tty
->driver
->init_termios
;
728 tty
->termios
.c_ispeed
= tty_termios_input_baud_rate(&tty
->termios
);
729 tty
->termios
.c_ospeed
= tty_termios_baud_rate(&tty
->termios
);
730 mutex_unlock(&tty
->termios_mutex
);
735 * tty_ldisc_reinit - reinitialise the tty ldisc
736 * @tty: tty to reinit
737 * @ldisc: line discipline to reinitialize
739 * Switch the tty to a line discipline and leave the ldisc
743 static int tty_ldisc_reinit(struct tty_struct
*tty
, int ldisc
)
745 struct tty_ldisc
*ld
= tty_ldisc_get(ldisc
);
750 tty_ldisc_close(tty
, tty
->ldisc
);
751 tty_ldisc_put(tty
->ldisc
);
754 * Switch the line discipline back
756 tty_ldisc_assign(tty
, ld
);
757 tty_set_termios_ldisc(tty
, ldisc
);
763 * tty_ldisc_hangup - hangup ldisc reset
764 * @tty: tty being hung up
766 * Some tty devices reset their termios when they receive a hangup
767 * event. In that situation we must also switch back to N_TTY properly
768 * before we reset the termios data.
770 * Locking: We can take the ldisc mutex as the rest of the code is
771 * careful to allow for this.
773 * In the pty pair case this occurs in the close() path of the
774 * tty itself so we must be careful about locking rules.
777 void tty_ldisc_hangup(struct tty_struct
*tty
)
779 struct tty_ldisc
*ld
;
780 int reset
= tty
->driver
->flags
& TTY_DRIVER_RESET_TERMIOS
;
784 * FIXME! What are the locking issues here? This may me overdoing
785 * things... This question is especially important now that we've
786 * removed the irqlock.
788 ld
= tty_ldisc_ref(tty
);
790 /* We may have no line discipline at this point */
791 if (ld
->ops
->flush_buffer
)
792 ld
->ops
->flush_buffer(tty
);
793 tty_driver_flush_buffer(tty
);
794 if ((test_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
)) &&
795 ld
->ops
->write_wakeup
)
796 ld
->ops
->write_wakeup(tty
);
798 ld
->ops
->hangup(tty
);
802 * FIXME: Once we trust the LDISC code better we can wait here for
803 * ldisc completion and fix the driver call race
805 wake_up_interruptible_poll(&tty
->write_wait
, POLLOUT
);
806 wake_up_interruptible_poll(&tty
->read_wait
, POLLIN
);
808 * Shutdown the current line discipline, and reset it to
811 * Avoid racing set_ldisc or tty_ldisc_release
813 mutex_lock(&tty
->ldisc_mutex
);
816 * this is like tty_ldisc_halt, but we need to give up
817 * the BTM before calling cancel_work_sync, which may
818 * need to wait for another function taking the BTM
820 clear_bit(TTY_LDISC
, &tty
->flags
);
822 cancel_work_sync(&tty
->port
->buf
.work
);
823 mutex_unlock(&tty
->ldisc_mutex
);
826 mutex_lock(&tty
->ldisc_mutex
);
828 /* At this point we have a closed ldisc and we want to
829 reopen it. We could defer this to the next open but
830 it means auditing a lot of other paths so this is
832 if (tty
->ldisc
) { /* Not yet closed */
833 if (atomic_read(&tty
->ldisc
->users
) != 1) {
834 char cur_n
[TASK_COMM_LEN
], tty_n
[64];
835 long timeout
= 3 * HZ
;
838 while (tty_ldisc_wait_idle(tty
, timeout
) == -EBUSY
) {
839 timeout
= MAX_SCHEDULE_TIMEOUT
;
840 printk_ratelimited(KERN_WARNING
841 "%s: waiting (%s) for %s took too long, but we keep waiting...\n",
842 __func__
, get_task_comm(cur_n
, current
),
843 tty_name(tty
, tty_n
));
845 mutex_unlock(&tty
->ldisc_mutex
);
851 if (!tty_ldisc_reinit(tty
, tty
->termios
.c_line
))
852 err
= tty_ldisc_open(tty
, tty
->ldisc
);
856 /* If the re-open fails or we reset then go to N_TTY. The
857 N_TTY open cannot fail */
859 BUG_ON(tty_ldisc_reinit(tty
, N_TTY
));
860 WARN_ON(tty_ldisc_open(tty
, tty
->ldisc
));
862 tty_ldisc_enable(tty
);
864 mutex_unlock(&tty
->ldisc_mutex
);
866 tty_reset_termios(tty
);
870 * tty_ldisc_setup - open line discipline
871 * @tty: tty being shut down
872 * @o_tty: pair tty for pty/tty pairs
874 * Called during the initial open of a tty/pty pair in order to set up the
875 * line disciplines and bind them to the tty. This has no locking issues
876 * as the device isn't yet active.
879 int tty_ldisc_setup(struct tty_struct
*tty
, struct tty_struct
*o_tty
)
881 struct tty_ldisc
*ld
= tty
->ldisc
;
884 retval
= tty_ldisc_open(tty
, ld
);
889 retval
= tty_ldisc_open(o_tty
, o_tty
->ldisc
);
891 tty_ldisc_close(tty
, ld
);
894 tty_ldisc_enable(o_tty
);
896 tty_ldisc_enable(tty
);
900 static void tty_ldisc_kill(struct tty_struct
*tty
)
902 /* There cannot be users from userspace now. But there still might be
903 * drivers holding a reference via tty_ldisc_ref. Do not steal them the
904 * ldisc until they are done. */
905 tty_ldisc_wait_idle(tty
, MAX_SCHEDULE_TIMEOUT
);
907 mutex_lock(&tty
->ldisc_mutex
);
909 * Now kill off the ldisc
911 tty_ldisc_close(tty
, tty
->ldisc
);
912 tty_ldisc_put(tty
->ldisc
);
913 /* Force an oops if we mess this up */
916 /* Ensure the next open requests the N_TTY ldisc */
917 tty_set_termios_ldisc(tty
, N_TTY
);
918 mutex_unlock(&tty
->ldisc_mutex
);
922 * tty_ldisc_release - release line discipline
923 * @tty: tty being shut down
924 * @o_tty: pair tty for pty/tty pairs
926 * Called during the final close of a tty/pty pair in order to shut down
927 * the line discpline layer. On exit the ldisc assigned is N_TTY and the
928 * ldisc has not been opened.
931 void tty_ldisc_release(struct tty_struct
*tty
, struct tty_struct
*o_tty
)
934 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
935 * kill any delayed work. As this is the final close it does not
936 * race with the set_ldisc code path.
941 tty_ldisc_halt(o_tty
);
943 tty_ldisc_flush_works(tty
);
945 tty_ldisc_flush_works(o_tty
);
947 tty_lock_pair(tty
, o_tty
);
948 /* This will need doing differently if we need to lock */
951 tty_ldisc_kill(o_tty
);
953 tty_unlock_pair(tty
, o_tty
);
954 /* And the memory resources remaining (buffers, termios) will be
955 disposed of when the kref hits zero */
959 * tty_ldisc_init - ldisc setup for new tty
960 * @tty: tty being allocated
962 * Set up the line discipline objects for a newly allocated tty. Note that
963 * the tty structure is not completely set up when this call is made.
966 void tty_ldisc_init(struct tty_struct
*tty
)
968 struct tty_ldisc
*ld
= tty_ldisc_get(N_TTY
);
970 panic("n_tty: init_tty");
971 tty_ldisc_assign(tty
, ld
);
975 * tty_ldisc_init - ldisc cleanup for new tty
976 * @tty: tty that was allocated recently
978 * The tty structure must not becompletely set up (tty_ldisc_setup) when
981 void tty_ldisc_deinit(struct tty_struct
*tty
)
983 put_ldisc(tty
->ldisc
);
984 tty_ldisc_assign(tty
, NULL
);
987 void tty_ldisc_begin(void)
989 /* Setup the default TTY line discipline. */
990 (void) tty_register_ldisc(N_TTY
, &tty_ldisc_N_TTY
);