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>
8 #include <linux/tty_driver.h>
9 #include <linux/file.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>
24 #undef LDISC_DEBUG_HANGUP
26 #ifdef LDISC_DEBUG_HANGUP
27 #define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args)
29 #define tty_ldisc_debug(tty, f, args...)
32 /* lockdep nested classes for tty->ldisc_sem */
40 * This guards the refcounted line discipline lists. The lock
41 * must be taken with irqs off because there are hangup path
42 * callers who will do ldisc lookups and cannot sleep.
45 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock
);
46 /* Line disc dispatch table */
47 static struct tty_ldisc_ops
*tty_ldiscs
[NR_LDISCS
];
50 * tty_register_ldisc - install a line discipline
52 * @new_ldisc: pointer to the ldisc object
54 * Installs a new line discipline into the kernel. The discipline
55 * is set up as unreferenced and then made available to the kernel
56 * from this point onwards.
59 * takes tty_ldiscs_lock to guard against ldisc races
62 int tty_register_ldisc(int disc
, struct tty_ldisc_ops
*new_ldisc
)
67 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
70 raw_spin_lock_irqsave(&tty_ldiscs_lock
, flags
);
71 tty_ldiscs
[disc
] = new_ldisc
;
72 new_ldisc
->num
= disc
;
73 new_ldisc
->refcount
= 0;
74 raw_spin_unlock_irqrestore(&tty_ldiscs_lock
, flags
);
78 EXPORT_SYMBOL(tty_register_ldisc
);
81 * tty_unregister_ldisc - unload a line discipline
84 * Remove a line discipline from the kernel providing it is not
88 * takes tty_ldiscs_lock to guard against ldisc races
91 int tty_unregister_ldisc(int disc
)
96 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
99 raw_spin_lock_irqsave(&tty_ldiscs_lock
, flags
);
100 if (tty_ldiscs
[disc
]->refcount
)
103 tty_ldiscs
[disc
] = NULL
;
104 raw_spin_unlock_irqrestore(&tty_ldiscs_lock
, flags
);
108 EXPORT_SYMBOL(tty_unregister_ldisc
);
110 static struct tty_ldisc_ops
*get_ldops(int disc
)
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
];
119 ret
= ERR_PTR(-EAGAIN
);
120 if (try_module_get(ldops
->owner
)) {
125 raw_spin_unlock_irqrestore(&tty_ldiscs_lock
, flags
);
129 static void put_ldops(struct tty_ldisc_ops
*ldops
)
133 raw_spin_lock_irqsave(&tty_ldiscs_lock
, flags
);
135 module_put(ldops
->owner
);
136 raw_spin_unlock_irqrestore(&tty_ldiscs_lock
, flags
);
139 static int tty_ldisc_autoload
= IS_BUILTIN(CONFIG_LDISC_AUTOLOAD
);
141 * tty_ldisc_get - take a reference to an ldisc
143 * @disc: ldisc number
145 * Takes a reference to a line discipline. Deals with refcounts and
146 * module locking counts.
148 * Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or
149 * if the discipline is not registered
150 * -EAGAIN if request_module() failed to load or register the
152 * -ENOMEM if allocation failure
154 * Otherwise, returns a pointer to the discipline and bumps the
158 * takes tty_ldiscs_lock to guard against ldisc races
161 static struct tty_ldisc
*tty_ldisc_get(struct tty_struct
*tty
, int disc
)
163 struct tty_ldisc
*ld
;
164 struct tty_ldisc_ops
*ldops
;
166 if (disc
< N_TTY
|| disc
>= NR_LDISCS
)
167 return ERR_PTR(-EINVAL
);
170 * Get the ldisc ops - we may need to request them to be loaded
171 * dynamically and try again.
173 ldops
= get_ldops(disc
);
175 if (!capable(CAP_SYS_MODULE
) && !tty_ldisc_autoload
)
176 return ERR_PTR(-EPERM
);
177 request_module("tty-ldisc-%d", disc
);
178 ldops
= get_ldops(disc
);
180 return ERR_CAST(ldops
);
184 * There is no way to handle allocation failure of only 16 bytes.
185 * Let's simplify error handling and save more memory.
187 ld
= kmalloc(sizeof(struct tty_ldisc
), GFP_KERNEL
| __GFP_NOFAIL
);
195 * tty_ldisc_put - release the ldisc
197 * Complement of tty_ldisc_get().
199 static void tty_ldisc_put(struct tty_ldisc
*ld
)
201 if (WARN_ON_ONCE(!ld
))
208 static void *tty_ldiscs_seq_start(struct seq_file
*m
, loff_t
*pos
)
210 return (*pos
< NR_LDISCS
) ? pos
: NULL
;
213 static void *tty_ldiscs_seq_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
216 return (*pos
< NR_LDISCS
) ? pos
: NULL
;
219 static void tty_ldiscs_seq_stop(struct seq_file
*m
, void *v
)
223 static int tty_ldiscs_seq_show(struct seq_file
*m
, void *v
)
225 int i
= *(loff_t
*)v
;
226 struct tty_ldisc_ops
*ldops
;
228 ldops
= get_ldops(i
);
231 seq_printf(m
, "%-10s %2d\n", ldops
->name
? ldops
->name
: "???", i
);
236 const struct seq_operations tty_ldiscs_seq_ops
= {
237 .start
= tty_ldiscs_seq_start
,
238 .next
= tty_ldiscs_seq_next
,
239 .stop
= tty_ldiscs_seq_stop
,
240 .show
= tty_ldiscs_seq_show
,
244 * tty_ldisc_ref_wait - wait for the tty ldisc
247 * Dereference the line discipline for the terminal and take a
248 * reference to it. If the line discipline is in flux then
249 * wait patiently until it changes.
251 * Returns: NULL if the tty has been hungup and not re-opened with
252 * a new file descriptor, otherwise valid ldisc reference
254 * Note 1: Must not be called from an IRQ/timer context. The caller
255 * must also be careful not to hold other locks that will deadlock
256 * against a discipline change, such as an existing ldisc reference
257 * (which we check for)
259 * Note 2: a file_operations routine (read/poll/write) should use this
260 * function to wait for any ldisc lifetime events to finish.
263 struct tty_ldisc
*tty_ldisc_ref_wait(struct tty_struct
*tty
)
265 struct tty_ldisc
*ld
;
267 ldsem_down_read(&tty
->ldisc_sem
, MAX_SCHEDULE_TIMEOUT
);
270 ldsem_up_read(&tty
->ldisc_sem
);
273 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait
);
276 * tty_ldisc_ref - get the tty ldisc
279 * Dereference the line discipline for the terminal and take a
280 * reference to it. If the line discipline is in flux then
281 * return NULL. Can be called from IRQ and timer functions.
284 struct tty_ldisc
*tty_ldisc_ref(struct tty_struct
*tty
)
286 struct tty_ldisc
*ld
= NULL
;
288 if (ldsem_down_read_trylock(&tty
->ldisc_sem
)) {
291 ldsem_up_read(&tty
->ldisc_sem
);
295 EXPORT_SYMBOL_GPL(tty_ldisc_ref
);
298 * tty_ldisc_deref - free a tty ldisc reference
299 * @ld: reference to free up
301 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
302 * be called in IRQ context.
305 void tty_ldisc_deref(struct tty_ldisc
*ld
)
307 ldsem_up_read(&ld
->tty
->ldisc_sem
);
309 EXPORT_SYMBOL_GPL(tty_ldisc_deref
);
313 __tty_ldisc_lock(struct tty_struct
*tty
, unsigned long timeout
)
315 return ldsem_down_write(&tty
->ldisc_sem
, timeout
);
319 __tty_ldisc_lock_nested(struct tty_struct
*tty
, unsigned long timeout
)
321 return ldsem_down_write_nested(&tty
->ldisc_sem
,
322 LDISC_SEM_OTHER
, timeout
);
325 static inline void __tty_ldisc_unlock(struct tty_struct
*tty
)
327 ldsem_up_write(&tty
->ldisc_sem
);
330 int tty_ldisc_lock(struct tty_struct
*tty
, unsigned long timeout
)
334 /* Kindly asking blocked readers to release the read side */
335 set_bit(TTY_LDISC_CHANGING
, &tty
->flags
);
336 wake_up_interruptible_all(&tty
->read_wait
);
337 wake_up_interruptible_all(&tty
->write_wait
);
339 ret
= __tty_ldisc_lock(tty
, timeout
);
342 set_bit(TTY_LDISC_HALTED
, &tty
->flags
);
346 void tty_ldisc_unlock(struct tty_struct
*tty
)
348 clear_bit(TTY_LDISC_HALTED
, &tty
->flags
);
349 /* Can be cleared here - ldisc_unlock will wake up writers firstly */
350 clear_bit(TTY_LDISC_CHANGING
, &tty
->flags
);
351 __tty_ldisc_unlock(tty
);
355 tty_ldisc_lock_pair_timeout(struct tty_struct
*tty
, struct tty_struct
*tty2
,
356 unsigned long timeout
)
361 ret
= __tty_ldisc_lock(tty
, timeout
);
363 ret
= __tty_ldisc_lock_nested(tty2
, timeout
);
365 __tty_ldisc_unlock(tty
);
368 /* if this is possible, it has lots of implications */
369 WARN_ON_ONCE(tty
== tty2
);
370 if (tty2
&& tty
!= tty2
) {
371 ret
= __tty_ldisc_lock(tty2
, timeout
);
373 ret
= __tty_ldisc_lock_nested(tty
, timeout
);
375 __tty_ldisc_unlock(tty2
);
378 ret
= __tty_ldisc_lock(tty
, timeout
);
384 set_bit(TTY_LDISC_HALTED
, &tty
->flags
);
386 set_bit(TTY_LDISC_HALTED
, &tty2
->flags
);
390 static void tty_ldisc_lock_pair(struct tty_struct
*tty
, struct tty_struct
*tty2
)
392 tty_ldisc_lock_pair_timeout(tty
, tty2
, MAX_SCHEDULE_TIMEOUT
);
395 static void tty_ldisc_unlock_pair(struct tty_struct
*tty
,
396 struct tty_struct
*tty2
)
398 __tty_ldisc_unlock(tty
);
400 __tty_ldisc_unlock(tty2
);
404 * tty_ldisc_flush - flush line discipline queue
407 * Flush the line discipline queue (if any) and the tty flip buffers
411 void tty_ldisc_flush(struct tty_struct
*tty
)
413 struct tty_ldisc
*ld
= tty_ldisc_ref(tty
);
415 tty_buffer_flush(tty
, ld
);
419 EXPORT_SYMBOL_GPL(tty_ldisc_flush
);
422 * tty_set_termios_ldisc - set ldisc field
423 * @tty: tty structure
424 * @disc: line discipline number
426 * This is probably overkill for real world processors but
427 * they are not on hot paths so a little discipline won't do
430 * The line discipline-related tty_struct fields are reset to
431 * prevent the ldisc driver from re-using stale information for
432 * the new ldisc instance.
434 * Locking: takes termios_rwsem
437 static void tty_set_termios_ldisc(struct tty_struct
*tty
, int disc
)
439 down_write(&tty
->termios_rwsem
);
440 tty
->termios
.c_line
= disc
;
441 up_write(&tty
->termios_rwsem
);
443 tty
->disc_data
= NULL
;
444 tty
->receive_room
= 0;
448 * tty_ldisc_open - open a line discipline
449 * @tty: tty we are opening the ldisc on
450 * @ld: discipline to open
452 * A helper opening method. Also a convenient debugging and check
455 * Locking: always called with BTM already held.
458 static int tty_ldisc_open(struct tty_struct
*tty
, struct tty_ldisc
*ld
)
460 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN
, &tty
->flags
));
463 /* BTM here locks versus a hangup event */
464 ret
= ld
->ops
->open(tty
);
466 clear_bit(TTY_LDISC_OPEN
, &tty
->flags
);
468 tty_ldisc_debug(tty
, "%p: opened\n", ld
);
475 * tty_ldisc_close - close a line discipline
476 * @tty: tty we are opening the ldisc on
477 * @ld: discipline to close
479 * A helper close method. Also a convenient debugging and check
483 static void tty_ldisc_close(struct tty_struct
*tty
, struct tty_ldisc
*ld
)
485 lockdep_assert_held_write(&tty
->ldisc_sem
);
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
);
507 lockdep_assert_held_write(&tty
->ldisc_sem
);
509 return PTR_ERR(disc
);
511 tty_set_termios_ldisc(tty
, ld
);
512 r
= tty_ldisc_open(tty
, disc
);
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 if (tty_ldisc_failto(tty
, old
->ops
->num
) < 0) {
531 const char *name
= tty_name(tty
);
533 pr_warn("Falling back ldisc for %s.\n", name
);
535 * The traditional behaviour is to fall back to N_TTY, we
536 * want to avoid falling back to N_NULL unless we have no
537 * 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.", name
);
546 * tty_set_ldisc - set line discipline
547 * @tty: the terminal to set
548 * @disc: the line discipline number
550 * Set the discipline of a tty line. Must be called from a process
551 * context. The ldisc change logic has to protect itself against any
552 * overlapping ldisc change (including on the other end of pty pairs),
553 * the close of one side of a tty/pty pair, and eventually hangup.
556 int tty_set_ldisc(struct tty_struct
*tty
, int disc
)
559 struct tty_ldisc
*old_ldisc
, *new_ldisc
;
561 new_ldisc
= tty_ldisc_get(tty
, disc
);
562 if (IS_ERR(new_ldisc
))
563 return PTR_ERR(new_ldisc
);
566 retval
= tty_ldisc_lock(tty
, 5 * HZ
);
575 /* Check the no-op case */
576 if (tty
->ldisc
->ops
->num
== disc
)
579 if (test_bit(TTY_HUPPED
, &tty
->flags
)) {
580 /* We were raced by hangup */
585 old_ldisc
= tty
->ldisc
;
587 /* Shutdown the old discipline. */
588 tty_ldisc_close(tty
, old_ldisc
);
590 /* Now set up the new line discipline. */
591 tty
->ldisc
= new_ldisc
;
592 tty_set_termios_ldisc(tty
, disc
);
594 retval
= tty_ldisc_open(tty
, new_ldisc
);
596 /* Back to the old one or N_TTY if we can't */
597 tty_ldisc_put(new_ldisc
);
598 tty_ldisc_restore(tty
, old_ldisc
);
601 if (tty
->ldisc
->ops
->num
!= old_ldisc
->ops
->num
&& tty
->ops
->set_ldisc
) {
602 down_read(&tty
->termios_rwsem
);
603 tty
->ops
->set_ldisc(tty
);
604 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.
614 new_ldisc
= old_ldisc
;
616 tty_ldisc_unlock(tty
);
619 * Restart the work queue in case no characters kick it off. Safe if
622 tty_buffer_restart_work(tty
->port
);
624 tty_ldisc_put(new_ldisc
); /* drop the extra reference */
628 EXPORT_SYMBOL_GPL(tty_set_ldisc
);
631 * tty_ldisc_kill - teardown ldisc
632 * @tty: tty being released
634 * Perform final close of the ldisc and reset tty->ldisc
636 static void tty_ldisc_kill(struct tty_struct
*tty
)
638 lockdep_assert_held_write(&tty
->ldisc_sem
);
642 * Now kill off the ldisc
644 tty_ldisc_close(tty
, tty
->ldisc
);
645 tty_ldisc_put(tty
->ldisc
);
646 /* Force an oops if we mess this up */
651 * tty_reset_termios - reset terminal state
654 * Restore a terminal to the driver default state.
657 static void tty_reset_termios(struct tty_struct
*tty
)
659 down_write(&tty
->termios_rwsem
);
660 tty
->termios
= tty
->driver
->init_termios
;
661 tty
->termios
.c_ispeed
= tty_termios_input_baud_rate(&tty
->termios
);
662 tty
->termios
.c_ospeed
= tty_termios_baud_rate(&tty
->termios
);
663 up_write(&tty
->termios_rwsem
);
668 * tty_ldisc_reinit - reinitialise the tty ldisc
669 * @tty: tty to reinit
670 * @disc: line discipline to reinitialize
672 * Completely reinitialize the line discipline state, by closing the
673 * current instance, if there is one, and opening a new instance. If
674 * an error occurs opening the new non-N_TTY instance, the instance
675 * is dropped and tty->ldisc reset to NULL. The caller can then retry
676 * with N_TTY instead.
678 * Returns 0 if successful, otherwise error code < 0
681 int tty_ldisc_reinit(struct tty_struct
*tty
, int disc
)
683 struct tty_ldisc
*ld
;
686 lockdep_assert_held_write(&tty
->ldisc_sem
);
687 ld
= tty_ldisc_get(tty
, disc
);
689 BUG_ON(disc
== N_TTY
);
694 tty_ldisc_close(tty
, tty
->ldisc
);
695 tty_ldisc_put(tty
->ldisc
);
698 /* switch the line discipline */
700 tty_set_termios_ldisc(tty
, disc
);
701 retval
= tty_ldisc_open(tty
, tty
->ldisc
);
703 tty_ldisc_put(tty
->ldisc
);
710 * tty_ldisc_hangup - hangup ldisc reset
711 * @tty: tty being hung up
712 * @reinit: whether to re-initialise the tty
714 * Some tty devices reset their termios when they receive a hangup
715 * event. In that situation we must also switch back to N_TTY properly
716 * before we reset the termios data.
718 * Locking: We can take the ldisc mutex as the rest of the code is
719 * careful to allow for this.
721 * In the pty pair case this occurs in the close() path of the
722 * tty itself so we must be careful about locking rules.
725 void tty_ldisc_hangup(struct tty_struct
*tty
, bool reinit
)
727 struct tty_ldisc
*ld
;
729 tty_ldisc_debug(tty
, "%p: hangup\n", tty
->ldisc
);
731 ld
= tty_ldisc_ref(tty
);
733 if (ld
->ops
->flush_buffer
)
734 ld
->ops
->flush_buffer(tty
);
735 tty_driver_flush_buffer(tty
);
736 if ((test_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
)) &&
737 ld
->ops
->write_wakeup
)
738 ld
->ops
->write_wakeup(tty
);
740 ld
->ops
->hangup(tty
);
744 wake_up_interruptible_poll(&tty
->write_wait
, EPOLLOUT
);
745 wake_up_interruptible_poll(&tty
->read_wait
, EPOLLIN
);
748 * Shutdown the current line discipline, and reset it to
751 * Avoid racing set_ldisc or tty_ldisc_release
753 tty_ldisc_lock(tty
, MAX_SCHEDULE_TIMEOUT
);
755 if (tty
->driver
->flags
& TTY_DRIVER_RESET_TERMIOS
)
756 tty_reset_termios(tty
);
760 if (tty_ldisc_reinit(tty
, tty
->termios
.c_line
) < 0 &&
761 tty_ldisc_reinit(tty
, N_TTY
) < 0)
762 WARN_ON(tty_ldisc_reinit(tty
, N_NULL
) < 0);
766 tty_ldisc_unlock(tty
);
770 * tty_ldisc_setup - open line discipline
771 * @tty: tty being shut down
772 * @o_tty: pair tty for pty/tty pairs
774 * Called during the initial open of a tty/pty pair in order to set up the
775 * line disciplines and bind them to the tty. This has no locking issues
776 * as the device isn't yet active.
779 int tty_ldisc_setup(struct tty_struct
*tty
, struct tty_struct
*o_tty
)
781 int retval
= tty_ldisc_open(tty
, tty
->ldisc
);
788 * Called without o_tty->ldisc_sem held, as o_tty has been
789 * just allocated and no one has a reference to it.
791 retval
= tty_ldisc_open(o_tty
, o_tty
->ldisc
);
793 tty_ldisc_close(tty
, tty
->ldisc
);
801 * tty_ldisc_release - release line discipline
802 * @tty: tty being shut down (or one end of pty pair)
804 * Called during the final close of a tty or a pty pair in order to shut
805 * down the line discpline layer. On exit, each tty's ldisc is NULL.
808 void tty_ldisc_release(struct tty_struct
*tty
)
810 struct tty_struct
*o_tty
= tty
->link
;
813 * Shutdown this line discipline. As this is the final close,
814 * it does not race with the set_ldisc code path.
817 tty_ldisc_lock_pair(tty
, o_tty
);
820 tty_ldisc_kill(o_tty
);
821 tty_ldisc_unlock_pair(tty
, o_tty
);
824 * And the memory resources remaining (buffers, termios) will be
825 * disposed of when the kref hits zero
828 tty_ldisc_debug(tty
, "released\n");
830 EXPORT_SYMBOL_GPL(tty_ldisc_release
);
833 * tty_ldisc_init - ldisc setup for new tty
834 * @tty: tty being allocated
836 * Set up the line discipline objects for a newly allocated tty. Note that
837 * the tty structure is not completely set up when this call is made.
840 int tty_ldisc_init(struct tty_struct
*tty
)
842 struct tty_ldisc
*ld
= tty_ldisc_get(tty
, N_TTY
);
851 * tty_ldisc_deinit - ldisc cleanup for new tty
852 * @tty: tty that was allocated recently
854 * The tty structure must not becompletely set up (tty_ldisc_setup) when
857 void tty_ldisc_deinit(struct tty_struct
*tty
)
859 /* no ldisc_sem, tty is being destroyed */
861 tty_ldisc_put(tty
->ldisc
);
865 static struct ctl_table tty_table
[] = {
867 .procname
= "ldisc_autoload",
868 .data
= &tty_ldisc_autoload
,
869 .maxlen
= sizeof(tty_ldisc_autoload
),
871 .proc_handler
= proc_dointvec
,
872 .extra1
= SYSCTL_ZERO
,
873 .extra2
= SYSCTL_ONE
,
878 static struct ctl_table tty_dir_table
[] = {
887 static struct ctl_table tty_root_table
[] = {
891 .child
= tty_dir_table
,
896 void tty_sysctl_init(void)
898 register_sysctl_table(tty_root_table
);