Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4
[linux-2.6] / 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/console.h>
14 #include <linux/timer.h>
15 #include <linux/ctype.h>
16 #include <linux/kd.h>
17 #include <linux/mm.h>
18 #include <linux/string.h>
19 #include <linux/slab.h>
20 #include <linux/poll.h>
21 #include <linux/proc_fs.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/smp_lock.h>
25 #include <linux/device.h>
26 #include <linux/wait.h>
27 #include <linux/bitops.h>
28 #include <linux/delay.h>
29 #include <linux/seq_file.h>
30
31 #include <linux/uaccess.h>
32 #include <asm/system.h>
33
34 #include <linux/kbd_kern.h>
35 #include <linux/vt_kern.h>
36 #include <linux/selection.h>
37
38 #include <linux/kmod.h>
39 #include <linux/nsproxy.h>
40
41 /*
42  *      This guards the refcounted line discipline lists. The lock
43  *      must be taken with irqs off because there are hangup path
44  *      callers who will do ldisc lookups and cannot sleep.
45  */
46
47 static DEFINE_SPINLOCK(tty_ldisc_lock);
48 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
49 /* Line disc dispatch table */
50 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
51
52 /**
53  *      tty_register_ldisc      -       install a line discipline
54  *      @disc: ldisc number
55  *      @new_ldisc: pointer to the ldisc object
56  *
57  *      Installs a new line discipline into the kernel. The discipline
58  *      is set up as unreferenced and then made available to the kernel
59  *      from this point onwards.
60  *
61  *      Locking:
62  *              takes tty_ldisc_lock to guard against ldisc races
63  */
64
65 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
66 {
67         unsigned long flags;
68         int ret = 0;
69
70         if (disc < N_TTY || disc >= NR_LDISCS)
71                 return -EINVAL;
72
73         spin_lock_irqsave(&tty_ldisc_lock, flags);
74         tty_ldiscs[disc] = new_ldisc;
75         new_ldisc->num = disc;
76         new_ldisc->refcount = 0;
77         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
78
79         return ret;
80 }
81 EXPORT_SYMBOL(tty_register_ldisc);
82
83 /**
84  *      tty_unregister_ldisc    -       unload a line discipline
85  *      @disc: ldisc number
86  *      @new_ldisc: pointer to the ldisc object
87  *
88  *      Remove a line discipline from the kernel providing it is not
89  *      currently in use.
90  *
91  *      Locking:
92  *              takes tty_ldisc_lock to guard against ldisc races
93  */
94
95 int tty_unregister_ldisc(int disc)
96 {
97         unsigned long flags;
98         int ret = 0;
99
100         if (disc < N_TTY || disc >= NR_LDISCS)
101                 return -EINVAL;
102
103         spin_lock_irqsave(&tty_ldisc_lock, flags);
104         if (tty_ldiscs[disc]->refcount)
105                 ret = -EBUSY;
106         else
107                 tty_ldiscs[disc] = NULL;
108         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
109
110         return ret;
111 }
112 EXPORT_SYMBOL(tty_unregister_ldisc);
113
114
115 /**
116  *      tty_ldisc_try_get       -       try and reference an ldisc
117  *      @disc: ldisc number
118  *
119  *      Attempt to open and lock a line discipline into place. Return
120  *      the line discipline refcounted or an error.
121  */
122
123 static struct tty_ldisc *tty_ldisc_try_get(int disc)
124 {
125         unsigned long flags;
126         struct tty_ldisc *ld;
127         struct tty_ldisc_ops *ldops;
128         int err = -EINVAL;
129
130         ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
131         if (ld == NULL)
132                 return ERR_PTR(-ENOMEM);
133
134         spin_lock_irqsave(&tty_ldisc_lock, flags);
135         ld->ops = NULL;
136         ldops = tty_ldiscs[disc];
137         /* Check the entry is defined */
138         if (ldops) {
139                 /* If the module is being unloaded we can't use it */
140                 if (!try_module_get(ldops->owner))
141                         err = -EAGAIN;
142                 else {
143                         /* lock it */
144                         ldops->refcount++;
145                         ld->ops = ldops;
146                         ld->refcount = 0;
147                         err = 0;
148                 }
149         }
150         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
151         if (err)
152                 return ERR_PTR(err);
153         return ld;
154 }
155
156 /**
157  *      tty_ldisc_get           -       take a reference to an ldisc
158  *      @disc: ldisc number
159  *
160  *      Takes a reference to a line discipline. Deals with refcounts and
161  *      module locking counts. Returns NULL if the discipline is not available.
162  *      Returns a pointer to the discipline and bumps the ref count if it is
163  *      available
164  *
165  *      Locking:
166  *              takes tty_ldisc_lock to guard against ldisc races
167  */
168
169 static struct tty_ldisc *tty_ldisc_get(int disc)
170 {
171         struct tty_ldisc *ld;
172
173         if (disc < N_TTY || disc >= NR_LDISCS)
174                 return ERR_PTR(-EINVAL);
175         ld = tty_ldisc_try_get(disc);
176         if (IS_ERR(ld)) {
177                 request_module("tty-ldisc-%d", disc);
178                 ld = tty_ldisc_try_get(disc);
179         }
180         return ld;
181 }
182
183 /**
184  *      tty_ldisc_put           -       drop ldisc reference
185  *      @ld: ldisc
186  *
187  *      Drop a reference to a line discipline. Manage refcounts and
188  *      module usage counts. Free the ldisc once the recount hits zero.
189  *
190  *      Locking:
191  *              takes tty_ldisc_lock to guard against ldisc races
192  */
193
194 static void tty_ldisc_put(struct tty_ldisc *ld)
195 {
196         unsigned long flags;
197         int disc = ld->ops->num;
198         struct tty_ldisc_ops *ldo;
199
200         BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
201
202         spin_lock_irqsave(&tty_ldisc_lock, flags);
203         ldo = tty_ldiscs[disc];
204         BUG_ON(ldo->refcount == 0);
205         ldo->refcount--;
206         module_put(ldo->owner);
207         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
208         kfree(ld);
209 }
210
211 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
212 {
213         return (*pos < NR_LDISCS) ? pos : NULL;
214 }
215
216 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
217 {
218         (*pos)++;
219         return (*pos < NR_LDISCS) ? pos : NULL;
220 }
221
222 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
223 {
224 }
225
226 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
227 {
228         int i = *(loff_t *)v;
229         struct tty_ldisc *ld;
230
231         ld = tty_ldisc_try_get(i);
232         if (IS_ERR(ld))
233                 return 0;
234         seq_printf(m, "%-10s %2d\n", ld->ops->name ? ld->ops->name : "???", i);
235         tty_ldisc_put(ld);
236         return 0;
237 }
238
239 static const struct seq_operations tty_ldiscs_seq_ops = {
240         .start  = tty_ldiscs_seq_start,
241         .next   = tty_ldiscs_seq_next,
242         .stop   = tty_ldiscs_seq_stop,
243         .show   = tty_ldiscs_seq_show,
244 };
245
246 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
247 {
248         return seq_open(file, &tty_ldiscs_seq_ops);
249 }
250
251 const struct file_operations tty_ldiscs_proc_fops = {
252         .owner          = THIS_MODULE,
253         .open           = proc_tty_ldiscs_open,
254         .read           = seq_read,
255         .llseek         = seq_lseek,
256         .release        = seq_release,
257 };
258
259 /**
260  *      tty_ldisc_assign        -       set ldisc on a tty
261  *      @tty: tty to assign
262  *      @ld: line discipline
263  *
264  *      Install an instance of a line discipline into a tty structure. The
265  *      ldisc must have a reference count above zero to ensure it remains/
266  *      The tty instance refcount starts at zero.
267  *
268  *      Locking:
269  *              Caller must hold references
270  */
271
272 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
273 {
274         tty->ldisc = ld;
275 }
276
277 /**
278  *      tty_ldisc_try           -       internal helper
279  *      @tty: the tty
280  *
281  *      Make a single attempt to grab and bump the refcount on
282  *      the tty ldisc. Return 0 on failure or 1 on success. This is
283  *      used to implement both the waiting and non waiting versions
284  *      of tty_ldisc_ref
285  *
286  *      Locking: takes tty_ldisc_lock
287  */
288
289 static int tty_ldisc_try(struct tty_struct *tty)
290 {
291         unsigned long flags;
292         struct tty_ldisc *ld;
293         int ret = 0;
294
295         spin_lock_irqsave(&tty_ldisc_lock, flags);
296         ld = tty->ldisc;
297         if (test_bit(TTY_LDISC, &tty->flags)) {
298                 ld->refcount++;
299                 ret = 1;
300         }
301         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
302         return ret;
303 }
304
305 /**
306  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
307  *      @tty: tty device
308  *
309  *      Dereference the line discipline for the terminal and take a
310  *      reference to it. If the line discipline is in flux then
311  *      wait patiently until it changes.
312  *
313  *      Note: Must not be called from an IRQ/timer context. The caller
314  *      must also be careful not to hold other locks that will deadlock
315  *      against a discipline change, such as an existing ldisc reference
316  *      (which we check for)
317  *
318  *      Locking: call functions take tty_ldisc_lock
319  */
320
321 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
322 {
323         /* wait_event is a macro */
324         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
325         WARN_ON(tty->ldisc->refcount == 0);
326         return tty->ldisc;
327 }
328 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
329
330 /**
331  *      tty_ldisc_ref           -       get the tty ldisc
332  *      @tty: tty device
333  *
334  *      Dereference the line discipline for the terminal and take a
335  *      reference to it. If the line discipline is in flux then
336  *      return NULL. Can be called from IRQ and timer functions.
337  *
338  *      Locking: called functions take tty_ldisc_lock
339  */
340
341 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
342 {
343         if (tty_ldisc_try(tty))
344                 return tty->ldisc;
345         return NULL;
346 }
347 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
348
349 /**
350  *      tty_ldisc_deref         -       free a tty ldisc reference
351  *      @ld: reference to free up
352  *
353  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
354  *      be called in IRQ context.
355  *
356  *      Locking: takes tty_ldisc_lock
357  */
358
359 void tty_ldisc_deref(struct tty_ldisc *ld)
360 {
361         unsigned long flags;
362
363         BUG_ON(ld == NULL);
364
365         spin_lock_irqsave(&tty_ldisc_lock, flags);
366         if (ld->refcount == 0)
367                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
368         else
369                 ld->refcount--;
370         if (ld->refcount == 0)
371                 wake_up(&tty_ldisc_wait);
372         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
373 }
374 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
375
376 /**
377  *      tty_ldisc_enable        -       allow ldisc use
378  *      @tty: terminal to activate ldisc on
379  *
380  *      Set the TTY_LDISC flag when the line discipline can be called
381  *      again. Do necessary wakeups for existing sleepers. Clear the LDISC
382  *      changing flag to indicate any ldisc change is now over.
383  *
384  *      Note: nobody should set the TTY_LDISC bit except via this function.
385  *      Clearing directly is allowed.
386  */
387
388 void tty_ldisc_enable(struct tty_struct *tty)
389 {
390         set_bit(TTY_LDISC, &tty->flags);
391         clear_bit(TTY_LDISC_CHANGING, &tty->flags);
392         wake_up(&tty_ldisc_wait);
393 }
394
395 /**
396  *      tty_ldisc_flush -       flush line discipline queue
397  *      @tty: tty
398  *
399  *      Flush the line discipline queue (if any) for this tty. If there
400  *      is no line discipline active this is a no-op.
401  */
402
403 void tty_ldisc_flush(struct tty_struct *tty)
404 {
405         struct tty_ldisc *ld = tty_ldisc_ref(tty);
406         if (ld) {
407                 if (ld->ops->flush_buffer)
408                         ld->ops->flush_buffer(tty);
409                 tty_ldisc_deref(ld);
410         }
411         tty_buffer_flush(tty);
412 }
413 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
414
415 /**
416  *      tty_set_termios_ldisc           -       set ldisc field
417  *      @tty: tty structure
418  *      @num: line discipline number
419  *
420  *      This is probably overkill for real world processors but
421  *      they are not on hot paths so a little discipline won't do
422  *      any harm.
423  *
424  *      Locking: takes termios_mutex
425  */
426
427 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
428 {
429         mutex_lock(&tty->termios_mutex);
430         tty->termios->c_line = num;
431         mutex_unlock(&tty->termios_mutex);
432 }
433
434 /**
435  *      tty_ldisc_open          -       open a line discipline
436  *      @tty: tty we are opening the ldisc on
437  *      @ld: discipline to open
438  *
439  *      A helper opening method. Also a convenient debugging and check
440  *      point.
441  */
442
443 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
444 {
445         WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
446         if (ld->ops->open)
447                 return ld->ops->open(tty);
448         return 0;
449 }
450
451 /**
452  *      tty_ldisc_close         -       close a line discipline
453  *      @tty: tty we are opening the ldisc on
454  *      @ld: discipline to close
455  *
456  *      A helper close method. Also a convenient debugging and check
457  *      point.
458  */
459
460 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
461 {
462         WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
463         clear_bit(TTY_LDISC_OPEN, &tty->flags);
464         if (ld->ops->close)
465                 ld->ops->close(tty);
466 }
467
468 /**
469  *      tty_ldisc_restore       -       helper for tty ldisc change
470  *      @tty: tty to recover
471  *      @old: previous ldisc
472  *
473  *      Restore the previous line discipline or N_TTY when a line discipline
474  *      change fails due to an open error
475  */
476
477 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
478 {
479         char buf[64];
480         struct tty_ldisc *new_ldisc;
481         int r;
482
483         /* There is an outstanding reference here so this is safe */
484         old = tty_ldisc_get(old->ops->num);
485         WARN_ON(IS_ERR(old));
486         tty_ldisc_assign(tty, old);
487         tty_set_termios_ldisc(tty, old->ops->num);
488         if (tty_ldisc_open(tty, old) < 0) {
489                 tty_ldisc_put(old);
490                 /* This driver is always present */
491                 new_ldisc = tty_ldisc_get(N_TTY);
492                 if (IS_ERR(new_ldisc))
493                         panic("n_tty: get");
494                 tty_ldisc_assign(tty, new_ldisc);
495                 tty_set_termios_ldisc(tty, N_TTY);
496                 r = tty_ldisc_open(tty, new_ldisc);
497                 if (r < 0)
498                         panic("Couldn't open N_TTY ldisc for "
499                               "%s --- error %d.",
500                               tty_name(tty, buf), r);
501         }
502 }
503
504 /**
505  *      tty_ldisc_halt          -       shut down the line discipline
506  *      @tty: tty device
507  *
508  *      Shut down the line discipline and work queue for this tty device.
509  *      The TTY_LDISC flag being cleared ensures no further references can
510  *      be obtained while the delayed work queue halt ensures that no more
511  *      data is fed to the ldisc.
512  *
513  *      In order to wait for any existing references to complete see
514  *      tty_ldisc_wait_idle.
515  */
516
517 static int tty_ldisc_halt(struct tty_struct *tty)
518 {
519         clear_bit(TTY_LDISC, &tty->flags);
520         return cancel_delayed_work(&tty->buf.work);
521 }
522
523 /**
524  *      tty_ldisc_wait_idle     -       wait for the ldisc to become idle
525  *      @tty: tty to wait for
526  *
527  *      Wait for the line discipline to become idle. The discipline must
528  *      have been halted for this to guarantee it remains idle.
529  *
530  *      tty_ldisc_lock protects the ref counts currently.
531  */
532
533 static int tty_ldisc_wait_idle(struct tty_struct *tty)
534 {
535         unsigned long flags;
536         spin_lock_irqsave(&tty_ldisc_lock, flags);
537         while (tty->ldisc->refcount) {
538                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
539                 if (wait_event_timeout(tty_ldisc_wait,
540                                 tty->ldisc->refcount == 0, 5 * HZ) == 0)
541                         return -EBUSY;
542                 spin_lock_irqsave(&tty_ldisc_lock, flags);
543         }
544         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
545         return 0;
546 }
547
548 /**
549  *      tty_set_ldisc           -       set line discipline
550  *      @tty: the terminal to set
551  *      @ldisc: the line discipline
552  *
553  *      Set the discipline of a tty line. Must be called from a process
554  *      context. The ldisc change logic has to protect itself against any
555  *      overlapping ldisc change (including on the other end of pty pairs),
556  *      the close of one side of a tty/pty pair, and eventually hangup.
557  *
558  *      Locking: takes tty_ldisc_lock, termios_mutex
559  */
560
561 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
562 {
563         int retval;
564         struct tty_ldisc *o_ldisc, *new_ldisc;
565         int work, o_work = 0;
566         struct tty_struct *o_tty;
567
568         new_ldisc = tty_ldisc_get(ldisc);
569         if (IS_ERR(new_ldisc))
570                 return PTR_ERR(new_ldisc);
571
572         /*
573          *      We need to look at the tty locking here for pty/tty pairs
574          *      when both sides try to change in parallel.
575          */
576
577         o_tty = tty->link;      /* o_tty is the pty side or NULL */
578
579
580         /*
581          *      Check the no-op case
582          */
583
584         if (tty->ldisc->ops->num == ldisc) {
585                 tty_ldisc_put(new_ldisc);
586                 return 0;
587         }
588
589         /*
590          *      Problem: What do we do if this blocks ?
591          *      We could deadlock here
592          */
593
594         tty_wait_until_sent(tty, 0);
595
596         mutex_lock(&tty->ldisc_mutex);
597
598         /*
599          *      We could be midstream of another ldisc change which has
600          *      dropped the lock during processing. If so we need to wait.
601          */
602
603         while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
604                 mutex_unlock(&tty->ldisc_mutex);
605                 wait_event(tty_ldisc_wait,
606                         test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0);
607                 mutex_lock(&tty->ldisc_mutex);
608         }
609         set_bit(TTY_LDISC_CHANGING, &tty->flags);
610
611         /*
612          *      No more input please, we are switching. The new ldisc
613          *      will update this value in the ldisc open function
614          */
615
616         tty->receive_room = 0;
617
618         o_ldisc = tty->ldisc;
619         /*
620          *      Make sure we don't change while someone holds a
621          *      reference to the line discipline. The TTY_LDISC bit
622          *      prevents anyone taking a reference once it is clear.
623          *      We need the lock to avoid racing reference takers.
624          *
625          *      We must clear the TTY_LDISC bit here to avoid a livelock
626          *      with a userspace app continually trying to use the tty in
627          *      parallel to the change and re-referencing the tty.
628          */
629
630         work = tty_ldisc_halt(tty);
631         if (o_tty)
632                 o_work = tty_ldisc_halt(o_tty);
633
634         /*
635          * Wait for ->hangup_work and ->buf.work handlers to terminate.
636          * We must drop the mutex here in case a hangup is also in process.
637          */
638
639         mutex_unlock(&tty->ldisc_mutex);
640
641         flush_scheduled_work();
642
643         /* Let any existing reference holders finish */
644         retval = tty_ldisc_wait_idle(tty);
645         if (retval < 0) {
646                 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
647                 tty_ldisc_put(new_ldisc);
648                 return retval;
649         }
650
651         mutex_lock(&tty->ldisc_mutex);
652         if (test_bit(TTY_HUPPED, &tty->flags)) {
653                 /* We were raced by the hangup method. It will have stomped
654                    the ldisc data and closed the ldisc down */
655                 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
656                 mutex_unlock(&tty->ldisc_mutex);
657                 tty_ldisc_put(new_ldisc);
658                 return -EIO;
659         }
660
661         /* Shutdown the current discipline. */
662         tty_ldisc_close(tty, o_ldisc);
663
664         /* Now set up the new line discipline. */
665         tty_ldisc_assign(tty, new_ldisc);
666         tty_set_termios_ldisc(tty, ldisc);
667
668         retval = tty_ldisc_open(tty, new_ldisc);
669         if (retval < 0) {
670                 /* Back to the old one or N_TTY if we can't */
671                 tty_ldisc_put(new_ldisc);
672                 tty_ldisc_restore(tty, o_ldisc);
673         }
674
675         /* At this point we hold a reference to the new ldisc and a
676            a reference to the old ldisc. If we ended up flipping back
677            to the existing ldisc we have two references to it */
678
679         if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc)
680                 tty->ops->set_ldisc(tty);
681
682         tty_ldisc_put(o_ldisc);
683
684         /*
685          *      Allow ldisc referencing to occur again
686          */
687
688         tty_ldisc_enable(tty);
689         if (o_tty)
690                 tty_ldisc_enable(o_tty);
691
692         /* Restart the work queue in case no characters kick it off. Safe if
693            already running */
694         if (work)
695                 schedule_delayed_work(&tty->buf.work, 1);
696         if (o_work)
697                 schedule_delayed_work(&o_tty->buf.work, 1);
698         mutex_unlock(&tty->ldisc_mutex);
699         return retval;
700 }
701
702 /**
703  *      tty_reset_termios       -       reset terminal state
704  *      @tty: tty to reset
705  *
706  *      Restore a terminal to the driver default state.
707  */
708
709 static void tty_reset_termios(struct tty_struct *tty)
710 {
711         mutex_lock(&tty->termios_mutex);
712         *tty->termios = tty->driver->init_termios;
713         tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
714         tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
715         mutex_unlock(&tty->termios_mutex);
716 }
717
718
719 /**
720  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
721  *      @tty: tty to reinit
722  *
723  *      Switch the tty back to N_TTY line discipline and leave the
724  *      ldisc state closed
725  */
726
727 static void tty_ldisc_reinit(struct tty_struct *tty)
728 {
729         struct tty_ldisc *ld;
730
731         tty_ldisc_close(tty, tty->ldisc);
732         tty_ldisc_put(tty->ldisc);
733         tty->ldisc = NULL;
734         /*
735          *      Switch the line discipline back
736          */
737         ld = tty_ldisc_get(N_TTY);
738         BUG_ON(IS_ERR(ld));
739         tty_ldisc_assign(tty, ld);
740         tty_set_termios_ldisc(tty, N_TTY);
741 }
742
743 /**
744  *      tty_ldisc_hangup                -       hangup ldisc reset
745  *      @tty: tty being hung up
746  *
747  *      Some tty devices reset their termios when they receive a hangup
748  *      event. In that situation we must also switch back to N_TTY properly
749  *      before we reset the termios data.
750  *
751  *      Locking: We can take the ldisc mutex as the rest of the code is
752  *      careful to allow for this.
753  *
754  *      In the pty pair case this occurs in the close() path of the
755  *      tty itself so we must be careful about locking rules.
756  */
757
758 void tty_ldisc_hangup(struct tty_struct *tty)
759 {
760         struct tty_ldisc *ld;
761
762         /*
763          * FIXME! What are the locking issues here? This may me overdoing
764          * things... This question is especially important now that we've
765          * removed the irqlock.
766          */
767         ld = tty_ldisc_ref(tty);
768         if (ld != NULL) {
769                 /* We may have no line discipline at this point */
770                 if (ld->ops->flush_buffer)
771                         ld->ops->flush_buffer(tty);
772                 tty_driver_flush_buffer(tty);
773                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
774                     ld->ops->write_wakeup)
775                         ld->ops->write_wakeup(tty);
776                 if (ld->ops->hangup)
777                         ld->ops->hangup(tty);
778                 tty_ldisc_deref(ld);
779         }
780         /*
781          * FIXME: Once we trust the LDISC code better we can wait here for
782          * ldisc completion and fix the driver call race
783          */
784         wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
785         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
786         /*
787          * Shutdown the current line discipline, and reset it to
788          * N_TTY.
789          */
790         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
791                 /* Avoid racing set_ldisc */
792                 mutex_lock(&tty->ldisc_mutex);
793                 /* Switch back to N_TTY */
794                 tty_ldisc_reinit(tty);
795                 /* At this point we have a closed ldisc and we want to
796                    reopen it. We could defer this to the next open but
797                    it means auditing a lot of other paths so this is a FIXME */
798                 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
799                 tty_ldisc_enable(tty);
800                 mutex_unlock(&tty->ldisc_mutex);
801                 tty_reset_termios(tty);
802         }
803 }
804
805 /**
806  *      tty_ldisc_setup                 -       open line discipline
807  *      @tty: tty being shut down
808  *      @o_tty: pair tty for pty/tty pairs
809  *
810  *      Called during the initial open of a tty/pty pair in order to set up the
811  *      line disciplines and bind them to the tty. This has no locking issues
812  *      as the device isn't yet active.
813  */
814
815 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
816 {
817         struct tty_ldisc *ld = tty->ldisc;
818         int retval;
819
820         retval = tty_ldisc_open(tty, ld);
821         if (retval)
822                 return retval;
823
824         if (o_tty) {
825                 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
826                 if (retval) {
827                         tty_ldisc_close(tty, ld);
828                         return retval;
829                 }
830                 tty_ldisc_enable(o_tty);
831         }
832         tty_ldisc_enable(tty);
833         return 0;
834 }
835 /**
836  *      tty_ldisc_release               -       release line discipline
837  *      @tty: tty being shut down
838  *      @o_tty: pair tty for pty/tty pairs
839  *
840  *      Called during the final close of a tty/pty pair in order to shut down
841  *      the line discpline layer. On exit the ldisc assigned is N_TTY and the
842  *      ldisc has not been opened.
843  */
844
845 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
846 {
847         /*
848          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
849          * kill any delayed work. As this is the final close it does not
850          * race with the set_ldisc code path.
851          */
852
853         tty_ldisc_halt(tty);
854         flush_scheduled_work();
855
856         /*
857          * Wait for any short term users (we know they are just driver
858          * side waiters as the file is closing so user count on the file
859          * side is zero.
860          */
861
862         tty_ldisc_wait_idle(tty);
863
864         /*
865          * Shutdown the current line discipline, and reset it to N_TTY.
866          *
867          * FIXME: this MUST get fixed for the new reflocking
868          */
869
870         tty_ldisc_reinit(tty);
871         /* This will need doing differently if we need to lock */
872         if (o_tty)
873                 tty_ldisc_release(o_tty, NULL);
874 }
875
876 /**
877  *      tty_ldisc_init          -       ldisc setup for new tty
878  *      @tty: tty being allocated
879  *
880  *      Set up the line discipline objects for a newly allocated tty. Note that
881  *      the tty structure is not completely set up when this call is made.
882  */
883
884 void tty_ldisc_init(struct tty_struct *tty)
885 {
886         struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
887         if (IS_ERR(ld))
888                 panic("n_tty: init_tty");
889         tty_ldisc_assign(tty, ld);
890 }
891
892 void tty_ldisc_begin(void)
893 {
894         /* Setup the default TTY line discipline. */
895         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
896 }