blob: 71750cbac31f745a6a899bc598cf0af1b84556b2 [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
Peter Hurley0a6adc12015-07-12 22:49:10 -040025#define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args)
Peter Hurleyfc575ee2013-03-11 16:44:38 -040026#else
27#define tty_ldisc_debug(tty, f, args...)
28#endif
29
Peter Hurleyd2c43892013-06-15 07:04:47 -040030/* lockdep nested classes for tty->ldisc_sem */
31enum {
32 LDISC_SEM_NORMAL,
33 LDISC_SEM_OTHER,
34};
35
36
Alan Cox01e1abb2008-07-22 11:16:55 +010037/*
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
Peter Hurley137084b2013-06-15 07:04:46 -040043static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
Alan Cox01e1abb2008-07-22 11:16:55 +010044/* Line disc dispatch table */
45static 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:
Peter Hurley137084b2013-06-15 07:04:46 -040057 * takes tty_ldiscs_lock to guard against ldisc races
Alan Cox01e1abb2008-07-22 11:16:55 +010058 */
59
60int 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
Peter Hurley137084b2013-06-15 07:04:46 -040068 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +010069 tty_ldiscs[disc] = new_ldisc;
70 new_ldisc->num = disc;
71 new_ldisc->refcount = 0;
Peter Hurley137084b2013-06-15 07:04:46 -040072 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +010073
74 return ret;
75}
76EXPORT_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:
Peter Hurley137084b2013-06-15 07:04:46 -040087 * takes tty_ldiscs_lock to guard against ldisc races
Alan Cox01e1abb2008-07-22 11:16:55 +010088 */
89
90int 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
Peter Hurley137084b2013-06-15 07:04:46 -040098 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +010099 if (tty_ldiscs[disc]->refcount)
100 ret = -EBUSY;
101 else
102 tty_ldiscs[disc] = NULL;
Peter Hurley137084b2013-06-15 07:04:46 -0400103 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Alan Cox01e1abb2008-07-22 11:16:55 +0100104
105 return ret;
106}
107EXPORT_SYMBOL(tty_unregister_ldisc);
108
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700109static struct tty_ldisc_ops *get_ldops(int disc)
110{
111 unsigned long flags;
112 struct tty_ldisc_ops *ldops, *ret;
113
Peter Hurley137084b2013-06-15 07:04:46 -0400114 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700115 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 }
Peter Hurley137084b2013-06-15 07:04:46 -0400124 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700125 return ret;
126}
127
128static void put_ldops(struct tty_ldisc_ops *ldops)
129{
130 unsigned long flags;
131
Peter Hurley137084b2013-06-15 07:04:46 -0400132 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700133 ldops->refcount--;
134 module_put(ldops->owner);
Peter Hurley137084b2013-06-15 07:04:46 -0400135 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700136}
Alan Cox01e1abb2008-07-22 11:16:55 +0100137
138/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100139 * tty_ldisc_get - take a reference to an ldisc
140 * @disc: ldisc number
Alan Cox01e1abb2008-07-22 11:16:55 +0100141 *
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:
Peter Hurley137084b2013-06-15 07:04:46 -0400148 * takes tty_ldiscs_lock to guard against ldisc races
Alan Cox01e1abb2008-07-22 11:16:55 +0100149 */
150
Peter Hurley36697522013-06-15 07:04:48 -0400151static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
Alan Cox01e1abb2008-07-22 11:16:55 +0100152{
Alan Coxc65c9bc2009-06-11 12:50:12 +0100153 struct tty_ldisc *ld;
Linus Torvalds182274f2009-08-03 16:01:28 -0700154 struct tty_ldisc_ops *ldops;
Alan Cox01e1abb2008-07-22 11:16:55 +0100155
156 if (disc < N_TTY || disc >= NR_LDISCS)
Alan Coxc65c9bc2009-06-11 12:50:12 +0100157 return ERR_PTR(-EINVAL);
Linus Torvalds182274f2009-08-03 16:01:28 -0700158
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)) {
Alan Cox01e1abb2008-07-22 11:16:55 +0100165 request_module("tty-ldisc-%d", disc);
Linus Torvalds182274f2009-08-03 16:01:28 -0700166 ldops = get_ldops(disc);
167 if (IS_ERR(ldops))
168 return ERR_CAST(ldops);
Alan Cox01e1abb2008-07-22 11:16:55 +0100169 }
Linus Torvalds182274f2009-08-03 16:01:28 -0700170
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;
Peter Hurley36697522013-06-15 07:04:48 -0400178 ld->tty = tty;
Ivo Sieben1541f842012-05-03 14:37:43 +0200179
Alan Coxc65c9bc2009-06-11 12:50:12 +0100180 return ld;
Alan Cox01e1abb2008-07-22 11:16:55 +0100181}
182
Peter Hurley734de242013-03-11 16:44:43 -0400183/**
184 * tty_ldisc_put - release the ldisc
185 *
186 * Complement of tty_ldisc_get().
187 */
188static inline void tty_ldisc_put(struct tty_ldisc *ld)
189{
Peter Hurley734de242013-03-11 16:44:43 -0400190 if (WARN_ON_ONCE(!ld))
191 return;
192
Peter Hurley36697522013-06-15 07:04:48 -0400193 put_ldops(ld->ops);
Peter Hurley734de242013-03-11 16:44:43 -0400194 kfree(ld);
Peter Hurley734de242013-03-11 16:44:43 -0400195}
196
Alan Cox852e99d2009-06-11 12:51:41 +0100197static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
Alan Cox01e1abb2008-07-22 11:16:55 +0100198{
199 return (*pos < NR_LDISCS) ? pos : NULL;
200}
201
Alan Cox852e99d2009-06-11 12:51:41 +0100202static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
Alan Cox01e1abb2008-07-22 11:16:55 +0100203{
204 (*pos)++;
205 return (*pos < NR_LDISCS) ? pos : NULL;
206}
207
208static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
209{
210}
211
212static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
213{
214 int i = *(loff_t *)v;
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700215 struct tty_ldisc_ops *ldops;
Alan Cox852e99d2009-06-11 12:51:41 +0100216
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700217 ldops = get_ldops(i);
218 if (IS_ERR(ldops))
Alan Cox01e1abb2008-07-22 11:16:55 +0100219 return 0;
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700220 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
221 put_ldops(ldops);
Alan Cox01e1abb2008-07-22 11:16:55 +0100222 return 0;
223}
224
225static 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
232static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
233{
234 return seq_open(file, &tty_ldiscs_seq_ops);
235}
236
237const 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/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100246 * 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 *
Peter Hurley36697522013-06-15 07:04:48 -0400258 * Note: only callable from a file_operations routine (which
259 * guarantees tty->ldisc != NULL when the lock is acquired).
Alan Cox01e1abb2008-07-22 11:16:55 +0100260 */
261
262struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
263{
Peter Hurley36697522013-06-15 07:04:48 -0400264 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
265 WARN_ON(!tty->ldisc);
266 return tty->ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100267}
Alan Cox01e1abb2008-07-22 11:16:55 +0100268EXPORT_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.
Alan Cox01e1abb2008-07-22 11:16:55 +0100277 */
278
279struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
280{
Peter Hurley36697522013-06-15 07:04:48 -0400281 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;
Alan Cox01e1abb2008-07-22 11:16:55 +0100289}
Alan Cox01e1abb2008-07-22 11:16:55 +0100290EXPORT_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.
Alan Cox01e1abb2008-07-22 11:16:55 +0100298 */
299
300void tty_ldisc_deref(struct tty_ldisc *ld)
301{
Peter Hurley36697522013-06-15 07:04:48 -0400302 ldsem_up_read(&ld->tty->ldisc_sem);
Alan Cox01e1abb2008-07-22 11:16:55 +0100303}
Alan Cox01e1abb2008-07-22 11:16:55 +0100304EXPORT_SYMBOL_GPL(tty_ldisc_deref);
305
Peter Hurleyd2c43892013-06-15 07:04:47 -0400306
307static inline int __lockfunc
Peter Hurleye80a10e2014-11-05 12:13:06 -0500308__tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400309{
310 return ldsem_down_write(&tty->ldisc_sem, timeout);
311}
312
313static inline int __lockfunc
Peter Hurleye80a10e2014-11-05 12:13:06 -0500314__tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400315{
316 return ldsem_down_write_nested(&tty->ldisc_sem,
317 LDISC_SEM_OTHER, timeout);
318}
319
Peter Hurleye80a10e2014-11-05 12:13:06 -0500320static inline void __tty_ldisc_unlock(struct tty_struct *tty)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400321{
322 return ldsem_up_write(&tty->ldisc_sem);
323}
324
325static int __lockfunc
Peter Hurleyfae76e92014-11-05 12:13:07 -0500326tty_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
337static void tty_ldisc_unlock(struct tty_struct *tty)
338{
339 clear_bit(TTY_LDISC_HALTED, &tty->flags);
340 __tty_ldisc_unlock(tty);
341}
342
343static int __lockfunc
Peter Hurleyd2c43892013-06-15 07:04:47 -0400344tty_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) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500350 ret = __tty_ldisc_lock(tty, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400351 if (ret) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500352 ret = __tty_ldisc_lock_nested(tty2, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400353 if (!ret)
Peter Hurleye80a10e2014-11-05 12:13:06 -0500354 __tty_ldisc_unlock(tty);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400355 }
356 } else {
357 /* if this is possible, it has lots of implications */
358 WARN_ON_ONCE(tty == tty2);
359 if (tty2 && tty != tty2) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500360 ret = __tty_ldisc_lock(tty2, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400361 if (ret) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500362 ret = __tty_ldisc_lock_nested(tty, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400363 if (!ret)
Peter Hurleye80a10e2014-11-05 12:13:06 -0500364 __tty_ldisc_unlock(tty2);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400365 }
366 } else
Peter Hurleye80a10e2014-11-05 12:13:06 -0500367 ret = __tty_ldisc_lock(tty, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400368 }
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
379static void __lockfunc
380tty_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
385static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
386 struct tty_struct *tty2)
387{
Peter Hurleye80a10e2014-11-05 12:13:06 -0500388 __tty_ldisc_unlock(tty);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400389 if (tty2)
Peter Hurleye80a10e2014-11-05 12:13:06 -0500390 __tty_ldisc_unlock(tty2);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400391}
392
Alan Cox01e1abb2008-07-22 11:16:55 +0100393/**
Alan Coxf2c4c652009-06-11 12:50:58 +0100394 * tty_ldisc_flush - flush line discipline queue
395 * @tty: tty
396 *
Peter Hurley86c80a82014-11-05 12:13:09 -0500397 * Flush the line discipline queue (if any) and the tty flip buffers
398 * for this tty.
Alan Coxf2c4c652009-06-11 12:50:58 +0100399 */
400
401void tty_ldisc_flush(struct tty_struct *tty)
402{
403 struct tty_ldisc *ld = tty_ldisc_ref(tty);
Peter Hurley86c80a82014-11-05 12:13:09 -0500404
405 tty_buffer_flush(tty, ld);
406 if (ld)
Alan Coxf2c4c652009-06-11 12:50:58 +0100407 tty_ldisc_deref(ld);
Alan Coxf2c4c652009-06-11 12:50:58 +0100408}
Alan Coxf2c4c652009-06-11 12:50:58 +0100409EXPORT_SYMBOL_GPL(tty_ldisc_flush);
410
411/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100412 * 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 *
Peter Hurley6a1c0682013-06-15 09:14:23 -0400420 * Locking: takes termios_rwsem
Alan Cox01e1abb2008-07-22 11:16:55 +0100421 */
422
423static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
424{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400425 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100426 tty->termios.c_line = num;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400427 up_write(&tty->termios_rwsem);
Alan Cox01e1abb2008-07-22 11:16:55 +0100428}
429
Alan Coxc65c9bc2009-06-11 12:50:12 +0100430/**
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.
Arnd Bergmannec79d602010-06-01 22:53:01 +0200437 *
438 * Locking: always called with BTM already held.
Alan Coxc65c9bc2009-06-11 12:50:12 +0100439 */
440
441static 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));
Alan Coxf18f9492009-11-30 13:18:35 +0000444 if (ld->ops->open) {
445 int ret;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200446 /* BTM here locks versus a hangup event */
Alan Coxf18f9492009-11-30 13:18:35 +0000447 ret = ld->ops->open(tty);
Jiri Slaby7f90cfc2010-11-25 00:27:54 +0100448 if (ret)
449 clear_bit(TTY_LDISC_OPEN, &tty->flags);
Peter Hurleyfb6edc92015-07-12 22:49:12 -0400450
451 tty_ldisc_debug(tty, "%p: opened\n", tty->ldisc);
Alan Coxf18f9492009-11-30 13:18:35 +0000452 return ret;
453 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100454 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
466static 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);
Peter Hurleyfb6edc92015-07-12 22:49:12 -0400472 tty_ldisc_debug(tty, "%p: closed\n", tty->ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100473}
Alan Cox01e1abb2008-07-22 11:16:55 +0100474
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
484static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
485{
Alan Coxc65c9bc2009-06-11 12:50:12 +0100486 struct tty_ldisc *new_ldisc;
487 int r;
Alan Cox01e1abb2008-07-22 11:16:55 +0100488
489 /* There is an outstanding reference here so this is safe */
Peter Hurley36697522013-06-15 07:04:48 -0400490 old = tty_ldisc_get(tty, old->ops->num);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100491 WARN_ON(IS_ERR(old));
Peter Hurleyf48070452013-03-11 16:44:42 -0400492 tty->ldisc = old;
Alan Cox01e1abb2008-07-22 11:16:55 +0100493 tty_set_termios_ldisc(tty, old->ops->num);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100494 if (tty_ldisc_open(tty, old) < 0) {
495 tty_ldisc_put(old);
Alan Cox01e1abb2008-07-22 11:16:55 +0100496 /* This driver is always present */
Peter Hurley36697522013-06-15 07:04:48 -0400497 new_ldisc = tty_ldisc_get(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100498 if (IS_ERR(new_ldisc))
Alan Cox01e1abb2008-07-22 11:16:55 +0100499 panic("n_tty: get");
Peter Hurleyf48070452013-03-11 16:44:42 -0400500 tty->ldisc = new_ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100501 tty_set_termios_ldisc(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100502 r = tty_ldisc_open(tty, new_ldisc);
503 if (r < 0)
504 panic("Couldn't open N_TTY ldisc for "
505 "%s --- error %d.",
Rasmus Villemoes429b4742015-03-31 15:55:59 +0200506 tty_name(tty), r);
Alan Cox01e1abb2008-07-22 11:16:55 +0100507 }
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
Alan Coxc65c9bc2009-06-11 12:50:12 +0100516 * 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.
Alan Cox01e1abb2008-07-22 11:16:55 +0100519 */
520
521int tty_set_ldisc(struct tty_struct *tty, int ldisc)
522{
523 int retval;
Peter Hurley9fbfa342013-06-15 07:04:49 -0400524 struct tty_ldisc *old_ldisc, *new_ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100525
Peter Hurley36697522013-06-15 07:04:48 -0400526 new_ldisc = tty_ldisc_get(tty, ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100527 if (IS_ERR(new_ldisc))
528 return PTR_ERR(new_ldisc);
529
Peter Hurleyc8483bc2014-11-05 12:12:45 -0500530 tty_lock(tty);
Peter Hurley276a6612014-11-05 12:13:08 -0500531 retval = tty_ldisc_lock(tty, 5 * HZ);
Peter Hurley36697522013-06-15 07:04:48 -0400532 if (retval) {
533 tty_ldisc_put(new_ldisc);
Peter Hurleyc8483bc2014-11-05 12:12:45 -0500534 tty_unlock(tty);
Peter Hurley36697522013-06-15 07:04:48 -0400535 return retval;
536 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100537
538 /*
539 * Check the no-op case
540 */
541
542 if (tty->ldisc->ops->num == ldisc) {
Peter Hurley276a6612014-11-05 12:13:08 -0500543 tty_ldisc_unlock(tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100544 tty_ldisc_put(new_ldisc);
Peter Hurleyc8483bc2014-11-05 12:12:45 -0500545 tty_unlock(tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100546 return 0;
547 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100548
Peter Hurley9fbfa342013-06-15 07:04:49 -0400549 old_ldisc = tty->ldisc;
Jiri Slaby100eeae2010-10-31 23:17:51 +0100550
Peter Hurley3ff51a12014-11-05 12:12:46 -0500551 if (test_bit(TTY_HUPPED, &tty->flags)) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100552 /* We were raced by the hangup method. It will have stomped
553 the ldisc data and closed the ldisc down */
Peter Hurley276a6612014-11-05 12:13:08 -0500554 tty_ldisc_unlock(tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100555 tty_ldisc_put(new_ldisc);
Alan Cox89c8d912012-08-08 16:30:13 +0100556 tty_unlock(tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100557 return -EIO;
558 }
559
Peter Hurley9fbfa342013-06-15 07:04:49 -0400560 /* Shutdown the old discipline. */
561 tty_ldisc_close(tty, old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100562
563 /* Now set up the new line discipline. */
Peter Hurleyf48070452013-03-11 16:44:42 -0400564 tty->ldisc = new_ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100565 tty_set_termios_ldisc(tty, ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100566
567 retval = tty_ldisc_open(tty, new_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100568 if (retval < 0) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100569 /* Back to the old one or N_TTY if we can't */
570 tty_ldisc_put(new_ldisc);
Peter Hurley9fbfa342013-06-15 07:04:49 -0400571 tty_ldisc_restore(tty, old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100572 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100573
Peter Hurley9191aaa2014-11-05 13:11:41 -0500574 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
575 down_read(&tty->termios_rwsem);
Alan Cox01e1abb2008-07-22 11:16:55 +0100576 tty->ops->set_ldisc(tty);
Peter Hurley9191aaa2014-11-05 13:11:41 -0500577 up_read(&tty->termios_rwsem);
578 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100579
Peter Hurleyb0e95852013-06-15 07:04:51 -0400580 /* 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
Peter Hurley9fbfa342013-06-15 07:04:49 -0400586 tty_ldisc_put(old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100587
588 /*
Alan Coxc65c9bc2009-06-11 12:50:12 +0100589 * Allow ldisc referencing to occur again
Alan Cox01e1abb2008-07-22 11:16:55 +0100590 */
Peter Hurley276a6612014-11-05 12:13:08 -0500591 tty_ldisc_unlock(tty);
Alan Cox01e1abb2008-07-22 11:16:55 +0100592
Alan Coxc65c9bc2009-06-11 12:50:12 +0100593 /* Restart the work queue in case no characters kick it off. Safe if
Alan Cox01e1abb2008-07-22 11:16:55 +0100594 already running */
Peter Hurley4f98d462013-03-11 16:44:34 -0400595 schedule_work(&tty->port->buf.work);
Peter Hurley4f98d462013-03-11 16:44:34 -0400596
Alan Cox89c8d912012-08-08 16:30:13 +0100597 tty_unlock(tty);
Alan Cox01e1abb2008-07-22 11:16:55 +0100598 return retval;
599}
600
Alan Coxc65c9bc2009-06-11 12:50:12 +0100601/**
602 * tty_reset_termios - reset terminal state
603 * @tty: tty to reset
604 *
605 * Restore a terminal to the driver default state.
606 */
607
608static void tty_reset_termios(struct tty_struct *tty)
609{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400610 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100611 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);
Peter Hurley6a1c0682013-06-15 09:14:23 -0400614 up_write(&tty->termios_rwsem);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100615}
616
617
618/**
619 * tty_ldisc_reinit - reinitialise the tty ldisc
620 * @tty: tty to reinit
Alan Cox638b9642010-02-08 10:09:26 +0000621 * @ldisc: line discipline to reinitialize
Alan Coxc65c9bc2009-06-11 12:50:12 +0100622 *
Alan Cox638b9642010-02-08 10:09:26 +0000623 * Switch the tty to a line discipline and leave the ldisc
624 * state closed
Alan Coxc65c9bc2009-06-11 12:50:12 +0100625 */
626
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200627static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
Alan Coxc65c9bc2009-06-11 12:50:12 +0100628{
Peter Hurley36697522013-06-15 07:04:48 -0400629 struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200630
631 if (IS_ERR(ld))
632 return -1;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100633
634 tty_ldisc_close(tty, tty->ldisc);
635 tty_ldisc_put(tty->ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100636 /*
637 * Switch the line discipline back
638 */
Peter Hurleyf48070452013-03-11 16:44:42 -0400639 tty->ldisc = ld;
Alan Cox638b9642010-02-08 10:09:26 +0000640 tty_set_termios_ldisc(tty, ldisc);
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200641
642 return 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100643}
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
660void tty_ldisc_hangup(struct tty_struct *tty)
661{
662 struct tty_ldisc *ld;
Alan Cox638b9642010-02-08 10:09:26 +0000663 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
664 int err = 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100665
Peter Hurleyfb6edc92015-07-12 22:49:12 -0400666 tty_ldisc_debug(tty, "%p: closing\n", tty->ldisc);
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400667
Alan Coxc65c9bc2009-06-11 12:50:12 +0100668 ld = tty_ldisc_ref(tty);
669 if (ld != NULL) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100670 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 }
Peter Hurley36697522013-06-15 07:04:48 -0400680
Alan Coxc65c9bc2009-06-11 12:50:12 +0100681 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
682 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Peter Hurley36697522013-06-15 07:04:48 -0400683
Alan Coxc65c9bc2009-06-11 12:50:12 +0100684 /*
685 * Shutdown the current line discipline, and reset it to
Alan Cox638b9642010-02-08 10:09:26 +0000686 * N_TTY if need be.
687 *
688 * Avoid racing set_ldisc or tty_ldisc_release
Alan Coxc65c9bc2009-06-11 12:50:12 +0100689 */
Peter Hurleyfae76e92014-11-05 12:13:07 -0500690 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
Arnd Bergmann60af22d2010-06-01 22:53:06 +0200691
Peter Hurley36697522013-06-15 07:04:48 -0400692 if (tty->ldisc) {
Peter Hurleyc8785242013-03-11 16:44:36 -0400693
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 */
Alan Cox638b9642010-02-08 10:09:26 +0000698 if (reset == 0) {
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200699
Alan Coxadc8d742012-07-14 15:31:47 +0100700 if (!tty_ldisc_reinit(tty, tty->termios.c_line))
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200701 err = tty_ldisc_open(tty, tty->ldisc);
702 else
703 err = 1;
Alan Coxc8d50042009-07-16 16:05:08 +0100704 }
Alan Cox638b9642010-02-08 10:09:26 +0000705 /* If the re-open fails or we reset then go to N_TTY. The
706 N_TTY open cannot fail */
707 if (reset || err) {
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200708 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
Alan Cox638b9642010-02-08 10:09:26 +0000709 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
710 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100711 }
Peter Hurleyfae76e92014-11-05 12:13:07 -0500712 tty_ldisc_unlock(tty);
Alan Cox638b9642010-02-08 10:09:26 +0000713 if (reset)
714 tty_reset_termios(tty);
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400715
Peter Hurleyfb6edc92015-07-12 22:49:12 -0400716 tty_ldisc_debug(tty, "%p: re-opened\n", tty->ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100717}
Alan Cox01e1abb2008-07-22 11:16:55 +0100718
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
Alan Coxc65c9bc2009-06-11 12:50:12 +0100725 * line disciplines and bind them to the tty. This has no locking issues
726 * as the device isn't yet active.
Alan Cox01e1abb2008-07-22 11:16:55 +0100727 */
728
729int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
730{
Alan Coxc65c9bc2009-06-11 12:50:12 +0100731 struct tty_ldisc *ld = tty->ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100732 int retval;
733
Alan Coxc65c9bc2009-06-11 12:50:12 +0100734 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);
Alan Cox01e1abb2008-07-22 11:16:55 +0100740 if (retval) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100741 tty_ldisc_close(tty, ld);
Alan Cox01e1abb2008-07-22 11:16:55 +0100742 return retval;
743 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100744 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100745 return 0;
746}
Alan Cox89c8d912012-08-08 16:30:13 +0100747
748static void tty_ldisc_kill(struct tty_struct *tty)
749{
Alan Cox89c8d912012-08-08 16:30:13 +0100750 /*
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);
Alan Cox89c8d912012-08-08 16:30:13 +0100760}
761
Alan Cox01e1abb2008-07-22 11:16:55 +0100762/**
763 * tty_ldisc_release - release line discipline
Peter Hurley62462ae2014-11-05 12:12:58 -0500764 * @tty: tty being shut down (or one end of pty pair)
Alan Cox01e1abb2008-07-22 11:16:55 +0100765 *
Peter Hurley62462ae2014-11-05 12:12:58 -0500766 * 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.
Alan Cox01e1abb2008-07-22 11:16:55 +0100769 */
770
Peter Hurley62462ae2014-11-05 12:12:58 -0500771void tty_ldisc_release(struct tty_struct *tty)
Alan Cox01e1abb2008-07-22 11:16:55 +0100772{
Peter Hurley62462ae2014-11-05 12:12:58 -0500773 struct tty_struct *o_tty = tty->link;
774
Alan Cox01e1abb2008-07-22 11:16:55 +0100775 /*
Peter Hurleya2965b72013-03-11 16:44:35 -0400776 * Shutdown this line discipline. As this is the final close,
777 * it does not race with the set_ldisc code path.
Alan Cox01e1abb2008-07-22 11:16:55 +0100778 */
Alan Cox01e1abb2008-07-22 11:16:55 +0100779
Peter Hurley36697522013-06-15 07:04:48 -0400780 tty_ldisc_lock_pair(tty, o_tty);
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);
Peter Hurley36697522013-06-15 07:04:48 -0400784 tty_ldisc_unlock_pair(tty, o_tty);
785
Alan Coxaef29bc2009-06-29 15:21:47 +0100786 /* And the memory resources remaining (buffers, termios) will be
787 disposed of when the kref hits zero */
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400788
Peter Hurleyfb6edc92015-07-12 22:49:12 -0400789 tty_ldisc_debug(tty, "released\n");
Alan Cox01e1abb2008-07-22 11:16:55 +0100790}
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
800void tty_ldisc_init(struct tty_struct *tty)
801{
Peter Hurley36697522013-06-15 07:04:48 -0400802 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100803 if (IS_ERR(ld))
Alan Cox01e1abb2008-07-22 11:16:55 +0100804 panic("n_tty: init_tty");
Peter Hurleyf48070452013-03-11 16:44:42 -0400805 tty->ldisc = ld;
Alan Cox01e1abb2008-07-22 11:16:55 +0100806}
807
Jiri Slaby67166712011-03-23 10:48:35 +0100808/**
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 */
815void tty_ldisc_deinit(struct tty_struct *tty)
816{
Peter Hurleyebc9bae2013-03-11 16:44:40 -0400817 tty_ldisc_put(tty->ldisc);
Peter Hurleyf48070452013-03-11 16:44:42 -0400818 tty->ldisc = NULL;
Jiri Slaby67166712011-03-23 10:48:35 +0100819}
820
Alan Cox01e1abb2008-07-22 11:16:55 +0100821void tty_ldisc_begin(void)
822{
823 /* Setup the default TTY line discipline. */
824 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
825}