Version:  2.0.40 2.2.26 2.4.37 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 4.1 4.2 4.3 4.4

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

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