blob: 68947f6de5ad6339adea804182597229c3eb1d38 [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
Peter Hurleyc0cc1c52016-01-10 22:40:59 -0800143 * module locking counts.
144 *
145 * Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or
146 * if the discipline is not registered
147 * -EAGAIN if request_module() failed to load or register the
148 * the discipline
149 * -ENOMEM if allocation failure
150 *
151 * Otherwise, returns a pointer to the discipline and bumps the
152 * ref count
Alan Cox01e1abb2008-07-22 11:16:55 +0100153 *
154 * Locking:
Peter Hurley137084b2013-06-15 07:04:46 -0400155 * takes tty_ldiscs_lock to guard against ldisc races
Alan Cox01e1abb2008-07-22 11:16:55 +0100156 */
157
Peter Hurley36697522013-06-15 07:04:48 -0400158static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
Alan Cox01e1abb2008-07-22 11:16:55 +0100159{
Alan Coxc65c9bc2009-06-11 12:50:12 +0100160 struct tty_ldisc *ld;
Linus Torvalds182274f2009-08-03 16:01:28 -0700161 struct tty_ldisc_ops *ldops;
Alan Cox01e1abb2008-07-22 11:16:55 +0100162
163 if (disc < N_TTY || disc >= NR_LDISCS)
Alan Coxc65c9bc2009-06-11 12:50:12 +0100164 return ERR_PTR(-EINVAL);
Linus Torvalds182274f2009-08-03 16:01:28 -0700165
166 /*
167 * Get the ldisc ops - we may need to request them to be loaded
168 * dynamically and try again.
169 */
170 ldops = get_ldops(disc);
171 if (IS_ERR(ldops)) {
Alan Cox01e1abb2008-07-22 11:16:55 +0100172 request_module("tty-ldisc-%d", disc);
Linus Torvalds182274f2009-08-03 16:01:28 -0700173 ldops = get_ldops(disc);
174 if (IS_ERR(ldops))
175 return ERR_CAST(ldops);
Alan Cox01e1abb2008-07-22 11:16:55 +0100176 }
Linus Torvalds182274f2009-08-03 16:01:28 -0700177
178 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
179 if (ld == NULL) {
180 put_ldops(ldops);
181 return ERR_PTR(-ENOMEM);
182 }
183
184 ld->ops = ldops;
Peter Hurley36697522013-06-15 07:04:48 -0400185 ld->tty = tty;
Ivo Sieben1541f842012-05-03 14:37:43 +0200186
Alan Coxc65c9bc2009-06-11 12:50:12 +0100187 return ld;
Alan Cox01e1abb2008-07-22 11:16:55 +0100188}
189
Peter Hurley734de242013-03-11 16:44:43 -0400190/**
191 * tty_ldisc_put - release the ldisc
192 *
193 * Complement of tty_ldisc_get().
194 */
Denys Vlasenkocb128f62015-10-27 17:40:02 +0100195static void tty_ldisc_put(struct tty_ldisc *ld)
Peter Hurley734de242013-03-11 16:44:43 -0400196{
Peter Hurley734de242013-03-11 16:44:43 -0400197 if (WARN_ON_ONCE(!ld))
198 return;
199
Peter Hurley36697522013-06-15 07:04:48 -0400200 put_ldops(ld->ops);
Peter Hurley734de242013-03-11 16:44:43 -0400201 kfree(ld);
Peter Hurley734de242013-03-11 16:44:43 -0400202}
203
Alan Cox852e99d2009-06-11 12:51:41 +0100204static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
Alan Cox01e1abb2008-07-22 11:16:55 +0100205{
206 return (*pos < NR_LDISCS) ? pos : NULL;
207}
208
Alan Cox852e99d2009-06-11 12:51:41 +0100209static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
Alan Cox01e1abb2008-07-22 11:16:55 +0100210{
211 (*pos)++;
212 return (*pos < NR_LDISCS) ? pos : NULL;
213}
214
215static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
216{
217}
218
219static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
220{
221 int i = *(loff_t *)v;
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700222 struct tty_ldisc_ops *ldops;
Alan Cox852e99d2009-06-11 12:51:41 +0100223
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700224 ldops = get_ldops(i);
225 if (IS_ERR(ldops))
Alan Cox01e1abb2008-07-22 11:16:55 +0100226 return 0;
Linus Torvaldsf0de0e82009-08-03 16:00:15 -0700227 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
228 put_ldops(ldops);
Alan Cox01e1abb2008-07-22 11:16:55 +0100229 return 0;
230}
231
232static const struct seq_operations tty_ldiscs_seq_ops = {
233 .start = tty_ldiscs_seq_start,
234 .next = tty_ldiscs_seq_next,
235 .stop = tty_ldiscs_seq_stop,
236 .show = tty_ldiscs_seq_show,
237};
238
239static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
240{
241 return seq_open(file, &tty_ldiscs_seq_ops);
242}
243
244const struct file_operations tty_ldiscs_proc_fops = {
245 .owner = THIS_MODULE,
246 .open = proc_tty_ldiscs_open,
247 .read = seq_read,
248 .llseek = seq_lseek,
249 .release = seq_release,
250};
251
252/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100253 * tty_ldisc_ref_wait - wait for the tty ldisc
254 * @tty: tty device
255 *
256 * Dereference the line discipline for the terminal and take a
257 * reference to it. If the line discipline is in flux then
258 * wait patiently until it changes.
259 *
Peter Hurley892d1fa2016-01-10 22:41:06 -0800260 * Returns: NULL if the tty has been hungup and not re-opened with
261 * a new file descriptor, otherwise valid ldisc reference
262 *
Alan Cox01e1abb2008-07-22 11:16:55 +0100263 * Note: Must not be called from an IRQ/timer context. The caller
264 * must also be careful not to hold other locks that will deadlock
265 * against a discipline change, such as an existing ldisc reference
266 * (which we check for)
267 *
Peter Hurleye55afd12016-01-10 22:41:01 -0800268 * Note: a file_operations routine (read/poll/write) should use this
269 * function to wait for any ldisc lifetime events to finish.
Alan Cox01e1abb2008-07-22 11:16:55 +0100270 */
271
272struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
273{
Peter Hurley36697522013-06-15 07:04:48 -0400274 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
Peter Hurleya570a492016-01-10 22:41:02 -0800275 if (!tty->ldisc)
276 ldsem_up_read(&tty->ldisc_sem);
Peter Hurley36697522013-06-15 07:04:48 -0400277 return tty->ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100278}
Alan Cox01e1abb2008-07-22 11:16:55 +0100279EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
280
281/**
282 * tty_ldisc_ref - get the tty ldisc
283 * @tty: tty device
284 *
285 * Dereference the line discipline for the terminal and take a
286 * reference to it. If the line discipline is in flux then
287 * return NULL. Can be called from IRQ and timer functions.
Alan Cox01e1abb2008-07-22 11:16:55 +0100288 */
289
290struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
291{
Peter Hurley36697522013-06-15 07:04:48 -0400292 struct tty_ldisc *ld = NULL;
293
294 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
295 ld = tty->ldisc;
296 if (!ld)
297 ldsem_up_read(&tty->ldisc_sem);
298 }
299 return ld;
Alan Cox01e1abb2008-07-22 11:16:55 +0100300}
Alan Cox01e1abb2008-07-22 11:16:55 +0100301EXPORT_SYMBOL_GPL(tty_ldisc_ref);
302
303/**
304 * tty_ldisc_deref - free a tty ldisc reference
305 * @ld: reference to free up
306 *
307 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
308 * be called in IRQ context.
Alan Cox01e1abb2008-07-22 11:16:55 +0100309 */
310
311void tty_ldisc_deref(struct tty_ldisc *ld)
312{
Peter Hurley36697522013-06-15 07:04:48 -0400313 ldsem_up_read(&ld->tty->ldisc_sem);
Alan Cox01e1abb2008-07-22 11:16:55 +0100314}
Alan Cox01e1abb2008-07-22 11:16:55 +0100315EXPORT_SYMBOL_GPL(tty_ldisc_deref);
316
Peter Hurleyd2c43892013-06-15 07:04:47 -0400317
Peter Hurleyc2bb5242016-01-09 21:13:51 -0800318static inline int
Peter Hurleye80a10e2014-11-05 12:13:06 -0500319__tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400320{
321 return ldsem_down_write(&tty->ldisc_sem, timeout);
322}
323
Peter Hurleyc2bb5242016-01-09 21:13:51 -0800324static inline int
Peter Hurleye80a10e2014-11-05 12:13:06 -0500325__tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400326{
327 return ldsem_down_write_nested(&tty->ldisc_sem,
328 LDISC_SEM_OTHER, timeout);
329}
330
Peter Hurleye80a10e2014-11-05 12:13:06 -0500331static inline void __tty_ldisc_unlock(struct tty_struct *tty)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400332{
Guillaume Gomez52772ea2015-10-04 21:19:18 +0200333 ldsem_up_write(&tty->ldisc_sem);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400334}
335
Peter Hurleyc2bb5242016-01-09 21:13:51 -0800336static int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
Peter Hurleyfae76e92014-11-05 12:13:07 -0500337{
338 int ret;
339
340 ret = __tty_ldisc_lock(tty, timeout);
341 if (!ret)
342 return -EBUSY;
343 set_bit(TTY_LDISC_HALTED, &tty->flags);
344 return 0;
345}
346
347static void tty_ldisc_unlock(struct tty_struct *tty)
348{
349 clear_bit(TTY_LDISC_HALTED, &tty->flags);
350 __tty_ldisc_unlock(tty);
351}
352
Peter Hurleyc2bb5242016-01-09 21:13:51 -0800353static int
Peter Hurleyd2c43892013-06-15 07:04:47 -0400354tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
355 unsigned long timeout)
356{
357 int ret;
358
359 if (tty < tty2) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500360 ret = __tty_ldisc_lock(tty, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400361 if (ret) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500362 ret = __tty_ldisc_lock_nested(tty2, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400363 if (!ret)
Peter Hurleye80a10e2014-11-05 12:13:06 -0500364 __tty_ldisc_unlock(tty);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400365 }
366 } else {
367 /* if this is possible, it has lots of implications */
368 WARN_ON_ONCE(tty == tty2);
369 if (tty2 && tty != tty2) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500370 ret = __tty_ldisc_lock(tty2, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400371 if (ret) {
Peter Hurleye80a10e2014-11-05 12:13:06 -0500372 ret = __tty_ldisc_lock_nested(tty, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400373 if (!ret)
Peter Hurleye80a10e2014-11-05 12:13:06 -0500374 __tty_ldisc_unlock(tty2);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400375 }
376 } else
Peter Hurleye80a10e2014-11-05 12:13:06 -0500377 ret = __tty_ldisc_lock(tty, timeout);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400378 }
379
380 if (!ret)
381 return -EBUSY;
382
383 set_bit(TTY_LDISC_HALTED, &tty->flags);
384 if (tty2)
385 set_bit(TTY_LDISC_HALTED, &tty2->flags);
386 return 0;
387}
388
Peter Hurleyc2bb5242016-01-09 21:13:51 -0800389static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400390{
391 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
392}
393
Peter Hurleyc2bb5242016-01-09 21:13:51 -0800394static void tty_ldisc_unlock_pair(struct tty_struct *tty,
395 struct tty_struct *tty2)
Peter Hurleyd2c43892013-06-15 07:04:47 -0400396{
Peter Hurleye80a10e2014-11-05 12:13:06 -0500397 __tty_ldisc_unlock(tty);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400398 if (tty2)
Peter Hurleye80a10e2014-11-05 12:13:06 -0500399 __tty_ldisc_unlock(tty2);
Peter Hurleyd2c43892013-06-15 07:04:47 -0400400}
401
Alan Cox01e1abb2008-07-22 11:16:55 +0100402/**
Alan Coxf2c4c652009-06-11 12:50:58 +0100403 * tty_ldisc_flush - flush line discipline queue
404 * @tty: tty
405 *
Peter Hurley86c80a82014-11-05 12:13:09 -0500406 * Flush the line discipline queue (if any) and the tty flip buffers
407 * for this tty.
Alan Coxf2c4c652009-06-11 12:50:58 +0100408 */
409
410void tty_ldisc_flush(struct tty_struct *tty)
411{
412 struct tty_ldisc *ld = tty_ldisc_ref(tty);
Peter Hurley86c80a82014-11-05 12:13:09 -0500413
414 tty_buffer_flush(tty, ld);
415 if (ld)
Alan Coxf2c4c652009-06-11 12:50:58 +0100416 tty_ldisc_deref(ld);
Alan Coxf2c4c652009-06-11 12:50:58 +0100417}
Alan Coxf2c4c652009-06-11 12:50:58 +0100418EXPORT_SYMBOL_GPL(tty_ldisc_flush);
419
420/**
Alan Cox01e1abb2008-07-22 11:16:55 +0100421 * tty_set_termios_ldisc - set ldisc field
422 * @tty: tty structure
Peter Hurleyc12da962016-01-10 22:41:04 -0800423 * @disc: line discipline number
Alan Cox01e1abb2008-07-22 11:16:55 +0100424 *
425 * This is probably overkill for real world processors but
426 * they are not on hot paths so a little discipline won't do
427 * any harm.
428 *
Peter Hurleydd42bf12015-11-27 14:30:21 -0500429 * The line discipline-related tty_struct fields are reset to
430 * prevent the ldisc driver from re-using stale information for
431 * the new ldisc instance.
432 *
Peter Hurley6a1c0682013-06-15 09:14:23 -0400433 * Locking: takes termios_rwsem
Alan Cox01e1abb2008-07-22 11:16:55 +0100434 */
435
Peter Hurleyc12da962016-01-10 22:41:04 -0800436static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
Alan Cox01e1abb2008-07-22 11:16:55 +0100437{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400438 down_write(&tty->termios_rwsem);
Peter Hurleyc12da962016-01-10 22:41:04 -0800439 tty->termios.c_line = disc;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400440 up_write(&tty->termios_rwsem);
Peter Hurleydd42bf12015-11-27 14:30:21 -0500441
442 tty->disc_data = NULL;
443 tty->receive_room = 0;
Alan Cox01e1abb2008-07-22 11:16:55 +0100444}
445
Alan Coxc65c9bc2009-06-11 12:50:12 +0100446/**
447 * tty_ldisc_open - open a line discipline
448 * @tty: tty we are opening the ldisc on
449 * @ld: discipline to open
450 *
451 * A helper opening method. Also a convenient debugging and check
452 * point.
Arnd Bergmannec79d602010-06-01 22:53:01 +0200453 *
454 * Locking: always called with BTM already held.
Alan Coxc65c9bc2009-06-11 12:50:12 +0100455 */
456
457static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
458{
459 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
Alan Coxf18f9492009-11-30 13:18:35 +0000460 if (ld->ops->open) {
461 int ret;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200462 /* BTM here locks versus a hangup event */
Alan Coxf18f9492009-11-30 13:18:35 +0000463 ret = ld->ops->open(tty);
Jiri Slaby7f90cfc2010-11-25 00:27:54 +0100464 if (ret)
465 clear_bit(TTY_LDISC_OPEN, &tty->flags);
Peter Hurleyfb6edc92015-07-12 22:49:12 -0400466
Peter Hurleya570a492016-01-10 22:41:02 -0800467 tty_ldisc_debug(tty, "%p: opened\n", ld);
Alan Coxf18f9492009-11-30 13:18:35 +0000468 return ret;
469 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100470 return 0;
471}
472
473/**
474 * tty_ldisc_close - close a line discipline
475 * @tty: tty we are opening the ldisc on
476 * @ld: discipline to close
477 *
478 * A helper close method. Also a convenient debugging and check
479 * point.
480 */
481
482static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
483{
484 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
485 clear_bit(TTY_LDISC_OPEN, &tty->flags);
486 if (ld->ops->close)
487 ld->ops->close(tty);
Peter Hurleya570a492016-01-10 22:41:02 -0800488 tty_ldisc_debug(tty, "%p: closed\n", ld);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100489}
Alan Cox01e1abb2008-07-22 11:16:55 +0100490
491/**
492 * tty_ldisc_restore - helper for tty ldisc change
493 * @tty: tty to recover
494 * @old: previous ldisc
495 *
496 * Restore the previous line discipline or N_TTY when a line discipline
497 * change fails due to an open error
498 */
499
500static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
501{
Alan Coxc65c9bc2009-06-11 12:50:12 +0100502 struct tty_ldisc *new_ldisc;
503 int r;
Alan Cox01e1abb2008-07-22 11:16:55 +0100504
505 /* There is an outstanding reference here so this is safe */
Peter Hurley36697522013-06-15 07:04:48 -0400506 old = tty_ldisc_get(tty, old->ops->num);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100507 WARN_ON(IS_ERR(old));
Peter Hurleyf48070452013-03-11 16:44:42 -0400508 tty->ldisc = old;
Alan Cox01e1abb2008-07-22 11:16:55 +0100509 tty_set_termios_ldisc(tty, old->ops->num);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100510 if (tty_ldisc_open(tty, old) < 0) {
511 tty_ldisc_put(old);
Alan Cox01e1abb2008-07-22 11:16:55 +0100512 /* This driver is always present */
Peter Hurley36697522013-06-15 07:04:48 -0400513 new_ldisc = tty_ldisc_get(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100514 if (IS_ERR(new_ldisc))
Alan Cox01e1abb2008-07-22 11:16:55 +0100515 panic("n_tty: get");
Peter Hurleyf48070452013-03-11 16:44:42 -0400516 tty->ldisc = new_ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100517 tty_set_termios_ldisc(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100518 r = tty_ldisc_open(tty, new_ldisc);
519 if (r < 0)
520 panic("Couldn't open N_TTY ldisc for "
521 "%s --- error %d.",
Rasmus Villemoes429b4742015-03-31 15:55:59 +0200522 tty_name(tty), r);
Alan Cox01e1abb2008-07-22 11:16:55 +0100523 }
524}
525
526/**
527 * tty_set_ldisc - set line discipline
528 * @tty: the terminal to set
529 * @ldisc: the line discipline
530 *
531 * Set the discipline of a tty line. Must be called from a process
Alan Coxc65c9bc2009-06-11 12:50:12 +0100532 * context. The ldisc change logic has to protect itself against any
533 * overlapping ldisc change (including on the other end of pty pairs),
534 * the close of one side of a tty/pty pair, and eventually hangup.
Alan Cox01e1abb2008-07-22 11:16:55 +0100535 */
536
Peter Hurleyc12da962016-01-10 22:41:04 -0800537int tty_set_ldisc(struct tty_struct *tty, int disc)
Alan Cox01e1abb2008-07-22 11:16:55 +0100538{
539 int retval;
Peter Hurley9fbfa342013-06-15 07:04:49 -0400540 struct tty_ldisc *old_ldisc, *new_ldisc;
Alan Cox01e1abb2008-07-22 11:16:55 +0100541
Peter Hurleyc12da962016-01-10 22:41:04 -0800542 new_ldisc = tty_ldisc_get(tty, disc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100543 if (IS_ERR(new_ldisc))
544 return PTR_ERR(new_ldisc);
545
Peter Hurleyc8483bc2014-11-05 12:12:45 -0500546 tty_lock(tty);
Peter Hurley276a6612014-11-05 12:13:08 -0500547 retval = tty_ldisc_lock(tty, 5 * HZ);
Peter Hurley63d8cb32015-11-08 09:29:38 -0500548 if (retval)
549 goto err;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100550
Peter Hurleya570a492016-01-10 22:41:02 -0800551 if (!tty->ldisc) {
552 retval = -EIO;
553 goto out;
554 }
555
Peter Hurley63d8cb32015-11-08 09:29:38 -0500556 /* Check the no-op case */
Peter Hurleyc12da962016-01-10 22:41:04 -0800557 if (tty->ldisc->ops->num == disc)
Peter Hurley63d8cb32015-11-08 09:29:38 -0500558 goto out;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100559
Peter Hurley63d8cb32015-11-08 09:29:38 -0500560 if (test_bit(TTY_HUPPED, &tty->flags)) {
561 /* We were raced by hangup */
562 retval = -EIO;
563 goto out;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100564 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100565
Peter Hurley9fbfa342013-06-15 07:04:49 -0400566 old_ldisc = tty->ldisc;
Jiri Slaby100eeae2010-10-31 23:17:51 +0100567
Peter Hurley9fbfa342013-06-15 07:04:49 -0400568 /* Shutdown the old discipline. */
569 tty_ldisc_close(tty, old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100570
571 /* Now set up the new line discipline. */
Peter Hurleyf48070452013-03-11 16:44:42 -0400572 tty->ldisc = new_ldisc;
Peter Hurleyc12da962016-01-10 22:41:04 -0800573 tty_set_termios_ldisc(tty, disc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100574
575 retval = tty_ldisc_open(tty, new_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100576 if (retval < 0) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100577 /* Back to the old one or N_TTY if we can't */
578 tty_ldisc_put(new_ldisc);
Peter Hurley9fbfa342013-06-15 07:04:49 -0400579 tty_ldisc_restore(tty, old_ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100580 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100581
Peter Hurley9191aaa2014-11-05 13:11:41 -0500582 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
583 down_read(&tty->termios_rwsem);
Alan Cox01e1abb2008-07-22 11:16:55 +0100584 tty->ops->set_ldisc(tty);
Peter Hurley9191aaa2014-11-05 13:11:41 -0500585 up_read(&tty->termios_rwsem);
586 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100587
Peter Hurleyb0e95852013-06-15 07:04:51 -0400588 /* At this point we hold a reference to the new ldisc and a
589 reference to the old ldisc, or we hold two references to
590 the old ldisc (if it was restored as part of error cleanup
591 above). In either case, releasing a single reference from
592 the old ldisc is correct. */
Peter Hurley63d8cb32015-11-08 09:29:38 -0500593 new_ldisc = old_ldisc;
594out:
Peter Hurley276a6612014-11-05 12:13:08 -0500595 tty_ldisc_unlock(tty);
Alan Cox01e1abb2008-07-22 11:16:55 +0100596
Alan Coxc65c9bc2009-06-11 12:50:12 +0100597 /* Restart the work queue in case no characters kick it off. Safe if
Alan Cox01e1abb2008-07-22 11:16:55 +0100598 already running */
Peter Hurley17a69212015-11-08 07:53:06 -0500599 tty_buffer_restart_work(tty->port);
Peter Hurley63d8cb32015-11-08 09:29:38 -0500600err:
601 tty_ldisc_put(new_ldisc); /* drop the extra reference */
Alan Cox89c8d912012-08-08 16:30:13 +0100602 tty_unlock(tty);
Alan Cox01e1abb2008-07-22 11:16:55 +0100603 return retval;
604}
605
Alan Coxc65c9bc2009-06-11 12:50:12 +0100606/**
Peter Hurley6ffeb4b2016-01-10 22:41:03 -0800607 * tty_ldisc_kill - teardown ldisc
608 * @tty: tty being released
609 *
610 * Perform final close of the ldisc and reset tty->ldisc
611 */
612static void tty_ldisc_kill(struct tty_struct *tty)
613{
614 if (!tty->ldisc)
615 return;
616 /*
617 * Now kill off the ldisc
618 */
619 tty_ldisc_close(tty, tty->ldisc);
620 tty_ldisc_put(tty->ldisc);
621 /* Force an oops if we mess this up */
622 tty->ldisc = NULL;
623}
624
625/**
Alan Coxc65c9bc2009-06-11 12:50:12 +0100626 * tty_reset_termios - reset terminal state
627 * @tty: tty to reset
628 *
629 * Restore a terminal to the driver default state.
630 */
631
632static void tty_reset_termios(struct tty_struct *tty)
633{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400634 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100635 tty->termios = tty->driver->init_termios;
636 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
637 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Peter Hurley6a1c0682013-06-15 09:14:23 -0400638 up_write(&tty->termios_rwsem);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100639}
640
641
642/**
643 * tty_ldisc_reinit - reinitialise the tty ldisc
644 * @tty: tty to reinit
Peter Hurleyc12da962016-01-10 22:41:04 -0800645 * @disc: line discipline to reinitialize
Alan Coxc65c9bc2009-06-11 12:50:12 +0100646 *
Peter Hurley7896f302016-01-10 22:41:05 -0800647 * Completely reinitialize the line discipline state, by closing the
Peter Hurley892d1fa2016-01-10 22:41:06 -0800648 * current instance, if there is one, and opening a new instance. If
649 * an error occurs opening the new non-N_TTY instance, the instance
650 * is dropped and tty->ldisc reset to NULL. The caller can then retry
651 * with N_TTY instead.
Peter Hurley7896f302016-01-10 22:41:05 -0800652 *
653 * Returns 0 if successful, otherwise error code < 0
Alan Coxc65c9bc2009-06-11 12:50:12 +0100654 */
655
Peter Hurley892d1fa2016-01-10 22:41:06 -0800656int tty_ldisc_reinit(struct tty_struct *tty, int disc)
Alan Coxc65c9bc2009-06-11 12:50:12 +0100657{
Peter Hurley7896f302016-01-10 22:41:05 -0800658 struct tty_ldisc *ld;
659 int retval;
Philippe Rétornaz1c95ba12010-10-27 17:13:21 +0200660
Peter Hurley7896f302016-01-10 22:41:05 -0800661 ld = tty_ldisc_get(tty, disc);
662 if (IS_ERR(ld)) {
663 BUG_ON(disc == N_TTY);
664 return PTR_ERR(ld);
665 }
Alan Coxc65c9bc2009-06-11 12:50:12 +0100666
Peter Hurley7896f302016-01-10 22:41:05 -0800667 if (tty->ldisc) {
668 tty_ldisc_close(tty, tty->ldisc);
669 tty_ldisc_put(tty->ldisc);
670 }
671
672 /* switch the line discipline */
Peter Hurleyf48070452013-03-11 16:44:42 -0400673 tty->ldisc = ld;
Peter Hurleyc12da962016-01-10 22:41:04 -0800674 tty_set_termios_ldisc(tty, disc);
Peter Hurley7896f302016-01-10 22:41:05 -0800675 retval = tty_ldisc_open(tty, tty->ldisc);
676 if (retval) {
677 if (!WARN_ON(disc == N_TTY)) {
678 tty_ldisc_put(tty->ldisc);
679 tty->ldisc = NULL;
680 }
681 }
682 return retval;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100683}
684
685/**
686 * tty_ldisc_hangup - hangup ldisc reset
687 * @tty: tty being hung up
688 *
689 * Some tty devices reset their termios when they receive a hangup
690 * event. In that situation we must also switch back to N_TTY properly
691 * before we reset the termios data.
692 *
693 * Locking: We can take the ldisc mutex as the rest of the code is
694 * careful to allow for this.
695 *
696 * In the pty pair case this occurs in the close() path of the
697 * tty itself so we must be careful about locking rules.
698 */
699
Peter Hurley892d1fa2016-01-10 22:41:06 -0800700void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
Alan Coxc65c9bc2009-06-11 12:50:12 +0100701{
702 struct tty_ldisc *ld;
703
Peter Hurleya570a492016-01-10 22:41:02 -0800704 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400705
Alan Coxc65c9bc2009-06-11 12:50:12 +0100706 ld = tty_ldisc_ref(tty);
707 if (ld != NULL) {
Alan Coxc65c9bc2009-06-11 12:50:12 +0100708 if (ld->ops->flush_buffer)
709 ld->ops->flush_buffer(tty);
710 tty_driver_flush_buffer(tty);
711 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
712 ld->ops->write_wakeup)
713 ld->ops->write_wakeup(tty);
714 if (ld->ops->hangup)
715 ld->ops->hangup(tty);
716 tty_ldisc_deref(ld);
717 }
Peter Hurley36697522013-06-15 07:04:48 -0400718
Alan Coxc65c9bc2009-06-11 12:50:12 +0100719 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
720 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Peter Hurley36697522013-06-15 07:04:48 -0400721
Alan Coxc65c9bc2009-06-11 12:50:12 +0100722 /*
723 * Shutdown the current line discipline, and reset it to
Alan Cox638b9642010-02-08 10:09:26 +0000724 * N_TTY if need be.
725 *
726 * Avoid racing set_ldisc or tty_ldisc_release
Alan Coxc65c9bc2009-06-11 12:50:12 +0100727 */
Peter Hurleyfae76e92014-11-05 12:13:07 -0500728 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
Arnd Bergmann60af22d2010-06-01 22:53:06 +0200729
Peter Hurley892d1fa2016-01-10 22:41:06 -0800730 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
Alan Cox638b9642010-02-08 10:09:26 +0000731 tty_reset_termios(tty);
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400732
Peter Hurley892d1fa2016-01-10 22:41:06 -0800733 if (tty->ldisc) {
734 if (reinit) {
735 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0)
736 tty_ldisc_reinit(tty, N_TTY);
737 } else
738 tty_ldisc_kill(tty);
739 }
740 tty_ldisc_unlock(tty);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100741}
Alan Cox01e1abb2008-07-22 11:16:55 +0100742
743/**
744 * tty_ldisc_setup - open line discipline
745 * @tty: tty being shut down
746 * @o_tty: pair tty for pty/tty pairs
747 *
748 * Called during the initial open of a tty/pty pair in order to set up the
Alan Coxc65c9bc2009-06-11 12:50:12 +0100749 * line disciplines and bind them to the tty. This has no locking issues
750 * as the device isn't yet active.
Alan Cox01e1abb2008-07-22 11:16:55 +0100751 */
752
753int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
754{
Peter Hurley9de2a7c2016-01-10 22:41:08 -0800755 int retval = tty_ldisc_open(tty, tty->ldisc);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100756 if (retval)
757 return retval;
758
759 if (o_tty) {
760 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100761 if (retval) {
Peter Hurley9de2a7c2016-01-10 22:41:08 -0800762 tty_ldisc_close(tty, tty->ldisc);
Alan Cox01e1abb2008-07-22 11:16:55 +0100763 return retval;
764 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100765 }
Alan Cox01e1abb2008-07-22 11:16:55 +0100766 return 0;
767}
Alan Cox89c8d912012-08-08 16:30:13 +0100768
Alan Cox01e1abb2008-07-22 11:16:55 +0100769/**
770 * tty_ldisc_release - release line discipline
Peter Hurley62462ae2014-11-05 12:12:58 -0500771 * @tty: tty being shut down (or one end of pty pair)
Alan Cox01e1abb2008-07-22 11:16:55 +0100772 *
Peter Hurley62462ae2014-11-05 12:12:58 -0500773 * Called during the final close of a tty or a pty pair in order to shut
Peter Hurley5b6e6832016-01-10 22:41:00 -0800774 * down the line discpline layer. On exit, each tty's ldisc is NULL.
Alan Cox01e1abb2008-07-22 11:16:55 +0100775 */
776
Peter Hurley62462ae2014-11-05 12:12:58 -0500777void tty_ldisc_release(struct tty_struct *tty)
Alan Cox01e1abb2008-07-22 11:16:55 +0100778{
Peter Hurley62462ae2014-11-05 12:12:58 -0500779 struct tty_struct *o_tty = tty->link;
780
Alan Cox01e1abb2008-07-22 11:16:55 +0100781 /*
Peter Hurleya2965b72013-03-11 16:44:35 -0400782 * Shutdown this line discipline. As this is the final close,
783 * it does not race with the set_ldisc code path.
Alan Cox01e1abb2008-07-22 11:16:55 +0100784 */
Alan Cox01e1abb2008-07-22 11:16:55 +0100785
Peter Hurley36697522013-06-15 07:04:48 -0400786 tty_ldisc_lock_pair(tty, o_tty);
Alan Cox89c8d912012-08-08 16:30:13 +0100787 tty_ldisc_kill(tty);
Alan Cox89c8d912012-08-08 16:30:13 +0100788 if (o_tty)
789 tty_ldisc_kill(o_tty);
Peter Hurley36697522013-06-15 07:04:48 -0400790 tty_ldisc_unlock_pair(tty, o_tty);
791
Alan Coxaef29bc2009-06-29 15:21:47 +0100792 /* And the memory resources remaining (buffers, termios) will be
793 disposed of when the kref hits zero */
Peter Hurleyfc575ee2013-03-11 16:44:38 -0400794
Peter Hurleyfb6edc92015-07-12 22:49:12 -0400795 tty_ldisc_debug(tty, "released\n");
Alan Cox01e1abb2008-07-22 11:16:55 +0100796}
797
798/**
799 * tty_ldisc_init - ldisc setup for new tty
800 * @tty: tty being allocated
801 *
802 * Set up the line discipline objects for a newly allocated tty. Note that
803 * the tty structure is not completely set up when this call is made.
804 */
805
806void tty_ldisc_init(struct tty_struct *tty)
807{
Peter Hurley36697522013-06-15 07:04:48 -0400808 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100809 if (IS_ERR(ld))
Alan Cox01e1abb2008-07-22 11:16:55 +0100810 panic("n_tty: init_tty");
Peter Hurleyf48070452013-03-11 16:44:42 -0400811 tty->ldisc = ld;
Alan Cox01e1abb2008-07-22 11:16:55 +0100812}
813
Jiri Slaby67166712011-03-23 10:48:35 +0100814/**
Peter Hurleyc8b710b2016-01-09 21:13:46 -0800815 * tty_ldisc_deinit - ldisc cleanup for new tty
Jiri Slaby67166712011-03-23 10:48:35 +0100816 * @tty: tty that was allocated recently
817 *
818 * The tty structure must not becompletely set up (tty_ldisc_setup) when
819 * this call is made.
820 */
821void tty_ldisc_deinit(struct tty_struct *tty)
822{
Peter Hurleyc8b710b2016-01-09 21:13:46 -0800823 if (tty->ldisc)
824 tty_ldisc_put(tty->ldisc);
Peter Hurleyf48070452013-03-11 16:44:42 -0400825 tty->ldisc = NULL;
Jiri Slaby67166712011-03-23 10:48:35 +0100826}