xref: /linux/drivers/tty/serial/kgdb_nmi.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
1 /*
2  * KGDB NMI serial console
3  *
4  * Copyright 2010 Google, Inc.
5  *		  Arve Hjønnevåg <arve@android.com>
6  *		  Colin Cross <ccross@android.com>
7  * Copyright 2012 Linaro Ltd.
8  *		  Anton Vorontsov <anton.vorontsov@linaro.org>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License version 2 as published
12  * by the Free Software Foundation.
13  */
14 
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/compiler.h>
18 #include <linux/init.h>
19 #include <linux/slab.h>
20 #include <linux/errno.h>
21 #include <linux/atomic.h>
22 #include <linux/console.h>
23 #include <linux/tty.h>
24 #include <linux/tty_driver.h>
25 #include <linux/tty_flip.h>
26 #include <linux/interrupt.h>
27 #include <linux/hrtimer.h>
28 #include <linux/tick.h>
29 #include <linux/kfifo.h>
30 #include <linux/kgdb.h>
31 #include <linux/kdb.h>
32 
33 static int kgdb_nmi_knock = 1;
34 module_param_named(knock, kgdb_nmi_knock, int, 0600);
35 MODULE_PARM_DESC(knock, "if set to 1 (default), the special '$3#33' command " \
36 			"must be used to enter the debugger; when set to 0, " \
37 			"hitting return key is enough to enter the debugger; " \
38 			"when set to -1, the debugger is entered immediately " \
39 			"upon NMI");
40 
41 static char *kgdb_nmi_magic = "$3#33";
42 module_param_named(magic, kgdb_nmi_magic, charp, 0600);
43 MODULE_PARM_DESC(magic, "magic sequence to enter NMI debugger (default $3#33)");
44 
45 static bool kgdb_nmi_tty_enabled;
46 
47 static void kgdb_nmi_console_write(struct console *co, const char *s, uint c)
48 {
49 	int i;
50 
51 	if (!kgdb_nmi_tty_enabled || atomic_read(&kgdb_active) >= 0)
52 		return;
53 
54 	for (i = 0; i < c; i++)
55 		dbg_io_ops->write_char(s[i]);
56 }
57 
58 static struct tty_driver *kgdb_nmi_tty_driver;
59 
60 static struct tty_driver *kgdb_nmi_console_device(struct console *co, int *idx)
61 {
62 	*idx = co->index;
63 	return kgdb_nmi_tty_driver;
64 }
65 
66 static struct console kgdb_nmi_console = {
67 	.name	= "ttyNMI",
68 	.write	= kgdb_nmi_console_write,
69 	.device	= kgdb_nmi_console_device,
70 	.flags	= CON_PRINTBUFFER | CON_ANYTIME | CON_ENABLED,
71 	.index	= -1,
72 };
73 
74 /*
75  * This is usually the maximum rate on debug ports. We make fifo large enough
76  * to make copy-pasting to the terminal usable.
77  */
78 #define KGDB_NMI_BAUD		115200
79 #define KGDB_NMI_FIFO_SIZE	roundup_pow_of_two(KGDB_NMI_BAUD / 8 / HZ)
80 
81 struct kgdb_nmi_tty_priv {
82 	struct tty_port port;
83 	struct tasklet_struct tlet;
84 	STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo;
85 };
86 
87 static struct kgdb_nmi_tty_priv *kgdb_nmi_port_to_priv(struct tty_port *port)
88 {
89 	return container_of(port, struct kgdb_nmi_tty_priv, port);
90 }
91 
92 /*
93  * Our debugging console is polled in a tasklet, so we'll check for input
94  * every tick. In HZ-less mode, we should program the next tick.  We have
95  * to use the lowlevel stuff as no locks should be grabbed.
96  */
97 #ifdef CONFIG_HIGH_RES_TIMERS
98 static void kgdb_tty_poke(void)
99 {
100 	tick_program_event(ktime_get(), 0);
101 }
102 #else
103 static inline void kgdb_tty_poke(void) {}
104 #endif
105 
106 static struct tty_port *kgdb_nmi_port;
107 
108 static void kgdb_tty_recv(int ch)
109 {
110 	struct kgdb_nmi_tty_priv *priv;
111 	char c = ch;
112 
113 	if (!kgdb_nmi_port || ch < 0)
114 		return;
115 	/*
116 	 * Can't use port->tty->driver_data as tty might be not there. Tasklet
117 	 * will check for tty and will get the ref, but here we don't have to
118 	 * do that, and actually, we can't: we're in NMI context, no locks are
119 	 * possible.
120 	 */
121 	priv = kgdb_nmi_port_to_priv(kgdb_nmi_port);
122 	kfifo_in(&priv->fifo, &c, 1);
123 	kgdb_tty_poke();
124 }
125 
126 static int kgdb_nmi_poll_one_knock(void)
127 {
128 	static int n;
129 	int c = -1;
130 	const char *magic = kgdb_nmi_magic;
131 	size_t m = strlen(magic);
132 	bool printch = 0;
133 
134 	c = dbg_io_ops->read_char();
135 	if (c == NO_POLL_CHAR)
136 		return c;
137 
138 	if (!kgdb_nmi_knock && (c == '\r' || c == '\n')) {
139 		return 1;
140 	} else if (c == magic[n]) {
141 		n = (n + 1) % m;
142 		if (!n)
143 			return 1;
144 		printch = 1;
145 	} else {
146 		n = 0;
147 	}
148 
149 	if (kgdb_nmi_tty_enabled) {
150 		kgdb_tty_recv(c);
151 		return 0;
152 	}
153 
154 	if (printch) {
155 		kdb_printf("%c", c);
156 		return 0;
157 	}
158 
159 	kdb_printf("\r%s %s to enter the debugger> %*s",
160 		   kgdb_nmi_knock ? "Type" : "Hit",
161 		   kgdb_nmi_knock ? magic  : "<return>", (int)m, "");
162 	while (m--)
163 		kdb_printf("\b");
164 	return 0;
165 }
166 
167 /**
168  * kgdb_nmi_poll_knock - Check if it is time to enter the debugger
169  *
170  * "Serial ports are often noisy, especially when muxed over another port (we
171  * often use serial over the headset connector). Noise on the async command
172  * line just causes characters that are ignored, on a command line that blocked
173  * execution noise would be catastrophic." -- Colin Cross
174  *
175  * So, this function implements KGDB/KDB knocking on the serial line: we won't
176  * enter the debugger until we receive a known magic phrase (which is actually
177  * "$3#33", known as "escape to KDB" command. There is also a relaxed variant
178  * of knocking, i.e. just pressing the return key is enough to enter the
179  * debugger. And if knocking is disabled, the function always returns 1.
180  */
181 bool kgdb_nmi_poll_knock(void)
182 {
183 	if (kgdb_nmi_knock < 0)
184 		return 1;
185 
186 	while (1) {
187 		int ret;
188 
189 		ret = kgdb_nmi_poll_one_knock();
190 		if (ret == NO_POLL_CHAR)
191 			return 0;
192 		else if (ret == 1)
193 			break;
194 	}
195 	return 1;
196 }
197 
198 /*
199  * The tasklet is cheap, it does not cause wakeups when reschedules itself,
200  * instead it waits for the next tick.
201  */
202 static void kgdb_nmi_tty_receiver(unsigned long data)
203 {
204 	struct kgdb_nmi_tty_priv *priv = (void *)data;
205 	struct tty_struct *tty;
206 	char ch;
207 
208 	tasklet_schedule(&priv->tlet);
209 
210 	if (likely(!kgdb_nmi_tty_enabled || !kfifo_len(&priv->fifo)))
211 		return;
212 
213 	/* Port is there, but tty might be hung up, check. */
214 	tty = tty_port_tty_get(kgdb_nmi_port);
215 	if (!tty)
216 		return;
217 
218 	while (kfifo_out(&priv->fifo, &ch, 1))
219 		tty_insert_flip_char(priv->port.tty, ch, TTY_NORMAL);
220 	tty_flip_buffer_push(priv->port.tty);
221 
222 	tty_kref_put(tty);
223 }
224 
225 static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty)
226 {
227 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
228 
229 	kgdb_nmi_port = port;
230 	tasklet_schedule(&priv->tlet);
231 	return 0;
232 }
233 
234 static void kgdb_nmi_tty_shutdown(struct tty_port *port)
235 {
236 	struct kgdb_nmi_tty_priv *priv = port->tty->driver_data;
237 
238 	tasklet_kill(&priv->tlet);
239 	kgdb_nmi_port = NULL;
240 }
241 
242 static const struct tty_port_operations kgdb_nmi_tty_port_ops = {
243 	.activate	= kgdb_nmi_tty_activate,
244 	.shutdown	= kgdb_nmi_tty_shutdown,
245 };
246 
247 static int kgdb_nmi_tty_install(struct tty_driver *drv, struct tty_struct *tty)
248 {
249 	struct kgdb_nmi_tty_priv *priv;
250 	int ret;
251 
252 	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
253 	if (!priv)
254 		return -ENOMEM;
255 
256 	INIT_KFIFO(priv->fifo);
257 	tasklet_init(&priv->tlet, kgdb_nmi_tty_receiver, (unsigned long)priv);
258 	tty_port_init(&priv->port);
259 	priv->port.ops = &kgdb_nmi_tty_port_ops;
260 	tty->driver_data = priv;
261 
262 	ret = tty_port_install(&priv->port, drv, tty);
263 	if (ret) {
264 		pr_err("%s: can't install tty port: %d\n", __func__, ret);
265 		goto err;
266 	}
267 	return 0;
268 err:
269 	tty_port_destroy(&priv->port);
270 	kfree(priv);
271 	return ret;
272 }
273 
274 static void kgdb_nmi_tty_cleanup(struct tty_struct *tty)
275 {
276 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
277 
278 	tty->driver_data = NULL;
279 	tty_port_destroy(&priv->port);
280 	kfree(priv);
281 }
282 
283 static int kgdb_nmi_tty_open(struct tty_struct *tty, struct file *file)
284 {
285 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
286 
287 	return tty_port_open(&priv->port, tty, file);
288 }
289 
290 static void kgdb_nmi_tty_close(struct tty_struct *tty, struct file *file)
291 {
292 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
293 
294 	tty_port_close(&priv->port, tty, file);
295 }
296 
297 static void kgdb_nmi_tty_hangup(struct tty_struct *tty)
298 {
299 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
300 
301 	tty_port_hangup(&priv->port);
302 }
303 
304 static int kgdb_nmi_tty_write_room(struct tty_struct *tty)
305 {
306 	/* Actually, we can handle any amount as we use polled writes. */
307 	return 2048;
308 }
309 
310 static int kgdb_nmi_tty_write(struct tty_struct *tty, const unchar *buf, int c)
311 {
312 	int i;
313 
314 	for (i = 0; i < c; i++)
315 		dbg_io_ops->write_char(buf[i]);
316 	return c;
317 }
318 
319 static const struct tty_operations kgdb_nmi_tty_ops = {
320 	.open		= kgdb_nmi_tty_open,
321 	.close		= kgdb_nmi_tty_close,
322 	.install	= kgdb_nmi_tty_install,
323 	.cleanup	= kgdb_nmi_tty_cleanup,
324 	.hangup		= kgdb_nmi_tty_hangup,
325 	.write_room	= kgdb_nmi_tty_write_room,
326 	.write		= kgdb_nmi_tty_write,
327 };
328 
329 static int kgdb_nmi_enable_console(int argc, const char *argv[])
330 {
331 	kgdb_nmi_tty_enabled = !(argc == 1 && !strcmp(argv[1], "off"));
332 	return 0;
333 }
334 
335 int kgdb_register_nmi_console(void)
336 {
337 	int ret;
338 
339 	if (!arch_kgdb_ops.enable_nmi)
340 		return 0;
341 
342 	kgdb_nmi_tty_driver = alloc_tty_driver(1);
343 	if (!kgdb_nmi_tty_driver) {
344 		pr_err("%s: cannot allocate tty\n", __func__);
345 		return -ENOMEM;
346 	}
347 	kgdb_nmi_tty_driver->driver_name	= "ttyNMI";
348 	kgdb_nmi_tty_driver->name		= "ttyNMI";
349 	kgdb_nmi_tty_driver->num		= 1;
350 	kgdb_nmi_tty_driver->type		= TTY_DRIVER_TYPE_SERIAL;
351 	kgdb_nmi_tty_driver->subtype		= SERIAL_TYPE_NORMAL;
352 	kgdb_nmi_tty_driver->flags		= TTY_DRIVER_REAL_RAW;
353 	kgdb_nmi_tty_driver->init_termios	= tty_std_termios;
354 	tty_termios_encode_baud_rate(&kgdb_nmi_tty_driver->init_termios,
355 				     KGDB_NMI_BAUD, KGDB_NMI_BAUD);
356 	tty_set_operations(kgdb_nmi_tty_driver, &kgdb_nmi_tty_ops);
357 
358 	ret = tty_register_driver(kgdb_nmi_tty_driver);
359 	if (ret) {
360 		pr_err("%s: can't register tty driver: %d\n", __func__, ret);
361 		goto err_drv_reg;
362 	}
363 
364 	ret = kdb_register("nmi_console", kgdb_nmi_enable_console, "[off]",
365 			   "switch to Linux NMI console", 0);
366 	if (ret) {
367 		pr_err("%s: can't register kdb command: %d\n", __func__, ret);
368 		goto err_kdb_reg;
369 	}
370 
371 	register_console(&kgdb_nmi_console);
372 	arch_kgdb_ops.enable_nmi(1);
373 
374 	return 0;
375 err_kdb_reg:
376 	tty_unregister_driver(kgdb_nmi_tty_driver);
377 err_drv_reg:
378 	put_tty_driver(kgdb_nmi_tty_driver);
379 	return ret;
380 }
381 EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);
382 
383 int kgdb_unregister_nmi_console(void)
384 {
385 	int ret;
386 
387 	if (!arch_kgdb_ops.enable_nmi)
388 		return 0;
389 	arch_kgdb_ops.enable_nmi(0);
390 
391 	kdb_unregister("nmi_console");
392 
393 	ret = unregister_console(&kgdb_nmi_console);
394 	if (ret)
395 		return ret;
396 
397 	ret = tty_unregister_driver(kgdb_nmi_tty_driver);
398 	if (ret)
399 		return ret;
400 	put_tty_driver(kgdb_nmi_tty_driver);
401 
402 	return 0;
403 }
404 EXPORT_SYMBOL_GPL(kgdb_unregister_nmi_console);
405