blob: 2d822aa259b2f73ad93212c949e900701d776f04 [file] [log] [blame]
Alan Cox01e1abb2008-07-22 11:16:55 +01001#include <linux/types.h>
Alan Cox01e1abb2008-07-22 11:16:55 +01002#include <linux/errno.h>
Jiri Slaby8b3ffa12011-11-16 16:27:10 +01003#include <linux/kmod.h>
Alan Cox01e1abb2008-07-22 11:16:55 +01004#include <linux/sched.h>
5#include <linux/interrupt.h>
6#include <linux/tty.h>
7#include <linux/tty_driver.h>
Alan Cox01e1abb2008-07-22 11:16:55 +01008#include <linux/file.h>
Alan Cox01e1abb2008-07-22 11:16:55 +01009#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>
Alan Cox01e1abb2008-07-22 11:16:55 +010014#include <linux/module.h>
Alan Cox01e1abb2008-07-22 11:16:55 +010015#include <linux/device.h>
16#include <linux/wait.h>
17#include <linux/bitops.h>
Alan Cox01e1abb2008-07-22 11:16:55 +010018#include <linux/seq_file.h>
Alan Cox01e1abb2008-07-22 11:16:55 +010019#include <linux/uaccess.h>
Jiri Slaby0c73c082011-11-16 16:27:09 +010020#include <linux/ratelimit.h>
Alan Cox01e1abb2008-07-22 11:16:55 +010021
Peter Hurleyfc575ee2013-03-11 16:44:38 -040022#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
Peter Hurleyd2c43892013-06-15 07:04:47 -040033/* lockdep nested classes for tty->ldisc_sem */
34enum {
35 LDISC_SEM_NORMAL,
36 LDISC_SEM_OTHER,
37};
38
39
Alan Cox01e1abb2008-07-22 11:16:55 +010040/*
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
Peter Hurley137084b2013-06-15 07:04:46 -040046static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
Alan Cox01e1abb2008-07-22 11:16:55 +010047/* Line disc dispatch table */
48static 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:
Peter Hurley137084b2013-06-15 07:04:46 -040060 * takes tty_ldiscs_lock to guard against ldisc races
Alan Cox01e1abb2008-07-22 11:16:55 +010061 */
62
63int 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
Peter Hurley137084b2013-06-15 07:04:46 -040071 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +010072 tty_ldiscs[disc] = new_ldisc;
73 new_ldisc->num = disc;
74 new_ldisc->refcount = 0;
Peter Hurley137084b2013-06-15 07:04:46 -040075 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +010076
77 return ret;
78}
79EXPORT_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:
Peter Hurley137084b2013-06-15 07:04:46 -040090 * takes tty_ldiscs_lock to guard against ldisc races
Alan Cox01e1abb2008-07-22 11:16:55 +010091 */
92
93int 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
Peter Hurley137084b2013-06-15 07:04:46 -0400101 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +0100102 if (tty_ldiscs[disc]->refcount)
103 ret = -EBUSY;
104 else
105 tty_ldiscs[disc] = NULL;
Peter Hurley137084b2013-06-15 07:04:46 -0400106 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +0100107
108 return ret;
109}
110EXPORT_SYMBOL(tty_unregister_ldisc);
111
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700112static struct tty_ldisc_ops *get_ldops(int disc)
113{
114 unsigned long flags;
115 struct tty_ldisc_ops *ldops, *ret;
116
Peter Hurley137084b2013-06-15 07:04:46 -0400117 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700118 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 }
Peter Hurley137084b2013-06-15 07:04:46 -0400127 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700128 return ret;
129}
130
131static void put_ldops(struct tty_ldisc_ops *ldops)
132{
133 unsigned long flags;
134
Peter Hurley137084b2013-06-15 07:04:46 -0400135 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700136 ldops->refcount--;
137 module_put(ldops->owner);
Peter Hurley137084b2013-06-15 07:04:46 -0400138 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700139}
Alan Cox01e1abb2008-07-22 11:16:55 +0100140
141/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100142 * tty_ldisc_get - take a reference to an ldisc
143 * @disc: ldisc number
Alan Cox01e1abb2008-07-22 11:16:55 +0100144 *
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:
Peter Hurley137084b2013-06-15 07:04:46 -0400151 * takes tty_ldiscs_lock to guard against ldisc races
Alan Cox01e1abb2008-07-22 11:16:55 +0100152 */
153
Peter Hurley36697522013-06-15 07:04:48 -0400154static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
Alan Cox01e1abb2008-07-22 11:16:55 +0100155{
Alan Coxc65c9bc2009-06-11 12:50:12 +0100156 struct tty_ldisc *ld;
Linus Torvalds182274f2009-08-03 16:01:28 -0700157 struct tty_ldisc_ops *ldops;
Alan Cox01e1abb2008-07-22 11:16:55 +0100158
159 if (disc < N_TTY || disc >= NR_LDISCS)
Alan Coxc65c9bc2009-06-11 12:50:12 +0100160 return ERR_PTR(-EINVAL);
Linus Torvalds182274f2009-08-03 16:01:28 -0700161
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)) {
Alan Cox01e1abb2008-07-22 11:16:55 +0100168 request_module("tty-ldisc-%d", disc);
Linus Torvalds182274f2009-08-03 16:01:28 -0700169 ldops = get_ldops(disc);
170 if (IS_ERR(ldops))
171 return ERR_CAST(ldops);
Alan Cox01e1abb2008-07-22 11:16:55 +0100172 }
Linus Torvalds182274f2009-08-03 16:01:28 -0700173
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;
Peter Hurley36697522013-06-15 07:04:48 -0400181 ld->tty = tty;
Ivo Sieben1541f842012-05-03 14:37:43 +0200182
Alan Coxc65c9bc2009-06-11 12:50:12 +0100183 return ld;
Alan Cox01e1abb2008-07-22 11:16:55 +0100184}
185
Peter Hurley734de242013-03-11 16:44:43 -0400186/**
187 * tty_ldisc_put - release the ldisc
188 *
189 * Complement of tty_ldisc_get().
190 */
191static inline void tty_ldisc_put(struct tty_ldisc *ld)
192{
Peter Hurley734de242013-03-11 16:44:43 -0400193 if (WARN_ON_ONCE(!ld))
194 return;
195
Peter Hurley36697522013-06-15 07:04:48 -0400196 put_ldops(ld->ops);
Peter Hurley734de242013-03-11 16:44:43 -0400197 kfree(ld);
Peter Hurley734de242013-03-11 16:44:43 -0400198}
199
Alan Cox852e99d2009-06-11 12:51:41 +0100200static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
Alan Cox01e1abb2008-07-22 11:16:55 +0100201{
202 return (*pos < NR_LDISCS) ? pos : NULL;
203}
204
Alan Cox852e99d2009-06-11 12:51:41 +0100205static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
Alan Cox01e1abb2008-07-22 11:16:55 +0100206{
207 (*pos)++;
208 return (*pos < NR_LDISCS) ? pos : NULL;
209}
210
211static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
212{
213}
214
215static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
216{
217 int i = *(loff_t *)v;
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700218 struct tty_ldisc_ops *ldops;
Alan Cox852e99d2009-06-11 12:51:41 +0100219
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700220 ldops = get_ldops(i);
221 if (IS_ERR(ldops))
Alan Cox01e1abb2008-07-22 11:16:55 +0100222 return 0;
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700223 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
224 put_ldops(ldops);
Alan Cox01e1abb2008-07-22 11:16:55 +0100225 return 0;
226}
227
228static 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
235static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
236{
237 return seq_open(file, &tty_ldiscs_seq_ops);
238}
239
240const 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/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100249 * 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 *
Peter Hurley36697522013-06-15 07:04:48 -0400261 * Note: only callable from a file_operations routine (which
262 * guarantees tty->ldisc != NULL when the lock is acquired).
Alan Cox01e1abb2008-07-22 11:16:55 +0100263 */
264
265struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
266{
Peter Hurley36697522013-06-15 07:04:48 -0400267 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
268 WARN_ON(!tty->ldisc);
269 return tty->ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100270}
Alan Cox01e1abb2008-07-22 11:16:55 +0100271EXPORT_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.
Alan Cox01e1abb2008-07-22 11:16:55 +0100280 */
281
282struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
283{
Peter Hurley36697522013-06-15 07:04:48 -0400284 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;
Alan Cox01e1abb2008-07-22 11:16:55 +0100292}
Alan Cox01e1abb2008-07-22 11:16:55 +0100293EXPORT_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.
Alan Cox01e1abb2008-07-22 11:16:55 +0100301 */
302
303void tty_ldisc_deref(struct tty_ldisc *ld)
304{
Peter Hurley36697522013-06-15 07:04:48 -0400305 ldsem_up_read(&ld->tty->ldisc_sem);
Alan Cox01e1abb2008-07-22 11:16:55 +0100306}
Alan Cox01e1abb2008-07-22 11:16:55 +0100307EXPORT_SYMBOL_GPL(tty_ldisc_deref);
308
Peter Hurleyd2c43892013-06-15 07:04:47 -0400309
310static inline int __lockfunc
311tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
312{
313 return ldsem_down_write(&tty->ldisc_sem, timeout);
314}
315
316static inline int __lockfunc
317tty_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
323static inline void tty_ldisc_unlock(struct tty_struct *tty)
324{
325 return ldsem_up_write(&tty->ldisc_sem);
326}
327
328static int __lockfunc
329tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
330 unsigned long timeout)
331{
332 int ret;
333
334 if (tty < tty2) {
335 ret = tty_ldisc_lock(tty, timeout);
336 if (ret) {
337 ret = tty_ldisc_lock_nested(tty2, timeout);
338 if (!ret)
339 tty_ldisc_unlock(tty);
340 }
341 } else {
342 /* if this is possible, it has lots of implications */
343 WARN_ON_ONCE(tty == tty2);
344 if (tty2 && tty != tty2) {
345 ret = tty_ldisc_lock(tty2, timeout);
346 if (ret) {
347 ret = tty_ldisc_lock_nested(tty, timeout);
348 if (!ret)
349 tty_ldisc_unlock(tty2);
350 }
351 } else
352 ret = tty_ldisc_lock(tty, timeout);
353 }
354
355 if (!ret)
356 return -EBUSY;
357
358 set_bit(TTY_LDISC_HALTED, &tty->flags);
359 if (tty2)
360 set_bit(TTY_LDISC_HALTED, &tty2->flags);
361 return 0;
362}
363
364static void __lockfunc
365tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
366{
367 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
368}
369
370static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
371 struct tty_struct *tty2)
372{
373 tty_ldisc_unlock(tty);
374 if (tty2)
375 tty_ldisc_unlock(tty2);
376}
377
378static void __lockfunc tty_ldisc_enable_pair(struct tty_struct *tty,
379 struct tty_struct *tty2)
380{
381 clear_bit(TTY_LDISC_HALTED, &tty->flags);
382 if (tty2)
383 clear_bit(TTY_LDISC_HALTED, &tty2->flags);
384
385 tty_ldisc_unlock_pair(tty, tty2);
386}
387
Alan Cox01e1abb2008-07-22 11:16:55 +0100388/**
Alan Coxf2c4c652009-06-11 12:50:58 +0100389 * tty_ldisc_flush - flush line discipline queue
390 * @tty: tty
391 *
392 * Flush the line discipline queue (if any) for this tty. If there
393 * is no line discipline active this is a no-op.
394 */
395
396void tty_ldisc_flush(struct tty_struct *tty)
397{
398 struct tty_ldisc *ld = tty_ldisc_ref(tty);
399 if (ld) {
400 if (ld->ops->flush_buffer)
401 ld->ops->flush_buffer(tty);
402 tty_ldisc_deref(ld);
403 }
404 tty_buffer_flush(tty);
405}
Alan Coxf2c4c652009-06-11 12:50:58 +0100406EXPORT_SYMBOL_GPL(tty_ldisc_flush);
407
408/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100409 * tty_set_termios_ldisc - set ldisc field
410 * @tty: tty structure
411 * @num: line discipline number
412 *
413 * This is probably overkill for real world processors but
414 * they are not on hot paths so a little discipline won't do
415 * any harm.
416 *
Peter Hurley6a1c0682013-06-15 09:14:23 -0400417 * Locking: takes termios_rwsem
Alan Cox01e1abb2008-07-22 11:16:55 +0100418 */
419
420static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
421{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400422 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100423 tty->termios.c_line = num;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400424 up_write(&tty->termios_rwsem);
Alan Cox01e1abb2008-07-22 11:16:55 +0100425}
426
Alan Coxc65c9bc2009-06-11 12:50:12 +0100427/**
428 * tty_ldisc_open - open a line discipline
429 * @tty: tty we are opening the ldisc on
430 * @ld: discipline to open
431 *
432 * A helper opening method. Also a convenient debugging and check
433 * point.
Arnd Bergmannec79d602010-06-01 22:53:01 +0200434 *
435 * Locking: always called with BTM already held.
Alan Coxc65c9bc2009-06-11 12:50:12 +0100436 */
437
438static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
439{
440 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
Alan Coxf18f9492009-11-30 13:18:35 +0000441 if (ld->ops->open) {
442 int ret;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200443 /* BTM here locks versus a hangup event */
Alan Coxf18f9492009-11-30 13:18:35 +0000444 ret = ld->ops->open(tty);
Jiri Slaby7f90cfc2010-11-25 00:27:54 +0100445 if (ret)
446 clear_bit(TTY_LDISC_OPEN, &tty->flags);
Alan Coxf18f9492009-11-30 13:18:35 +0000447 return ret;
448 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100449 return 0;
450}
451
452/**
453 * tty_ldisc_close - close a line discipline
454 * @tty: tty we are opening the ldisc on
455 * @ld: discipline to close
456 *
457 * A helper close method. Also a convenient debugging and check
458 * point.
459 */
460
461static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
462{
463 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
464 clear_bit(TTY_LDISC_OPEN, &tty->flags);
465 if (ld->ops->close)
466 ld->ops->close(tty);
467}
Alan Cox01e1abb2008-07-22 11:16:55 +0100468
469/**
470 * tty_ldisc_restore - helper for tty ldisc change
471 * @tty: tty to recover
472 * @old: previous ldisc
473 *
474 * Restore the previous line discipline or N_TTY when a line discipline
475 * change fails due to an open error
476 */
477
478static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
479{
480 char buf[64];
Alan Coxc65c9bc2009-06-11 12:50:12 +0100481 struct tty_ldisc *new_ldisc;
482 int r;
Alan Cox01e1abb2008-07-22 11:16:55 +0100483
484 /* There is an outstanding reference here so this is safe */
Peter Hurley36697522013-06-15 07:04:48 -0400485 old = tty_ldisc_get(tty, old->ops->num);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100486 WARN_ON(IS_ERR(old));
Peter Hurleyf48070452013-03-11 16:44:42 -0400487 tty->ldisc = old;
Alan Cox01e1abb2008-07-22 11:16:55 +0100488 tty_set_termios_ldisc(tty, old->ops->num);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100489 if (tty_ldisc_open(tty, old) < 0) {
490 tty_ldisc_put(old);
Alan Cox01e1abb2008-07-22 11:16:55 +0100491 /* This driver is always present */
Peter Hurley36697522013-06-15 07:04:48 -0400492 new_ldisc = tty_ldisc_get(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100493 if (IS_ERR(new_ldisc))
Alan Cox01e1abb2008-07-22 11:16:55 +0100494 panic("n_tty: get");
Peter Hurleyf48070452013-03-11 16:44:42 -0400495 tty->ldisc = new_ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100496 tty_set_termios_ldisc(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100497 r = tty_ldisc_open(tty, new_ldisc);
498 if (r < 0)
499 panic("Couldn't open N_TTY ldisc for "
500 "%s --- error %d.",
501 tty_name(tty, buf), r);
Alan Cox01e1abb2008-07-22 11:16:55 +0100502 }
503}
504
505/**
506 * tty_set_ldisc - set line discipline
507 * @tty: the terminal to set
508 * @ldisc: the line discipline
509 *
510 * Set the discipline of a tty line. Must be called from a process
Alan Coxc65c9bc2009-06-11 12:50:12 +0100511 * context. The ldisc change logic has to protect itself against any
512 * overlapping ldisc change (including on the other end of pty pairs),
513 * the close of one side of a tty/pty pair, and eventually hangup.
Alan Cox01e1abb2008-07-22 11:16:55 +0100514 */
515
516int tty_set_ldisc(struct tty_struct *tty, int ldisc)
517{
518 int retval;
Peter Hurley9fbfa342013-06-15 07:04:49 -0400519 struct tty_ldisc *old_ldisc, *new_ldisc;
Peter Hurley36697522013-06-15 07:04:48 -0400520 struct tty_struct *o_tty = tty->link;
Alan Cox01e1abb2008-07-22 11:16:55 +0100521
Peter Hurley36697522013-06-15 07:04:48 -0400522 new_ldisc = tty_ldisc_get(tty, ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100523 if (IS_ERR(new_ldisc))
524 return PTR_ERR(new_ldisc);
525
Peter Hurley36697522013-06-15 07:04:48 -0400526 retval = tty_ldisc_lock_pair_timeout(tty, o_tty, 5 * HZ);
527 if (retval) {
528 tty_ldisc_put(new_ldisc);
529 return retval;
530 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100531
532 /*
533 * Check the no-op case
534 */
535
536 if (tty->ldisc->ops->num == ldisc) {
Peter Hurley36697522013-06-15 07:04:48 -0400537 tty_ldisc_enable_pair(tty, o_tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100538 tty_ldisc_put(new_ldisc);
539 return 0;
540 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100541
Peter Hurley9fbfa342013-06-15 07:04:49 -0400542 old_ldisc = tty->ldisc;
Alan Cox89c8d912012-08-08 16:30:13 +0100543 tty_lock(tty);
Jiri Slaby100eeae2010-10-31 23:17:51 +0100544
Peter Hurleye97733c2013-06-15 07:04:50 -0400545 if (test_bit(TTY_HUPPING, &tty->flags) ||
546 test_bit(TTY_HUPPED, &tty->flags)) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100547 /* We were raced by the hangup method. It will have stomped
548 the ldisc data and closed the ldisc down */
Peter Hurley36697522013-06-15 07:04:48 -0400549 tty_ldisc_enable_pair(tty, o_tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100550 tty_ldisc_put(new_ldisc);
Alan Cox89c8d912012-08-08 16:30:13 +0100551 tty_unlock(tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100552 return -EIO;
553 }
554
Peter Hurley9fbfa342013-06-15 07:04:49 -0400555 /* Shutdown the old discipline. */
556 tty_ldisc_close(tty, old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100557
558 /* Now set up the new line discipline. */
Peter Hurleyf48070452013-03-11 16:44:42 -0400559 tty->ldisc = new_ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100560 tty_set_termios_ldisc(tty, ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100561
562 retval = tty_ldisc_open(tty, new_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100563 if (retval < 0) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100564 /* Back to the old one or N_TTY if we can't */
565 tty_ldisc_put(new_ldisc);
Peter Hurley9fbfa342013-06-15 07:04:49 -0400566 tty_ldisc_restore(tty, old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100567 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100568
Peter Hurley9fbfa342013-06-15 07:04:49 -0400569 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc)
Alan Cox01e1abb2008-07-22 11:16:55 +0100570 tty->ops->set_ldisc(tty);
571
Peter Hurleyb0e95852013-06-15 07:04:51 -0400572 /* At this point we hold a reference to the new ldisc and a
573 reference to the old ldisc, or we hold two references to
574 the old ldisc (if it was restored as part of error cleanup
575 above). In either case, releasing a single reference from
576 the old ldisc is correct. */
577
Peter Hurley9fbfa342013-06-15 07:04:49 -0400578 tty_ldisc_put(old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100579
580 /*
Alan Coxc65c9bc2009-06-11 12:50:12 +0100581 * Allow ldisc referencing to occur again
Alan Cox01e1abb2008-07-22 11:16:55 +0100582 */
Peter Hurley36697522013-06-15 07:04:48 -0400583 tty_ldisc_enable_pair(tty, o_tty);
Alan Cox01e1abb2008-07-22 11:16:55 +0100584
Alan Coxc65c9bc2009-06-11 12:50:12 +0100585 /* Restart the work queue in case no characters kick it off. Safe if
Alan Cox01e1abb2008-07-22 11:16:55 +0100586 already running */
Peter Hurley4f98d462013-03-11 16:44:34 -0400587 schedule_work(&tty->port->buf.work);
588 if (o_tty)
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200589 schedule_work(&o_tty->port->buf.work);
Peter Hurley4f98d462013-03-11 16:44:34 -0400590
Alan Cox89c8d912012-08-08 16:30:13 +0100591 tty_unlock(tty);
Alan Cox01e1abb2008-07-22 11:16:55 +0100592 return retval;
593}
594
Alan Coxc65c9bc2009-06-11 12:50:12 +0100595/**
596 * tty_reset_termios - reset terminal state
597 * @tty: tty to reset
598 *
599 * Restore a terminal to the driver default state.
600 */
601
602static void tty_reset_termios(struct tty_struct *tty)
603{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400604 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100605 tty->termios = tty->driver->init_termios;
606 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
607 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Peter Hurley6a1c0682013-06-15 09:14:23 -0400608 up_write(&tty->termios_rwsem);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100609}
610
611
612/**
613 * tty_ldisc_reinit - reinitialise the tty ldisc
614 * @tty: tty to reinit
Alan Cox638b9642010-02-08 10:09:26 +0000615 * @ldisc: line discipline to reinitialize
Alan Coxc65c9bc2009-06-11 12:50:12 +0100616 *
Alan Cox638b9642010-02-08 10:09:26 +0000617 * Switch the tty to a line discipline and leave the ldisc
618 * state closed
Alan Coxc65c9bc2009-06-11 12:50:12 +0100619 */
620
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200621static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
Alan Coxc65c9bc2009-06-11 12:50:12 +0100622{
Peter Hurley36697522013-06-15 07:04:48 -0400623 struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200624
625 if (IS_ERR(ld))
626 return -1;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100627
628 tty_ldisc_close(tty, tty->ldisc);
629 tty_ldisc_put(tty->ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100630 /*
631 * Switch the line discipline back
632 */
Peter Hurleyf48070452013-03-11 16:44:42 -0400633 tty->ldisc = ld;
Alan Cox638b9642010-02-08 10:09:26 +0000634 tty_set_termios_ldisc(tty, ldisc);
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200635
636 return 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100637}
638
639/**
640 * tty_ldisc_hangup - hangup ldisc reset
641 * @tty: tty being hung up
642 *
643 * Some tty devices reset their termios when they receive a hangup
644 * event. In that situation we must also switch back to N_TTY properly
645 * before we reset the termios data.
646 *
647 * Locking: We can take the ldisc mutex as the rest of the code is
648 * careful to allow for this.
649 *
650 * In the pty pair case this occurs in the close() path of the
651 * tty itself so we must be careful about locking rules.
652 */
653
654void tty_ldisc_hangup(struct tty_struct *tty)
655{
656 struct tty_ldisc *ld;
Alan Cox638b9642010-02-08 10:09:26 +0000657 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
658 int err = 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100659
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400660 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
661
Alan Coxc65c9bc2009-06-11 12:50:12 +0100662 ld = tty_ldisc_ref(tty);
663 if (ld != NULL) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100664 if (ld->ops->flush_buffer)
665 ld->ops->flush_buffer(tty);
666 tty_driver_flush_buffer(tty);
667 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
668 ld->ops->write_wakeup)
669 ld->ops->write_wakeup(tty);
670 if (ld->ops->hangup)
671 ld->ops->hangup(tty);
672 tty_ldisc_deref(ld);
673 }
Peter Hurley36697522013-06-15 07:04:48 -0400674
Alan Coxc65c9bc2009-06-11 12:50:12 +0100675 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
676 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Peter Hurley36697522013-06-15 07:04:48 -0400677
678 tty_unlock(tty);
679
Alan Coxc65c9bc2009-06-11 12:50:12 +0100680 /*
681 * Shutdown the current line discipline, and reset it to
Alan Cox638b9642010-02-08 10:09:26 +0000682 * N_TTY if need be.
683 *
684 * Avoid racing set_ldisc or tty_ldisc_release
Alan Coxc65c9bc2009-06-11 12:50:12 +0100685 */
Peter Hurley36697522013-06-15 07:04:48 -0400686 tty_ldisc_lock_pair(tty, tty->link);
687 tty_lock(tty);
Arnd Bergmann60af22d2010-06-01 22:53:06 +0200688
Peter Hurley36697522013-06-15 07:04:48 -0400689 if (tty->ldisc) {
Peter Hurleyc8785242013-03-11 16:44:36 -0400690
691 /* At this point we have a halted ldisc; we want to close it and
692 reopen a new ldisc. We could defer the reopen to the next
693 open but it means auditing a lot of other paths so this is
694 a FIXME */
Alan Cox638b9642010-02-08 10:09:26 +0000695 if (reset == 0) {
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200696
Alan Coxadc8d742012-07-14 15:31:47 +0100697 if (!tty_ldisc_reinit(tty, tty->termios.c_line))
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200698 err = tty_ldisc_open(tty, tty->ldisc);
699 else
700 err = 1;
Alan Coxc8d50042009-07-16 16:05:08 +0100701 }
Alan Cox638b9642010-02-08 10:09:26 +0000702 /* If the re-open fails or we reset then go to N_TTY. The
703 N_TTY open cannot fail */
704 if (reset || err) {
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200705 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
Alan Cox638b9642010-02-08 10:09:26 +0000706 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
707 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100708 }
Peter Hurley36697522013-06-15 07:04:48 -0400709 tty_ldisc_enable_pair(tty, tty->link);
Alan Cox638b9642010-02-08 10:09:26 +0000710 if (reset)
711 tty_reset_termios(tty);
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400712
713 tty_ldisc_debug(tty, "re-opened ldisc: %p\n", tty->ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100714}
Alan Cox01e1abb2008-07-22 11:16:55 +0100715
716/**
717 * tty_ldisc_setup - open line discipline
718 * @tty: tty being shut down
719 * @o_tty: pair tty for pty/tty pairs
720 *
721 * Called during the initial open of a tty/pty pair in order to set up the
Alan Coxc65c9bc2009-06-11 12:50:12 +0100722 * line disciplines and bind them to the tty. This has no locking issues
723 * as the device isn't yet active.
Alan Cox01e1abb2008-07-22 11:16:55 +0100724 */
725
726int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
727{
Alan Coxc65c9bc2009-06-11 12:50:12 +0100728 struct tty_ldisc *ld = tty->ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100729 int retval;
730
Alan Coxc65c9bc2009-06-11 12:50:12 +0100731 retval = tty_ldisc_open(tty, ld);
732 if (retval)
733 return retval;
734
735 if (o_tty) {
736 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100737 if (retval) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100738 tty_ldisc_close(tty, ld);
Alan Cox01e1abb2008-07-22 11:16:55 +0100739 return retval;
740 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100741 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100742 return 0;
743}
Alan Cox89c8d912012-08-08 16:30:13 +0100744
745static void tty_ldisc_kill(struct tty_struct *tty)
746{
Alan Cox89c8d912012-08-08 16:30:13 +0100747 /*
748 * Now kill off the ldisc
749 */
750 tty_ldisc_close(tty, tty->ldisc);
751 tty_ldisc_put(tty->ldisc);
752 /* Force an oops if we mess this up */
753 tty->ldisc = NULL;
754
755 /* Ensure the next open requests the N_TTY ldisc */
756 tty_set_termios_ldisc(tty, N_TTY);
Alan Cox89c8d912012-08-08 16:30:13 +0100757}
758
Alan Cox01e1abb2008-07-22 11:16:55 +0100759/**
760 * tty_ldisc_release - release line discipline
761 * @tty: tty being shut down
762 * @o_tty: pair tty for pty/tty pairs
763 *
Alan Cox852e99d2009-06-11 12:51:41 +0100764 * Called during the final close of a tty/pty pair in order to shut down
765 * the line discpline layer. On exit the ldisc assigned is N_TTY and the
Alan Coxc65c9bc2009-06-11 12:50:12 +0100766 * ldisc has not been opened.
Alan Cox01e1abb2008-07-22 11:16:55 +0100767 */
768
769void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
770{
Alan Cox01e1abb2008-07-22 11:16:55 +0100771 /*
Peter Hurleya2965b72013-03-11 16:44:35 -0400772 * Shutdown this line discipline. As this is the final close,
773 * it does not race with the set_ldisc code path.
Alan Cox01e1abb2008-07-22 11:16:55 +0100774 */
Alan Cox01e1abb2008-07-22 11:16:55 +0100775
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400776 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
777
Peter Hurley36697522013-06-15 07:04:48 -0400778 tty_ldisc_lock_pair(tty, o_tty);
Sebastian Andrzej Siewior852e4a82012-12-25 23:02:48 +0100779 tty_lock_pair(tty, o_tty);
Peter Hurley36697522013-06-15 07:04:48 -0400780
Alan Cox89c8d912012-08-08 16:30:13 +0100781 tty_ldisc_kill(tty);
Alan Cox89c8d912012-08-08 16:30:13 +0100782 if (o_tty)
783 tty_ldisc_kill(o_tty);
784
785 tty_unlock_pair(tty, o_tty);
Peter Hurley36697522013-06-15 07:04:48 -0400786 tty_ldisc_unlock_pair(tty, o_tty);
787
Alan Coxaef29bc2009-06-29 15:21:47 +0100788 /* And the memory resources remaining (buffers, termios) will be
789 disposed of when the kref hits zero */
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400790
791 tty_ldisc_debug(tty, "ldisc closed\n");
Alan Cox01e1abb2008-07-22 11:16:55 +0100792}
793
794/**
795 * tty_ldisc_init - ldisc setup for new tty
796 * @tty: tty being allocated
797 *
798 * Set up the line discipline objects for a newly allocated tty. Note that
799 * the tty structure is not completely set up when this call is made.
800 */
801
802void tty_ldisc_init(struct tty_struct *tty)
803{
Peter Hurley36697522013-06-15 07:04:48 -0400804 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100805 if (IS_ERR(ld))
Alan Cox01e1abb2008-07-22 11:16:55 +0100806 panic("n_tty: init_tty");
Peter Hurleyf48070452013-03-11 16:44:42 -0400807 tty->ldisc = ld;
Alan Cox01e1abb2008-07-22 11:16:55 +0100808}
809
Jiri Slaby67166712011-03-23 10:48:35 +0100810/**
811 * tty_ldisc_init - ldisc cleanup for new tty
812 * @tty: tty that was allocated recently
813 *
814 * The tty structure must not becompletely set up (tty_ldisc_setup) when
815 * this call is made.
816 */
817void tty_ldisc_deinit(struct tty_struct *tty)
818{
Peter Hurleyebc9bae2013-03-11 16:44:40 -0400819 tty_ldisc_put(tty->ldisc);
Peter Hurleyf48070452013-03-11 16:44:42 -0400820 tty->ldisc = NULL;
Jiri Slaby67166712011-03-23 10:48:35 +0100821}
822
Alan Cox01e1abb2008-07-22 11:16:55 +0100823void tty_ldisc_begin(void)
824{
825 /* Setup the default TTY line discipline. */
826 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
827}