tty: Fix PPP hang under load
[linux-2.6.git] / drivers / char / tty_ldisc.c
1 #include <linux/types.h>
2 #include <linux/major.h>
3 #include <linux/errno.h>
4 #include <linux/signal.h>
5 #include <linux/fcntl.h>
6 #include <linux/sched.h>
7 #include <linux/interrupt.h>
8 #include <linux/tty.h>
9 #include <linux/tty_driver.h>
10 #include <linux/tty_flip.h>
11 #include <linux/devpts_fs.h>
12 #include <linux/file.h>
13 #include <linux/fdtable.h>
14 #include <linux/console.h>
15 #include <linux/timer.h>
16 #include <linux/ctype.h>
17 #include <linux/kd.h>
18 #include <linux/mm.h>
19 #include <linux/string.h>
20 #include <linux/slab.h>
21 #include <linux/poll.h>
22 #include <linux/proc_fs.h>
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/smp_lock.h>
26 #include <linux/device.h>
27 #include <linux/wait.h>
28 #include <linux/bitops.h>
29 #include <linux/delay.h>
30 #include <linux/seq_file.h>
31
32 #include <linux/uaccess.h>
33 #include <asm/system.h>
34
35 #include <linux/kbd_kern.h>
36 #include <linux/vt_kern.h>
37 #include <linux/selection.h>
38
39 #include <linux/kmod.h>
40 #include <linux/nsproxy.h>
41
42 /*
43  *      This guards the refcounted line discipline lists. The lock
44  *      must be taken with irqs off because there are hangup path
45  *      callers who will do ldisc lookups and cannot sleep.
46  */
47
48 static DEFINE_SPINLOCK(tty_ldisc_lock);
49 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
50 /* Line disc dispatch table */
51 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
52
53 /**
54  *      tty_register_ldisc      -       install a line discipline
55  *      @disc: ldisc number
56  *      @new_ldisc: pointer to the ldisc object
57  *
58  *      Installs a new line discipline into the kernel. The discipline
59  *      is set up as unreferenced and then made available to the kernel
60  *      from this point onwards.
61  *
62  *      Locking:
63  *              takes tty_ldisc_lock to guard against ldisc races
64  */
65
66 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
67 {
68         unsigned long flags;
69         int ret = 0;
70
71         if (disc < N_TTY || disc >= NR_LDISCS)
72                 return -EINVAL;
73
74         spin_lock_irqsave(&tty_ldisc_lock, flags);
75         tty_ldiscs[disc] = new_ldisc;
76         new_ldisc->num = disc;
77         new_ldisc->refcount = 0;
78         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
79
80         return ret;
81 }
82 EXPORT_SYMBOL(tty_register_ldisc);
83
84 /**
85  *      tty_unregister_ldisc    -       unload a line discipline
86  *      @disc: ldisc number
87  *      @new_ldisc: pointer to the ldisc object
88  *
89  *      Remove a line discipline from the kernel providing it is not
90  *      currently in use.
91  *
92  *      Locking:
93  *              takes tty_ldisc_lock to guard against ldisc races
94  */
95
96 int tty_unregister_ldisc(int disc)
97 {
98         unsigned long flags;
99         int ret = 0;
100
101         if (disc < N_TTY || disc >= NR_LDISCS)
102                 return -EINVAL;
103
104         spin_lock_irqsave(&tty_ldisc_lock, flags);
105         if (tty_ldiscs[disc]->refcount)
106                 ret = -EBUSY;
107         else
108                 tty_ldiscs[disc] = NULL;
109         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
110
111         return ret;
112 }
113 EXPORT_SYMBOL(tty_unregister_ldisc);
114
115
116 /**
117  *      tty_ldisc_try_get       -       try and reference an ldisc
118  *      @disc: ldisc number
119  *      @ld: tty ldisc structure to complete
120  *
121  *      Attempt to open and lock a line discipline into place. Return
122  *      the line discipline refcounted and assigned in ld. On an error
123  *      report the error code back
124  */
125
126 static int tty_ldisc_try_get(int disc, struct tty_ldisc *ld)
127 {
128         unsigned long flags;
129         struct tty_ldisc_ops *ldops;
130         int err = -EINVAL;
131         
132         spin_lock_irqsave(&tty_ldisc_lock, flags);
133         ld->ops = NULL;
134         ldops = tty_ldiscs[disc];
135         /* Check the entry is defined */
136         if (ldops) {
137                 /* If the module is being unloaded we can't use it */
138                 if (!try_module_get(ldops->owner))
139                         err = -EAGAIN;
140                 else {
141                         /* lock it */
142                         ldops->refcount++;
143                         ld->ops = ldops;
144                         err = 0;
145                 }
146         }
147         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
148         return err;
149 }
150
151 /**
152  *      tty_ldisc_get           -       take a reference to an ldisc
153  *      @disc: ldisc number
154  *      @ld: tty line discipline structure to use
155  *
156  *      Takes a reference to a line discipline. Deals with refcounts and
157  *      module locking counts. Returns NULL if the discipline is not available.
158  *      Returns a pointer to the discipline and bumps the ref count if it is
159  *      available
160  *
161  *      Locking:
162  *              takes tty_ldisc_lock to guard against ldisc races
163  */
164
165 static int tty_ldisc_get(int disc, struct tty_ldisc *ld)
166 {
167         int err;
168
169         if (disc < N_TTY || disc >= NR_LDISCS)
170                 return -EINVAL;
171         err = tty_ldisc_try_get(disc, ld);
172         if (err < 0) {
173                 request_module("tty-ldisc-%d", disc);
174                 err = tty_ldisc_try_get(disc, ld);
175         }
176         return err;
177 }
178
179 /**
180  *      tty_ldisc_put           -       drop ldisc reference
181  *      @disc: ldisc number
182  *
183  *      Drop a reference to a line discipline. Manage refcounts and
184  *      module usage counts
185  *
186  *      Locking:
187  *              takes tty_ldisc_lock to guard against ldisc races
188  */
189
190 static void tty_ldisc_put(struct tty_ldisc_ops *ld)
191 {
192         unsigned long flags;
193         int disc = ld->num;
194
195         BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
196
197         spin_lock_irqsave(&tty_ldisc_lock, flags);
198         ld = tty_ldiscs[disc];
199         BUG_ON(ld->refcount == 0);
200         ld->refcount--;
201         module_put(ld->owner);
202         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
203 }
204
205 static void * tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
206 {
207         return (*pos < NR_LDISCS) ? pos : NULL;
208 }
209
210 static void * tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
211 {
212         (*pos)++;
213         return (*pos < NR_LDISCS) ? pos : NULL;
214 }
215
216 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
217 {
218 }
219
220 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
221 {
222         int i = *(loff_t *)v;
223         struct tty_ldisc ld;
224         
225         if (tty_ldisc_get(i, &ld) < 0)
226                 return 0;
227         seq_printf(m, "%-10s %2d\n", ld.ops->name ? ld.ops->name : "???", i);
228         tty_ldisc_put(ld.ops);
229         return 0;
230 }
231
232 static const struct seq_operations tty_ldiscs_seq_ops = {
233         .start  = tty_ldiscs_seq_start,
234         .next   = tty_ldiscs_seq_next,
235         .stop   = tty_ldiscs_seq_stop,
236         .show   = tty_ldiscs_seq_show,
237 };
238
239 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
240 {
241         return seq_open(file, &tty_ldiscs_seq_ops);
242 }
243
244 const struct file_operations tty_ldiscs_proc_fops = {
245         .owner          = THIS_MODULE,
246         .open           = proc_tty_ldiscs_open,
247         .read           = seq_read,
248         .llseek         = seq_lseek,
249         .release        = seq_release,
250 };
251
252 /**
253  *      tty_ldisc_assign        -       set ldisc on a tty
254  *      @tty: tty to assign
255  *      @ld: line discipline
256  *
257  *      Install an instance of a line discipline into a tty structure. The
258  *      ldisc must have a reference count above zero to ensure it remains/
259  *      The tty instance refcount starts at zero.
260  *
261  *      Locking:
262  *              Caller must hold references
263  */
264
265 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
266 {
267         ld->refcount = 0;
268         tty->ldisc = *ld;
269 }
270
271 /**
272  *      tty_ldisc_try           -       internal helper
273  *      @tty: the tty
274  *
275  *      Make a single attempt to grab and bump the refcount on
276  *      the tty ldisc. Return 0 on failure or 1 on success. This is
277  *      used to implement both the waiting and non waiting versions
278  *      of tty_ldisc_ref
279  *
280  *      Locking: takes tty_ldisc_lock
281  */
282
283 static int tty_ldisc_try(struct tty_struct *tty)
284 {
285         unsigned long flags;
286         struct tty_ldisc *ld;
287         int ret = 0;
288
289         spin_lock_irqsave(&tty_ldisc_lock, flags);
290         ld = &tty->ldisc;
291         if (test_bit(TTY_LDISC, &tty->flags)) {
292                 ld->refcount++;
293                 ret = 1;
294         }
295         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
296         return ret;
297 }
298
299 /**
300  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
301  *      @tty: tty device
302  *
303  *      Dereference the line discipline for the terminal and take a
304  *      reference to it. If the line discipline is in flux then
305  *      wait patiently until it changes.
306  *
307  *      Note: Must not be called from an IRQ/timer context. The caller
308  *      must also be careful not to hold other locks that will deadlock
309  *      against a discipline change, such as an existing ldisc reference
310  *      (which we check for)
311  *
312  *      Locking: call functions take tty_ldisc_lock
313  */
314
315 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
316 {
317         /* wait_event is a macro */
318         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
319         WARN_ON(tty->ldisc.refcount == 0);
320         return &tty->ldisc;
321 }
322
323 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
324
325 /**
326  *      tty_ldisc_ref           -       get the tty ldisc
327  *      @tty: tty device
328  *
329  *      Dereference the line discipline for the terminal and take a
330  *      reference to it. If the line discipline is in flux then
331  *      return NULL. Can be called from IRQ and timer functions.
332  *
333  *      Locking: called functions take tty_ldisc_lock
334  */
335
336 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
337 {
338         if (tty_ldisc_try(tty))
339                 return &tty->ldisc;
340         return NULL;
341 }
342
343 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
344
345 /**
346  *      tty_ldisc_deref         -       free a tty ldisc reference
347  *      @ld: reference to free up
348  *
349  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
350  *      be called in IRQ context.
351  *
352  *      Locking: takes tty_ldisc_lock
353  */
354
355 void tty_ldisc_deref(struct tty_ldisc *ld)
356 {
357         unsigned long flags;
358
359         BUG_ON(ld == NULL);
360
361         spin_lock_irqsave(&tty_ldisc_lock, flags);
362         if (ld->refcount == 0)
363                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
364         else
365                 ld->refcount--;
366         if (ld->refcount == 0)
367                 wake_up(&tty_ldisc_wait);
368         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
369 }
370
371 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
372
373 /**
374  *      tty_ldisc_enable        -       allow ldisc use
375  *      @tty: terminal to activate ldisc on
376  *
377  *      Set the TTY_LDISC flag when the line discipline can be called
378  *      again. Do necessary wakeups for existing sleepers. Clear the LDISC
379  *      changing flag to indicate any ldisc change is now over.
380  *
381  *      Note: nobody should set the TTY_LDISC bit except via this function.
382  *      Clearing directly is allowed.
383  */
384
385 void tty_ldisc_enable(struct tty_struct *tty)
386 {
387         set_bit(TTY_LDISC, &tty->flags);
388         clear_bit(TTY_LDISC_CHANGING, &tty->flags);
389         wake_up(&tty_ldisc_wait);
390 }
391
392 /**
393  *      tty_set_termios_ldisc           -       set ldisc field
394  *      @tty: tty structure
395  *      @num: line discipline number
396  *
397  *      This is probably overkill for real world processors but
398  *      they are not on hot paths so a little discipline won't do
399  *      any harm.
400  *
401  *      Locking: takes termios_mutex
402  */
403
404 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
405 {
406         mutex_lock(&tty->termios_mutex);
407         tty->termios->c_line = num;
408         mutex_unlock(&tty->termios_mutex);
409 }
410
411
412 /**
413  *      tty_ldisc_restore       -       helper for tty ldisc change
414  *      @tty: tty to recover
415  *      @old: previous ldisc
416  *
417  *      Restore the previous line discipline or N_TTY when a line discipline
418  *      change fails due to an open error
419  */
420
421 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
422 {
423         char buf[64];
424         struct tty_ldisc new_ldisc;
425
426         /* There is an outstanding reference here so this is safe */
427         tty_ldisc_get(old->ops->num, old);
428         tty_ldisc_assign(tty, old);
429         tty_set_termios_ldisc(tty, old->ops->num);
430         if (old->ops->open && (old->ops->open(tty) < 0)) {
431                 tty_ldisc_put(old->ops);
432                 /* This driver is always present */
433                 if (tty_ldisc_get(N_TTY, &new_ldisc) < 0)
434                         panic("n_tty: get");
435                 tty_ldisc_assign(tty, &new_ldisc);
436                 tty_set_termios_ldisc(tty, N_TTY);
437                 if (new_ldisc.ops->open) {
438                         int r = new_ldisc.ops->open(tty);
439                                 if (r < 0)
440                                 panic("Couldn't open N_TTY ldisc for "
441                                       "%s --- error %d.",
442                                       tty_name(tty, buf), r);
443                 }
444         }
445 }
446
447 /**
448  *      tty_set_ldisc           -       set line discipline
449  *      @tty: the terminal to set
450  *      @ldisc: the line discipline
451  *
452  *      Set the discipline of a tty line. Must be called from a process
453  *      context.
454  *
455  *      Locking: takes tty_ldisc_lock.
456  *               called functions take termios_mutex
457  */
458
459 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
460 {
461         int retval;
462         struct tty_ldisc o_ldisc, new_ldisc;
463         int work;
464         unsigned long flags;
465         struct tty_struct *o_tty;
466
467 restart:
468         /* This is a bit ugly for now but means we can break the 'ldisc
469            is part of the tty struct' assumption later */
470         retval = tty_ldisc_get(ldisc, &new_ldisc);
471         if (retval)
472                 return retval;
473
474         /*
475          *      Problem: What do we do if this blocks ?
476          */
477
478         tty_wait_until_sent(tty, 0);
479
480         if (tty->ldisc.ops->num == ldisc) {
481                 tty_ldisc_put(new_ldisc.ops);
482                 return 0;
483         }
484
485         /*
486          *      No more input please, we are switching. The new ldisc
487          *      will update this value in the ldisc open function
488          */
489
490         tty->receive_room = 0;
491
492         o_ldisc = tty->ldisc;
493         o_tty = tty->link;
494
495         /*
496          *      Make sure we don't change while someone holds a
497          *      reference to the line discipline. The TTY_LDISC bit
498          *      prevents anyone taking a reference once it is clear.
499          *      We need the lock to avoid racing reference takers.
500          *
501          *      We must clear the TTY_LDISC bit here to avoid a livelock
502          *      with a userspace app continually trying to use the tty in
503          *      parallel to the change and re-referencing the tty.
504          */
505         clear_bit(TTY_LDISC, &tty->flags);
506         if (o_tty)
507                 clear_bit(TTY_LDISC, &o_tty->flags);
508
509         spin_lock_irqsave(&tty_ldisc_lock, flags);
510         if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
511                 if (tty->ldisc.refcount) {
512                         /* Free the new ldisc we grabbed. Must drop the lock
513                            first. */
514                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
515                         tty_ldisc_put(o_ldisc.ops);
516                         /*
517                          * There are several reasons we may be busy, including
518                          * random momentary I/O traffic. We must therefore
519                          * retry. We could distinguish between blocking ops
520                          * and retries if we made tty_ldisc_wait() smarter.
521                          * That is up for discussion.
522                          */
523                         if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
524                                 return -ERESTARTSYS;
525                         goto restart;
526                 }
527                 if (o_tty && o_tty->ldisc.refcount) {
528                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
529                         tty_ldisc_put(o_tty->ldisc.ops);
530                         if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
531                                 return -ERESTARTSYS;
532                         goto restart;
533                 }
534         }
535         /*
536          *      If the TTY_LDISC bit is set, then we are racing against
537          *      another ldisc change
538          */
539         if (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
540                 struct tty_ldisc *ld;
541                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
542                 tty_ldisc_put(new_ldisc.ops);
543                 ld = tty_ldisc_ref_wait(tty);
544                 tty_ldisc_deref(ld);
545                 goto restart;
546         }
547         /*
548          *      This flag is used to avoid two parallel ldisc changes. Once
549          *      open and close are fine grained locked this may work better
550          *      as a mutex shared with the open/close/hup paths
551          */
552         set_bit(TTY_LDISC_CHANGING, &tty->flags);
553         if (o_tty)
554                 set_bit(TTY_LDISC_CHANGING, &o_tty->flags);
555         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
556         
557         /*
558          *      From this point on we know nobody has an ldisc
559          *      usage reference, nor can they obtain one until
560          *      we say so later on.
561          */
562
563         work = cancel_delayed_work(&tty->buf.work);
564         /*
565          * Wait for ->hangup_work and ->buf.work handlers to terminate
566          * MUST NOT hold locks here.
567          */
568         flush_scheduled_work();
569         /* Shutdown the current discipline. */
570         if (o_ldisc.ops->close)
571                 (o_ldisc.ops->close)(tty);
572
573         /* Now set up the new line discipline. */
574         tty_ldisc_assign(tty, &new_ldisc);
575         tty_set_termios_ldisc(tty, ldisc);
576         if (new_ldisc.ops->open)
577                 retval = (new_ldisc.ops->open)(tty);
578         if (retval < 0) {
579                 tty_ldisc_put(new_ldisc.ops);
580                 tty_ldisc_restore(tty, &o_ldisc);
581         }
582         /* At this point we hold a reference to the new ldisc and a
583            a reference to the old ldisc. If we ended up flipping back
584            to the existing ldisc we have two references to it */
585
586         if (tty->ldisc.ops->num != o_ldisc.ops->num && tty->ops->set_ldisc)
587                 tty->ops->set_ldisc(tty);
588
589         tty_ldisc_put(o_ldisc.ops);
590
591         /*
592          *      Allow ldisc referencing to occur as soon as the driver
593          *      ldisc callback completes.
594          */
595
596         tty_ldisc_enable(tty);
597         if (o_tty)
598                 tty_ldisc_enable(o_tty);
599
600         /* Restart it in case no characters kick it off. Safe if
601            already running */
602         if (work)
603                 schedule_delayed_work(&tty->buf.work, 1);
604         return retval;
605 }
606
607
608 /**
609  *      tty_ldisc_setup                 -       open line discipline
610  *      @tty: tty being shut down
611  *      @o_tty: pair tty for pty/tty pairs
612  *
613  *      Called during the initial open of a tty/pty pair in order to set up the
614  *      line discplines and bind them to the tty.
615  */
616
617 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
618 {
619         struct tty_ldisc *ld = &tty->ldisc;
620         int retval;
621
622         if (ld->ops->open) {
623                 retval = (ld->ops->open)(tty);
624                 if (retval)
625                         return retval;
626         }
627         if (o_tty && o_tty->ldisc.ops->open) {
628                 retval = (o_tty->ldisc.ops->open)(o_tty);
629                 if (retval) {
630                         if (ld->ops->close)
631                                 (ld->ops->close)(tty);
632                         return retval;
633                 }
634                 tty_ldisc_enable(o_tty);
635         }
636         tty_ldisc_enable(tty);
637         return 0;
638 }
639
640 /**
641  *      tty_ldisc_release               -       release line discipline
642  *      @tty: tty being shut down
643  *      @o_tty: pair tty for pty/tty pairs
644  *
645  *      Called during the final close of a tty/pty pair in order to shut down the
646  *      line discpline layer.
647  */
648
649 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
650 {
651         unsigned long flags;
652         struct tty_ldisc ld;
653         /*
654          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
655          * kill any delayed work. As this is the final close it does not
656          * race with the set_ldisc code path.
657          */
658         clear_bit(TTY_LDISC, &tty->flags);
659         cancel_delayed_work(&tty->buf.work);
660
661         /*
662          * Wait for ->hangup_work and ->buf.work handlers to terminate
663          */
664
665         flush_scheduled_work();
666
667         /*
668          * Wait for any short term users (we know they are just driver
669          * side waiters as the file is closing so user count on the file
670          * side is zero.
671          */
672         spin_lock_irqsave(&tty_ldisc_lock, flags);
673         while (tty->ldisc.refcount) {
674                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
675                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
676                 spin_lock_irqsave(&tty_ldisc_lock, flags);
677         }
678         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
679         /*
680          * Shutdown the current line discipline, and reset it to N_TTY.
681          *
682          * FIXME: this MUST get fixed for the new reflocking
683          */
684         if (tty->ldisc.ops->close)
685                 (tty->ldisc.ops->close)(tty);
686         tty_ldisc_put(tty->ldisc.ops);
687
688         /*
689          *      Switch the line discipline back
690          */
691         WARN_ON(tty_ldisc_get(N_TTY, &ld));
692         tty_ldisc_assign(tty, &ld);
693         tty_set_termios_ldisc(tty, N_TTY);
694         if (o_tty) {
695                 /* FIXME: could o_tty be in setldisc here ? */
696                 clear_bit(TTY_LDISC, &o_tty->flags);
697                 if (o_tty->ldisc.ops->close)
698                         (o_tty->ldisc.ops->close)(o_tty);
699                 tty_ldisc_put(o_tty->ldisc.ops);
700                 WARN_ON(tty_ldisc_get(N_TTY, &ld));
701                 tty_ldisc_assign(o_tty, &ld);
702                 tty_set_termios_ldisc(o_tty, N_TTY);
703         }
704 }
705
706 /**
707  *      tty_ldisc_init          -       ldisc setup for new tty
708  *      @tty: tty being allocated
709  *
710  *      Set up the line discipline objects for a newly allocated tty. Note that
711  *      the tty structure is not completely set up when this call is made.
712  */
713
714 void tty_ldisc_init(struct tty_struct *tty)
715 {
716         struct tty_ldisc ld;
717         if (tty_ldisc_get(N_TTY, &ld) < 0)
718                 panic("n_tty: init_tty");
719         tty_ldisc_assign(tty, &ld);
720 }
721
722 void tty_ldisc_begin(void)
723 {
724         /* Setup the default TTY line discipline. */
725         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
726 }