xref: /openbmc/linux/drivers/tty/serial/kgdb_nmi.c (revision d2999e1b)
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/slab.h>
19 #include <linux/errno.h>
20 #include <linux/atomic.h>
21 #include <linux/console.h>
22 #include <linux/tty.h>
23 #include <linux/tty_driver.h>
24 #include <linux/tty_flip.h>
25 #include <linux/serial_core.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 int kgdb_nmi_console_setup(struct console *co, char *options)
48 {
49 	/* The NMI console uses the dbg_io_ops to issue console messages. To
50 	 * avoid duplicate messages during kdb sessions we must inform kdb's
51 	 * I/O utilities that messages sent to the console will automatically
52 	 * be displayed on the dbg_io.
53 	 */
54 	dbg_io_ops->is_console = true;
55 
56 	return 0;
57 }
58 
59 static void kgdb_nmi_console_write(struct console *co, const char *s, uint c)
60 {
61 	int i;
62 
63 	for (i = 0; i < c; i++)
64 		dbg_io_ops->write_char(s[i]);
65 }
66 
67 static struct tty_driver *kgdb_nmi_tty_driver;
68 
69 static struct tty_driver *kgdb_nmi_console_device(struct console *co, int *idx)
70 {
71 	*idx = co->index;
72 	return kgdb_nmi_tty_driver;
73 }
74 
75 static struct console kgdb_nmi_console = {
76 	.name	= "ttyNMI",
77 	.setup  = kgdb_nmi_console_setup,
78 	.write	= kgdb_nmi_console_write,
79 	.device	= kgdb_nmi_console_device,
80 	.flags	= CON_PRINTBUFFER | CON_ANYTIME | CON_ENABLED,
81 	.index	= -1,
82 };
83 
84 /*
85  * This is usually the maximum rate on debug ports. We make fifo large enough
86  * to make copy-pasting to the terminal usable.
87  */
88 #define KGDB_NMI_BAUD		115200
89 #define KGDB_NMI_FIFO_SIZE	roundup_pow_of_two(KGDB_NMI_BAUD / 8 / HZ)
90 
91 struct kgdb_nmi_tty_priv {
92 	struct tty_port port;
93 	struct timer_list timer;
94 	STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo;
95 };
96 
97 static struct tty_port *kgdb_nmi_port;
98 
99 static void kgdb_tty_recv(int ch)
100 {
101 	struct kgdb_nmi_tty_priv *priv;
102 	char c = ch;
103 
104 	if (!kgdb_nmi_port || ch < 0)
105 		return;
106 	/*
107 	 * Can't use port->tty->driver_data as tty might be not there. Timer
108 	 * will check for tty and will get the ref, but here we don't have to
109 	 * do that, and actually, we can't: we're in NMI context, no locks are
110 	 * possible.
111 	 */
112 	priv = container_of(kgdb_nmi_port, struct kgdb_nmi_tty_priv, port);
113 	kfifo_in(&priv->fifo, &c, 1);
114 }
115 
116 static int kgdb_nmi_poll_one_knock(void)
117 {
118 	static int n;
119 	int c = -1;
120 	const char *magic = kgdb_nmi_magic;
121 	size_t m = strlen(magic);
122 	bool printch = 0;
123 
124 	c = dbg_io_ops->read_char();
125 	if (c == NO_POLL_CHAR)
126 		return c;
127 
128 	if (!kgdb_nmi_knock && (c == '\r' || c == '\n')) {
129 		return 1;
130 	} else if (c == magic[n]) {
131 		n = (n + 1) % m;
132 		if (!n)
133 			return 1;
134 		printch = 1;
135 	} else {
136 		n = 0;
137 	}
138 
139 	if (kgdb_nmi_tty_enabled) {
140 		kgdb_tty_recv(c);
141 		return 0;
142 	}
143 
144 	if (printch) {
145 		kdb_printf("%c", c);
146 		return 0;
147 	}
148 
149 	kdb_printf("\r%s %s to enter the debugger> %*s",
150 		   kgdb_nmi_knock ? "Type" : "Hit",
151 		   kgdb_nmi_knock ? magic  : "<return>", (int)m, "");
152 	while (m--)
153 		kdb_printf("\b");
154 	return 0;
155 }
156 
157 /**
158  * kgdb_nmi_poll_knock - Check if it is time to enter the debugger
159  *
160  * "Serial ports are often noisy, especially when muxed over another port (we
161  * often use serial over the headset connector). Noise on the async command
162  * line just causes characters that are ignored, on a command line that blocked
163  * execution noise would be catastrophic." -- Colin Cross
164  *
165  * So, this function implements KGDB/KDB knocking on the serial line: we won't
166  * enter the debugger until we receive a known magic phrase (which is actually
167  * "$3#33", known as "escape to KDB" command. There is also a relaxed variant
168  * of knocking, i.e. just pressing the return key is enough to enter the
169  * debugger. And if knocking is disabled, the function always returns 1.
170  */
171 bool kgdb_nmi_poll_knock(void)
172 {
173 	if (kgdb_nmi_knock < 0)
174 		return 1;
175 
176 	while (1) {
177 		int ret;
178 
179 		ret = kgdb_nmi_poll_one_knock();
180 		if (ret == NO_POLL_CHAR)
181 			return 0;
182 		else if (ret == 1)
183 			break;
184 	}
185 	return 1;
186 }
187 
188 /*
189  * The tasklet is cheap, it does not cause wakeups when reschedules itself,
190  * instead it waits for the next tick.
191  */
192 static void kgdb_nmi_tty_receiver(unsigned long data)
193 {
194 	struct kgdb_nmi_tty_priv *priv = (void *)data;
195 	char ch;
196 
197 	priv->timer.expires = jiffies + (HZ/100);
198 	add_timer(&priv->timer);
199 
200 	if (likely(!kgdb_nmi_tty_enabled || !kfifo_len(&priv->fifo)))
201 		return;
202 
203 	while (kfifo_out(&priv->fifo, &ch, 1))
204 		tty_insert_flip_char(&priv->port, ch, TTY_NORMAL);
205 	tty_flip_buffer_push(&priv->port);
206 }
207 
208 static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty)
209 {
210 	struct kgdb_nmi_tty_priv *priv =
211 	    container_of(port, struct kgdb_nmi_tty_priv, port);
212 
213 	kgdb_nmi_port = port;
214 	priv->timer.expires = jiffies + (HZ/100);
215 	add_timer(&priv->timer);
216 
217 	return 0;
218 }
219 
220 static void kgdb_nmi_tty_shutdown(struct tty_port *port)
221 {
222 	struct kgdb_nmi_tty_priv *priv =
223 	    container_of(port, struct kgdb_nmi_tty_priv, port);
224 
225 	del_timer(&priv->timer);
226 	kgdb_nmi_port = NULL;
227 }
228 
229 static const struct tty_port_operations kgdb_nmi_tty_port_ops = {
230 	.activate	= kgdb_nmi_tty_activate,
231 	.shutdown	= kgdb_nmi_tty_shutdown,
232 };
233 
234 static int kgdb_nmi_tty_install(struct tty_driver *drv, struct tty_struct *tty)
235 {
236 	struct kgdb_nmi_tty_priv *priv;
237 	int ret;
238 
239 	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
240 	if (!priv)
241 		return -ENOMEM;
242 
243 	INIT_KFIFO(priv->fifo);
244 	setup_timer(&priv->timer, kgdb_nmi_tty_receiver, (unsigned long)priv);
245 	tty_port_init(&priv->port);
246 	priv->port.ops = &kgdb_nmi_tty_port_ops;
247 	tty->driver_data = priv;
248 
249 	ret = tty_port_install(&priv->port, drv, tty);
250 	if (ret) {
251 		pr_err("%s: can't install tty port: %d\n", __func__, ret);
252 		goto err;
253 	}
254 	return 0;
255 err:
256 	tty_port_destroy(&priv->port);
257 	kfree(priv);
258 	return ret;
259 }
260 
261 static void kgdb_nmi_tty_cleanup(struct tty_struct *tty)
262 {
263 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
264 
265 	tty->driver_data = NULL;
266 	tty_port_destroy(&priv->port);
267 	kfree(priv);
268 }
269 
270 static int kgdb_nmi_tty_open(struct tty_struct *tty, struct file *file)
271 {
272 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
273 
274 	return tty_port_open(&priv->port, tty, file);
275 }
276 
277 static void kgdb_nmi_tty_close(struct tty_struct *tty, struct file *file)
278 {
279 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
280 
281 	tty_port_close(&priv->port, tty, file);
282 }
283 
284 static void kgdb_nmi_tty_hangup(struct tty_struct *tty)
285 {
286 	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
287 
288 	tty_port_hangup(&priv->port);
289 }
290 
291 static int kgdb_nmi_tty_write_room(struct tty_struct *tty)
292 {
293 	/* Actually, we can handle any amount as we use polled writes. */
294 	return 2048;
295 }
296 
297 static int kgdb_nmi_tty_write(struct tty_struct *tty, const unchar *buf, int c)
298 {
299 	int i;
300 
301 	for (i = 0; i < c; i++)
302 		dbg_io_ops->write_char(buf[i]);
303 	return c;
304 }
305 
306 static const struct tty_operations kgdb_nmi_tty_ops = {
307 	.open		= kgdb_nmi_tty_open,
308 	.close		= kgdb_nmi_tty_close,
309 	.install	= kgdb_nmi_tty_install,
310 	.cleanup	= kgdb_nmi_tty_cleanup,
311 	.hangup		= kgdb_nmi_tty_hangup,
312 	.write_room	= kgdb_nmi_tty_write_room,
313 	.write		= kgdb_nmi_tty_write,
314 };
315 
316 static int kgdb_nmi_enable_console(int argc, const char *argv[])
317 {
318 	kgdb_nmi_tty_enabled = !(argc == 1 && !strcmp(argv[1], "off"));
319 	return 0;
320 }
321 
322 int kgdb_register_nmi_console(void)
323 {
324 	int ret;
325 
326 	if (!arch_kgdb_ops.enable_nmi)
327 		return 0;
328 
329 	kgdb_nmi_tty_driver = alloc_tty_driver(1);
330 	if (!kgdb_nmi_tty_driver) {
331 		pr_err("%s: cannot allocate tty\n", __func__);
332 		return -ENOMEM;
333 	}
334 	kgdb_nmi_tty_driver->driver_name	= "ttyNMI";
335 	kgdb_nmi_tty_driver->name		= "ttyNMI";
336 	kgdb_nmi_tty_driver->num		= 1;
337 	kgdb_nmi_tty_driver->type		= TTY_DRIVER_TYPE_SERIAL;
338 	kgdb_nmi_tty_driver->subtype		= SERIAL_TYPE_NORMAL;
339 	kgdb_nmi_tty_driver->flags		= TTY_DRIVER_REAL_RAW;
340 	kgdb_nmi_tty_driver->init_termios	= tty_std_termios;
341 	tty_termios_encode_baud_rate(&kgdb_nmi_tty_driver->init_termios,
342 				     KGDB_NMI_BAUD, KGDB_NMI_BAUD);
343 	tty_set_operations(kgdb_nmi_tty_driver, &kgdb_nmi_tty_ops);
344 
345 	ret = tty_register_driver(kgdb_nmi_tty_driver);
346 	if (ret) {
347 		pr_err("%s: can't register tty driver: %d\n", __func__, ret);
348 		goto err_drv_reg;
349 	}
350 
351 	ret = kdb_register("nmi_console", kgdb_nmi_enable_console, "[off]",
352 			   "switch to Linux NMI console", 0);
353 	if (ret) {
354 		pr_err("%s: can't register kdb command: %d\n", __func__, ret);
355 		goto err_kdb_reg;
356 	}
357 
358 	register_console(&kgdb_nmi_console);
359 	arch_kgdb_ops.enable_nmi(1);
360 
361 	return 0;
362 err_kdb_reg:
363 	tty_unregister_driver(kgdb_nmi_tty_driver);
364 err_drv_reg:
365 	put_tty_driver(kgdb_nmi_tty_driver);
366 	return ret;
367 }
368 EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);
369 
370 int kgdb_unregister_nmi_console(void)
371 {
372 	int ret;
373 
374 	if (!arch_kgdb_ops.enable_nmi)
375 		return 0;
376 	arch_kgdb_ops.enable_nmi(0);
377 
378 	kdb_unregister("nmi_console");
379 
380 	ret = unregister_console(&kgdb_nmi_console);
381 	if (ret)
382 		return ret;
383 
384 	ret = tty_unregister_driver(kgdb_nmi_tty_driver);
385 	if (ret)
386 		return ret;
387 	put_tty_driver(kgdb_nmi_tty_driver);
388 
389 	return 0;
390 }
391 EXPORT_SYMBOL_GPL(kgdb_unregister_nmi_console);
392