Version:  2.0.40 2.2.26 2.4.37 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0

Linux/drivers/tty/tty_ldisc.c

  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>
  6 #include <linux/tty.h>
  7 #include <linux/tty_driver.h>
  8 #include <linux/file.h>
  9 #include <linux/mm.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/module.h>
 15 #include <linux/device.h>
 16 #include <linux/wait.h>
 17 #include <linux/bitops.h>
 18 #include <linux/seq_file.h>
 19 #include <linux/uaccess.h>
 20 #include <linux/ratelimit.h>
 21 
 22 #undef LDISC_DEBUG_HANGUP
 23 
 24 #ifdef LDISC_DEBUG_HANGUP
 25 #define tty_ldisc_debug(tty, f, args...) ({                                    \
 26         char __b[64];                                                          \
 27         printk(KERN_DEBUG "%s: %s: " f, __func__, tty_name(tty, __b), ##args); \
 28 })
 29 #else
 30 #define tty_ldisc_debug(tty, f, args...)
 31 #endif
 32 
 33 /* lockdep nested classes for tty->ldisc_sem */
 34 enum {
 35         LDISC_SEM_NORMAL,
 36         LDISC_SEM_OTHER,
 37 };
 38 
 39 
 40 /*
 41  *      This guards the refcounted line discipline lists. The lock
 42  *      must be taken with irqs off because there are hangup path
 43  *      callers who will do ldisc lookups and cannot sleep.
 44  */
 45 
 46 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
 47 /* Line disc dispatch table */
 48 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
 49 
 50 /**
 51  *      tty_register_ldisc      -       install a line discipline
 52  *      @disc: ldisc number
 53  *      @new_ldisc: pointer to the ldisc object
 54  *
 55  *      Installs a new line discipline into the kernel. The discipline
 56  *      is set up as unreferenced and then made available to the kernel
 57  *      from this point onwards.
 58  *
 59  *      Locking:
 60  *              takes tty_ldiscs_lock to guard against ldisc races
 61  */
 62 
 63 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
 64 {
 65         unsigned long flags;
 66         int ret = 0;
 67 
 68         if (disc < N_TTY || disc >= NR_LDISCS)
 69                 return -EINVAL;
 70 
 71         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
 72         tty_ldiscs[disc] = new_ldisc;
 73         new_ldisc->num = disc;
 74         new_ldisc->refcount = 0;
 75         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
 76 
 77         return ret;
 78 }
 79 EXPORT_SYMBOL(tty_register_ldisc);
 80 
 81 /**
 82  *      tty_unregister_ldisc    -       unload a line discipline
 83  *      @disc: ldisc number
 84  *      @new_ldisc: pointer to the ldisc object
 85  *
 86  *      Remove a line discipline from the kernel providing it is not
 87  *      currently in use.
 88  *
 89  *      Locking:
 90  *              takes tty_ldiscs_lock to guard against ldisc races
 91  */
 92 
 93 int tty_unregister_ldisc(int disc)
 94 {
 95         unsigned long flags;
 96         int ret = 0;
 97 
 98         if (disc < N_TTY || disc >= NR_LDISCS)
 99                 return -EINVAL;
100 
101         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
102         if (tty_ldiscs[disc]->refcount)
103                 ret = -EBUSY;
104         else
105                 tty_ldiscs[disc] = NULL;
106         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
107 
108         return ret;
109 }
110 EXPORT_SYMBOL(tty_unregister_ldisc);
111 
112 static struct tty_ldisc_ops *get_ldops(int disc)
113 {
114         unsigned long flags;
115         struct tty_ldisc_ops *ldops, *ret;
116 
117         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
118         ret = ERR_PTR(-EINVAL);
119         ldops = tty_ldiscs[disc];
120         if (ldops) {
121                 ret = ERR_PTR(-EAGAIN);
122                 if (try_module_get(ldops->owner)) {
123                         ldops->refcount++;
124                         ret = ldops;
125                 }
126         }
127         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
128         return ret;
129 }
130 
131 static void put_ldops(struct tty_ldisc_ops *ldops)
132 {
133         unsigned long flags;
134 
135         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
136         ldops->refcount--;
137         module_put(ldops->owner);
138         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
139 }
140 
141 /**
142  *      tty_ldisc_get           -       take a reference to an ldisc
143  *      @disc: ldisc number
144  *
145  *      Takes a reference to a line discipline. Deals with refcounts and
146  *      module locking counts. Returns NULL if the discipline is not available.
147  *      Returns a pointer to the discipline and bumps the ref count if it is
148  *      available
149  *
150  *      Locking:
151  *              takes tty_ldiscs_lock to guard against ldisc races
152  */
153 
154 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
155 {
156         struct tty_ldisc *ld;
157         struct tty_ldisc_ops *ldops;
158 
159         if (disc < N_TTY || disc >= NR_LDISCS)
160                 return ERR_PTR(-EINVAL);
161 
162         /*
163          * Get the ldisc ops - we may need to request them to be loaded
164          * dynamically and try again.
165          */
166         ldops = get_ldops(disc);
167         if (IS_ERR(ldops)) {
168                 request_module("tty-ldisc-%d", disc);
169                 ldops = get_ldops(disc);
170                 if (IS_ERR(ldops))
171                         return ERR_CAST(ldops);
172         }
173 
174         ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
175         if (ld == NULL) {
176                 put_ldops(ldops);
177                 return ERR_PTR(-ENOMEM);
178         }
179 
180         ld->ops = ldops;
181         ld->tty = tty;
182 
183         return ld;
184 }
185 
186 /**
187  *      tty_ldisc_put           -       release the ldisc
188  *
189  *      Complement of tty_ldisc_get().
190  */
191 static inline void tty_ldisc_put(struct tty_ldisc *ld)
192 {
193         if (WARN_ON_ONCE(!ld))
194                 return;
195 
196         put_ldops(ld->ops);
197         kfree(ld);
198 }
199 
200 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
201 {
202         return (*pos < NR_LDISCS) ? pos : NULL;
203 }
204 
205 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
206 {
207         (*pos)++;
208         return (*pos < NR_LDISCS) ? pos : NULL;
209 }
210 
211 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
212 {
213 }
214 
215 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
216 {
217         int i = *(loff_t *)v;
218         struct tty_ldisc_ops *ldops;
219 
220         ldops = get_ldops(i);
221         if (IS_ERR(ldops))
222                 return 0;
223         seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
224         put_ldops(ldops);
225         return 0;
226 }
227 
228 static const struct seq_operations tty_ldiscs_seq_ops = {
229         .start  = tty_ldiscs_seq_start,
230         .next   = tty_ldiscs_seq_next,
231         .stop   = tty_ldiscs_seq_stop,
232         .show   = tty_ldiscs_seq_show,
233 };
234 
235 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
236 {
237         return seq_open(file, &tty_ldiscs_seq_ops);
238 }
239 
240 const struct file_operations tty_ldiscs_proc_fops = {
241         .owner          = THIS_MODULE,
242         .open           = proc_tty_ldiscs_open,
243         .read           = seq_read,
244         .llseek         = seq_lseek,
245         .release        = seq_release,
246 };
247 
248 /**
249  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
250  *      @tty: tty device
251  *
252  *      Dereference the line discipline for the terminal and take a
253  *      reference to it. If the line discipline is in flux then
254  *      wait patiently until it changes.
255  *
256  *      Note: Must not be called from an IRQ/timer context. The caller
257  *      must also be careful not to hold other locks that will deadlock
258  *      against a discipline change, such as an existing ldisc reference
259  *      (which we check for)
260  *
261  *      Note: only callable from a file_operations routine (which
262  *      guarantees tty->ldisc != NULL when the lock is acquired).
263  */
264 
265 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
266 {
267         ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
268         WARN_ON(!tty->ldisc);
269         return tty->ldisc;
270 }
271 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
272 
273 /**
274  *      tty_ldisc_ref           -       get the tty ldisc
275  *      @tty: tty device
276  *
277  *      Dereference the line discipline for the terminal and take a
278  *      reference to it. If the line discipline is in flux then
279  *      return NULL. Can be called from IRQ and timer functions.
280  */
281 
282 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
283 {
284         struct tty_ldisc *ld = NULL;
285 
286         if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
287                 ld = tty->ldisc;
288                 if (!ld)
289                         ldsem_up_read(&tty->ldisc_sem);
290         }
291         return ld;
292 }
293 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
294 
295 /**
296  *      tty_ldisc_deref         -       free a tty ldisc reference
297  *      @ld: reference to free up
298  *
299  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
300  *      be called in IRQ context.
301  */
302 
303 void tty_ldisc_deref(struct tty_ldisc *ld)
304 {
305         ldsem_up_read(&ld->tty->ldisc_sem);
306 }
307 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
308 
309 
310 static inline int __lockfunc
311 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
312 {
313         return ldsem_down_write(&tty->ldisc_sem, timeout);
314 }
315 
316 static inline int __lockfunc
317 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
318 {
319         return ldsem_down_write_nested(&tty->ldisc_sem,
320                                        LDISC_SEM_OTHER, timeout);
321 }
322 
323 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
324 {
325         return ldsem_up_write(&tty->ldisc_sem);
326 }
327 
328 static int __lockfunc
329 tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
330 {
331         int ret;
332 
333         ret = __tty_ldisc_lock(tty, timeout);
334         if (!ret)
335                 return -EBUSY;
336         set_bit(TTY_LDISC_HALTED, &tty->flags);
337         return 0;
338 }
339 
340 static void tty_ldisc_unlock(struct tty_struct *tty)
341 {
342         clear_bit(TTY_LDISC_HALTED, &tty->flags);
343         __tty_ldisc_unlock(tty);
344 }
345 
346 static int __lockfunc
347 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
348                             unsigned long timeout)
349 {
350         int ret;
351 
352         if (tty < tty2) {
353                 ret = __tty_ldisc_lock(tty, timeout);
354                 if (ret) {
355                         ret = __tty_ldisc_lock_nested(tty2, timeout);
356                         if (!ret)
357                                 __tty_ldisc_unlock(tty);
358                 }
359         } else {
360                 /* if this is possible, it has lots of implications */
361                 WARN_ON_ONCE(tty == tty2);
362                 if (tty2 && tty != tty2) {
363                         ret = __tty_ldisc_lock(tty2, timeout);
364                         if (ret) {
365                                 ret = __tty_ldisc_lock_nested(tty, timeout);
366                                 if (!ret)
367                                         __tty_ldisc_unlock(tty2);
368                         }
369                 } else
370                         ret = __tty_ldisc_lock(tty, timeout);
371         }
372 
373         if (!ret)
374                 return -EBUSY;
375 
376         set_bit(TTY_LDISC_HALTED, &tty->flags);
377         if (tty2)
378                 set_bit(TTY_LDISC_HALTED, &tty2->flags);
379         return 0;
380 }
381 
382 static void __lockfunc
383 tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
384 {
385         tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
386 }
387 
388 static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
389                                              struct tty_struct *tty2)
390 {
391         __tty_ldisc_unlock(tty);
392         if (tty2)
393                 __tty_ldisc_unlock(tty2);
394 }
395 
396 /**
397  *      tty_ldisc_flush -       flush line discipline queue
398  *      @tty: tty
399  *
400  *      Flush the line discipline queue (if any) and the tty flip buffers
401  *      for this tty.
402  */
403 
404 void tty_ldisc_flush(struct tty_struct *tty)
405 {
406         struct tty_ldisc *ld = tty_ldisc_ref(tty);
407 
408         tty_buffer_flush(tty, ld);
409         if (ld)
410                 tty_ldisc_deref(ld);
411 }
412 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
413 
414 /**
415  *      tty_set_termios_ldisc           -       set ldisc field
416  *      @tty: tty structure
417  *      @num: line discipline number
418  *
419  *      This is probably overkill for real world processors but
420  *      they are not on hot paths so a little discipline won't do
421  *      any harm.
422  *
423  *      Locking: takes termios_rwsem
424  */
425 
426 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
427 {
428         down_write(&tty->termios_rwsem);
429         tty->termios.c_line = num;
430         up_write(&tty->termios_rwsem);
431 }
432 
433 /**
434  *      tty_ldisc_open          -       open a line discipline
435  *      @tty: tty we are opening the ldisc on
436  *      @ld: discipline to open
437  *
438  *      A helper opening method. Also a convenient debugging and check
439  *      point.
440  *
441  *      Locking: always called with BTM already held.
442  */
443 
444 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
445 {
446         WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
447         if (ld->ops->open) {
448                 int ret;
449                 /* BTM here locks versus a hangup event */
450                 ret = ld->ops->open(tty);
451                 if (ret)
452                         clear_bit(TTY_LDISC_OPEN, &tty->flags);
453                 return ret;
454         }
455         return 0;
456 }
457 
458 /**
459  *      tty_ldisc_close         -       close a line discipline
460  *      @tty: tty we are opening the ldisc on
461  *      @ld: discipline to close
462  *
463  *      A helper close method. Also a convenient debugging and check
464  *      point.
465  */
466 
467 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
468 {
469         WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
470         clear_bit(TTY_LDISC_OPEN, &tty->flags);
471         if (ld->ops->close)
472                 ld->ops->close(tty);
473 }
474 
475 /**
476  *      tty_ldisc_restore       -       helper for tty ldisc change
477  *      @tty: tty to recover
478  *      @old: previous ldisc
479  *
480  *      Restore the previous line discipline or N_TTY when a line discipline
481  *      change fails due to an open error
482  */
483 
484 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
485 {
486         char buf[64];
487         struct tty_ldisc *new_ldisc;
488         int r;
489 
490         /* There is an outstanding reference here so this is safe */
491         old = tty_ldisc_get(tty, old->ops->num);
492         WARN_ON(IS_ERR(old));
493         tty->ldisc = old;
494         tty_set_termios_ldisc(tty, old->ops->num);
495         if (tty_ldisc_open(tty, old) < 0) {
496                 tty_ldisc_put(old);
497                 /* This driver is always present */
498                 new_ldisc = tty_ldisc_get(tty, N_TTY);
499                 if (IS_ERR(new_ldisc))
500                         panic("n_tty: get");
501                 tty->ldisc = new_ldisc;
502                 tty_set_termios_ldisc(tty, N_TTY);
503                 r = tty_ldisc_open(tty, new_ldisc);
504                 if (r < 0)
505                         panic("Couldn't open N_TTY ldisc for "
506                               "%s --- error %d.",
507                               tty_name(tty, buf), r);
508         }
509 }
510 
511 /**
512  *      tty_set_ldisc           -       set line discipline
513  *      @tty: the terminal to set
514  *      @ldisc: the line discipline
515  *
516  *      Set the discipline of a tty line. Must be called from a process
517  *      context. The ldisc change logic has to protect itself against any
518  *      overlapping ldisc change (including on the other end of pty pairs),
519  *      the close of one side of a tty/pty pair, and eventually hangup.
520  */
521 
522 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
523 {
524         int retval;
525         struct tty_ldisc *old_ldisc, *new_ldisc;
526 
527         new_ldisc = tty_ldisc_get(tty, ldisc);
528         if (IS_ERR(new_ldisc))
529                 return PTR_ERR(new_ldisc);
530 
531         tty_lock(tty);
532         retval = tty_ldisc_lock(tty, 5 * HZ);
533         if (retval) {
534                 tty_ldisc_put(new_ldisc);
535                 tty_unlock(tty);
536                 return retval;
537         }
538 
539         /*
540          *      Check the no-op case
541          */
542 
543         if (tty->ldisc->ops->num == ldisc) {
544                 tty_ldisc_unlock(tty);
545                 tty_ldisc_put(new_ldisc);
546                 tty_unlock(tty);
547                 return 0;
548         }
549 
550         old_ldisc = tty->ldisc;
551 
552         if (test_bit(TTY_HUPPED, &tty->flags)) {
553                 /* We were raced by the hangup method. It will have stomped
554                    the ldisc data and closed the ldisc down */
555                 tty_ldisc_unlock(tty);
556                 tty_ldisc_put(new_ldisc);
557                 tty_unlock(tty);
558                 return -EIO;
559         }
560 
561         /* Shutdown the old discipline. */
562         tty_ldisc_close(tty, old_ldisc);
563 
564         /* Now set up the new line discipline. */
565         tty->ldisc = new_ldisc;
566         tty_set_termios_ldisc(tty, ldisc);
567 
568         retval = tty_ldisc_open(tty, new_ldisc);
569         if (retval < 0) {
570                 /* Back to the old one or N_TTY if we can't */
571                 tty_ldisc_put(new_ldisc);
572                 tty_ldisc_restore(tty, old_ldisc);
573         }
574 
575         if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
576                 down_read(&tty->termios_rwsem);
577                 tty->ops->set_ldisc(tty);
578                 up_read(&tty->termios_rwsem);
579         }
580 
581         /* At this point we hold a reference to the new ldisc and a
582            reference to the old ldisc, or we hold two references to
583            the old ldisc (if it was restored as part of error cleanup
584            above). In either case, releasing a single reference from
585            the old ldisc is correct. */
586 
587         tty_ldisc_put(old_ldisc);
588 
589         /*
590          *      Allow ldisc referencing to occur again
591          */
592         tty_ldisc_unlock(tty);
593 
594         /* Restart the work queue in case no characters kick it off. Safe if
595            already running */
596         schedule_work(&tty->port->buf.work);
597 
598         tty_unlock(tty);
599         return retval;
600 }
601 
602 /**
603  *      tty_reset_termios       -       reset terminal state
604  *      @tty: tty to reset
605  *
606  *      Restore a terminal to the driver default state.
607  */
608 
609 static void tty_reset_termios(struct tty_struct *tty)
610 {
611         down_write(&tty->termios_rwsem);
612         tty->termios = tty->driver->init_termios;
613         tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
614         tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
615         up_write(&tty->termios_rwsem);
616 }
617 
618 
619 /**
620  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
621  *      @tty: tty to reinit
622  *      @ldisc: line discipline to reinitialize
623  *
624  *      Switch the tty to a line discipline and leave the ldisc
625  *      state closed
626  */
627 
628 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
629 {
630         struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
631 
632         if (IS_ERR(ld))
633                 return -1;
634 
635         tty_ldisc_close(tty, tty->ldisc);
636         tty_ldisc_put(tty->ldisc);
637         /*
638          *      Switch the line discipline back
639          */
640         tty->ldisc = ld;
641         tty_set_termios_ldisc(tty, ldisc);
642 
643         return 0;
644 }
645 
646 /**
647  *      tty_ldisc_hangup                -       hangup ldisc reset
648  *      @tty: tty being hung up
649  *
650  *      Some tty devices reset their termios when they receive a hangup
651  *      event. In that situation we must also switch back to N_TTY properly
652  *      before we reset the termios data.
653  *
654  *      Locking: We can take the ldisc mutex as the rest of the code is
655  *      careful to allow for this.
656  *
657  *      In the pty pair case this occurs in the close() path of the
658  *      tty itself so we must be careful about locking rules.
659  */
660 
661 void tty_ldisc_hangup(struct tty_struct *tty)
662 {
663         struct tty_ldisc *ld;
664         int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
665         int err = 0;
666 
667         tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
668 
669         ld = tty_ldisc_ref(tty);
670         if (ld != NULL) {
671                 if (ld->ops->flush_buffer)
672                         ld->ops->flush_buffer(tty);
673                 tty_driver_flush_buffer(tty);
674                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
675                     ld->ops->write_wakeup)
676                         ld->ops->write_wakeup(tty);
677                 if (ld->ops->hangup)
678                         ld->ops->hangup(tty);
679                 tty_ldisc_deref(ld);
680         }
681 
682         wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
683         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
684 
685         /*
686          * Shutdown the current line discipline, and reset it to
687          * N_TTY if need be.
688          *
689          * Avoid racing set_ldisc or tty_ldisc_release
690          */
691         tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
692 
693         if (tty->ldisc) {
694 
695                 /* At this point we have a halted ldisc; we want to close it and
696                    reopen a new ldisc. We could defer the reopen to the next
697                    open but it means auditing a lot of other paths so this is
698                    a FIXME */
699                 if (reset == 0) {
700 
701                         if (!tty_ldisc_reinit(tty, tty->termios.c_line))
702                                 err = tty_ldisc_open(tty, tty->ldisc);
703                         else
704                                 err = 1;
705                 }
706                 /* If the re-open fails or we reset then go to N_TTY. The
707                    N_TTY open cannot fail */
708                 if (reset || err) {
709                         BUG_ON(tty_ldisc_reinit(tty, N_TTY));
710                         WARN_ON(tty_ldisc_open(tty, tty->ldisc));
711                 }
712         }
713         tty_ldisc_unlock(tty);
714         if (reset)
715                 tty_reset_termios(tty);
716 
717         tty_ldisc_debug(tty, "re-opened ldisc: %p\n", tty->ldisc);
718 }
719 
720 /**
721  *      tty_ldisc_setup                 -       open line discipline
722  *      @tty: tty being shut down
723  *      @o_tty: pair tty for pty/tty pairs
724  *
725  *      Called during the initial open of a tty/pty pair in order to set up the
726  *      line disciplines and bind them to the tty. This has no locking issues
727  *      as the device isn't yet active.
728  */
729 
730 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
731 {
732         struct tty_ldisc *ld = tty->ldisc;
733         int retval;
734 
735         retval = tty_ldisc_open(tty, ld);
736         if (retval)
737                 return retval;
738 
739         if (o_tty) {
740                 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
741                 if (retval) {
742                         tty_ldisc_close(tty, ld);
743                         return retval;
744                 }
745         }
746         return 0;
747 }
748 
749 static void tty_ldisc_kill(struct tty_struct *tty)
750 {
751         /*
752          * Now kill off the ldisc
753          */
754         tty_ldisc_close(tty, tty->ldisc);
755         tty_ldisc_put(tty->ldisc);
756         /* Force an oops if we mess this up */
757         tty->ldisc = NULL;
758 
759         /* Ensure the next open requests the N_TTY ldisc */
760         tty_set_termios_ldisc(tty, N_TTY);
761 }
762 
763 /**
764  *      tty_ldisc_release               -       release line discipline
765  *      @tty: tty being shut down (or one end of pty pair)
766  *
767  *      Called during the final close of a tty or a pty pair in order to shut
768  *      down the line discpline layer. On exit, each ldisc assigned is N_TTY and
769  *      each ldisc has not been opened.
770  */
771 
772 void tty_ldisc_release(struct tty_struct *tty)
773 {
774         struct tty_struct *o_tty = tty->link;
775 
776         /*
777          * Shutdown this line discipline. As this is the final close,
778          * it does not race with the set_ldisc code path.
779          */
780 
781         tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
782 
783         tty_ldisc_lock_pair(tty, o_tty);
784         tty_ldisc_kill(tty);
785         if (o_tty)
786                 tty_ldisc_kill(o_tty);
787         tty_ldisc_unlock_pair(tty, o_tty);
788 
789         /* And the memory resources remaining (buffers, termios) will be
790            disposed of when the kref hits zero */
791 
792         tty_ldisc_debug(tty, "ldisc closed\n");
793 }
794 
795 /**
796  *      tty_ldisc_init          -       ldisc setup for new tty
797  *      @tty: tty being allocated
798  *
799  *      Set up the line discipline objects for a newly allocated tty. Note that
800  *      the tty structure is not completely set up when this call is made.
801  */
802 
803 void tty_ldisc_init(struct tty_struct *tty)
804 {
805         struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
806         if (IS_ERR(ld))
807                 panic("n_tty: init_tty");
808         tty->ldisc = ld;
809 }
810 
811 /**
812  *      tty_ldisc_init          -       ldisc cleanup for new tty
813  *      @tty: tty that was allocated recently
814  *
815  *      The tty structure must not becompletely set up (tty_ldisc_setup) when
816  *      this call is made.
817  */
818 void tty_ldisc_deinit(struct tty_struct *tty)
819 {
820         tty_ldisc_put(tty->ldisc);
821         tty->ldisc = NULL;
822 }
823 
824 void tty_ldisc_begin(void)
825 {
826         /* Setup the default TTY line discipline. */
827         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
828 }
829 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us