1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * KGDB NMI serial console
  4 *
  5 * Copyright 2010 Google, Inc.
  6 *		  Arve Hjønnevåg <arve@android.com>
  7 *		  Colin Cross <ccross@android.com>
  8 * Copyright 2012 Linaro Ltd.
  9 *		  Anton Vorontsov <anton.vorontsov@linaro.org>
 10 */
 11
 12#include <linux/kernel.h>
 13#include <linux/module.h>
 14#include <linux/compiler.h>
 15#include <linux/slab.h>
 16#include <linux/errno.h>
 17#include <linux/atomic.h>
 18#include <linux/console.h>
 19#include <linux/tty.h>
 20#include <linux/tty_driver.h>
 21#include <linux/tty_flip.h>
 22#include <linux/serial_core.h>
 23#include <linux/interrupt.h>
 24#include <linux/hrtimer.h>
 25#include <linux/tick.h>
 26#include <linux/kfifo.h>
 27#include <linux/kgdb.h>
 28#include <linux/kdb.h>
 29
 30static int kgdb_nmi_knock = 1;
 31module_param_named(knock, kgdb_nmi_knock, int, 0600);
 32MODULE_PARM_DESC(knock, "if set to 1 (default), the special '$3#33' command " \
 33			"must be used to enter the debugger; when set to 0, " \
 34			"hitting return key is enough to enter the debugger; " \
 35			"when set to -1, the debugger is entered immediately " \
 36			"upon NMI");
 37
 38static char *kgdb_nmi_magic = "$3#33";
 39module_param_named(magic, kgdb_nmi_magic, charp, 0600);
 40MODULE_PARM_DESC(magic, "magic sequence to enter NMI debugger (default $3#33)");
 41
 42static atomic_t kgdb_nmi_num_readers = ATOMIC_INIT(0);
 43
 44static int kgdb_nmi_console_setup(struct console *co, char *options)
 45{
 46	arch_kgdb_ops.enable_nmi(1);
 47
 48	/* The NMI console uses the dbg_io_ops to issue console messages. To
 49	 * avoid duplicate messages during kdb sessions we must inform kdb's
 50	 * I/O utilities that messages sent to the console will automatically
 51	 * be displayed on the dbg_io.
 52	 */
 53	dbg_io_ops->cons = co;
 54
 55	return 0;
 56}
 57
 58static void kgdb_nmi_console_write(struct console *co, const char *s, uint c)
 59{
 60	int i;
 61
 62	for (i = 0; i < c; i++)
 63		dbg_io_ops->write_char(s[i]);
 64}
 65
 66static struct tty_driver *kgdb_nmi_tty_driver;
 67
 68static struct tty_driver *kgdb_nmi_console_device(struct console *co, int *idx)
 69{
 70	*idx = co->index;
 71	return kgdb_nmi_tty_driver;
 72}
 73
 74static struct console kgdb_nmi_console = {
 75	.name	= "ttyNMI",
 76	.setup  = kgdb_nmi_console_setup,
 77	.write	= kgdb_nmi_console_write,
 78	.device	= kgdb_nmi_console_device,
 79	.flags	= CON_PRINTBUFFER | CON_ANYTIME,
 80	.index	= -1,
 81};
 82
 83/*
 84 * This is usually the maximum rate on debug ports. We make fifo large enough
 85 * to make copy-pasting to the terminal usable.
 86 */
 87#define KGDB_NMI_BAUD		115200
 88#define KGDB_NMI_FIFO_SIZE	roundup_pow_of_two(KGDB_NMI_BAUD / 8 / HZ)
 89
 90struct kgdb_nmi_tty_priv {
 91	struct tty_port port;
 92	struct timer_list timer;
 93	STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo;
 94};
 95
 96static struct tty_port *kgdb_nmi_port;
 97
 98static void kgdb_tty_recv(int ch)
 99{
100	struct kgdb_nmi_tty_priv *priv;
101	char c = ch;
102
103	if (!kgdb_nmi_port || ch < 0)
104		return;
105	/*
106	 * Can't use port->tty->driver_data as tty might be not there. Timer
107	 * will check for tty and will get the ref, but here we don't have to
108	 * do that, and actually, we can't: we're in NMI context, no locks are
109	 * possible.
110	 */
111	priv = container_of(kgdb_nmi_port, struct kgdb_nmi_tty_priv, port);
112	kfifo_in(&priv->fifo, &c, 1);
113}
114
115static int kgdb_nmi_poll_one_knock(void)
116{
117	static int n;
118	int c;
119	const char *magic = kgdb_nmi_magic;
120	size_t m = strlen(magic);
121	bool printch = false;
122
123	c = dbg_io_ops->read_char();
124	if (c == NO_POLL_CHAR)
125		return c;
126
127	if (!kgdb_nmi_knock && (c == '\r' || c == '\n')) {
128		return 1;
129	} else if (c == magic[n]) {
130		n = (n + 1) % m;
131		if (!n)
132			return 1;
133		printch = true;
134	} else {
135		n = 0;
136	}
137
138	if (atomic_read(&kgdb_nmi_num_readers)) {
139		kgdb_tty_recv(c);
140		return 0;
141	}
142
143	if (printch) {
144		kdb_printf("%c", c);
145		return 0;
146	}
147
148	kdb_printf("\r%s %s to enter the debugger> %*s",
149		   kgdb_nmi_knock ? "Type" : "Hit",
150		   kgdb_nmi_knock ? magic  : "<return>", (int)m, "");
151	while (m--)
152		kdb_printf("\b");
153	return 0;
154}
155
156/**
157 * kgdb_nmi_poll_knock - Check if it is time to enter the debugger
158 *
159 * "Serial ports are often noisy, especially when muxed over another port (we
160 * often use serial over the headset connector). Noise on the async command
161 * line just causes characters that are ignored, on a command line that blocked
162 * execution noise would be catastrophic." -- Colin Cross
163 *
164 * So, this function implements KGDB/KDB knocking on the serial line: we won't
165 * enter the debugger until we receive a known magic phrase (which is actually
166 * "$3#33", known as "escape to KDB" command. There is also a relaxed variant
167 * of knocking, i.e. just pressing the return key is enough to enter the
168 * debugger. And if knocking is disabled, the function always returns 1.
169 */
170bool kgdb_nmi_poll_knock(void)
171{
172	if (kgdb_nmi_knock < 0)
173		return true;
174
175	while (1) {
176		int ret;
177
178		ret = kgdb_nmi_poll_one_knock();
179		if (ret == NO_POLL_CHAR)
180			return false;
181		else if (ret == 1)
182			break;
183	}
184	return true;
185}
186
187/*
188 * The tasklet is cheap, it does not cause wakeups when reschedules itself,
189 * instead it waits for the next tick.
190 */
191static void kgdb_nmi_tty_receiver(struct timer_list *t)
192{
193	struct kgdb_nmi_tty_priv *priv = from_timer(priv, t, timer);
194	char ch;
195
196	priv->timer.expires = jiffies + (HZ/100);
197	add_timer(&priv->timer);
198
199	if (likely(!atomic_read(&kgdb_nmi_num_readers) ||
200		   !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
208static 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
220static 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
229static const struct tty_port_operations kgdb_nmi_tty_port_ops = {
230	.activate	= kgdb_nmi_tty_activate,
231	.shutdown	= kgdb_nmi_tty_shutdown,
232};
233
234static 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	timer_setup(&priv->timer, kgdb_nmi_tty_receiver, 0);
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;
255err:
256	tty_port_destroy(&priv->port);
257	kfree(priv);
258	return ret;
259}
260
261static 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
270static int kgdb_nmi_tty_open(struct tty_struct *tty, struct file *file)
271{
272	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
273	unsigned int mode = file->f_flags & O_ACCMODE;
274	int ret;
275
276	ret = tty_port_open(&priv->port, tty, file);
277	if (!ret && (mode == O_RDONLY || mode == O_RDWR))
278		atomic_inc(&kgdb_nmi_num_readers);
279
280	return ret;
281}
282
283static void kgdb_nmi_tty_close(struct tty_struct *tty, struct file *file)
284{
285	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
286	unsigned int mode = file->f_flags & O_ACCMODE;
287
288	if (mode == O_RDONLY || mode == O_RDWR)
289		atomic_dec(&kgdb_nmi_num_readers);
290
291	tty_port_close(&priv->port, tty, file);
292}
293
294static void kgdb_nmi_tty_hangup(struct tty_struct *tty)
295{
296	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
297
298	tty_port_hangup(&priv->port);
299}
300
301static unsigned int kgdb_nmi_tty_write_room(struct tty_struct *tty)
302{
303	/* Actually, we can handle any amount as we use polled writes. */
304	return 2048;
305}
306
307static ssize_t kgdb_nmi_tty_write(struct tty_struct *tty, const u8 *buf,
308				  size_t c)
309{
310	int i;
311
312	for (i = 0; i < c; i++)
313		dbg_io_ops->write_char(buf[i]);
314	return c;
315}
316
317static const struct tty_operations kgdb_nmi_tty_ops = {
318	.open		= kgdb_nmi_tty_open,
319	.close		= kgdb_nmi_tty_close,
320	.install	= kgdb_nmi_tty_install,
321	.cleanup	= kgdb_nmi_tty_cleanup,
322	.hangup		= kgdb_nmi_tty_hangup,
323	.write_room	= kgdb_nmi_tty_write_room,
324	.write		= kgdb_nmi_tty_write,
325};
326
327int kgdb_register_nmi_console(void)
328{
329	int ret;
330
331	if (!arch_kgdb_ops.enable_nmi)
332		return 0;
333
334	kgdb_nmi_tty_driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW);
335	if (IS_ERR(kgdb_nmi_tty_driver)) {
336		pr_err("%s: cannot allocate tty\n", __func__);
337		return PTR_ERR(kgdb_nmi_tty_driver);
338	}
339	kgdb_nmi_tty_driver->driver_name	= "ttyNMI";
340	kgdb_nmi_tty_driver->name		= "ttyNMI";
341	kgdb_nmi_tty_driver->num		= 1;
342	kgdb_nmi_tty_driver->type		= TTY_DRIVER_TYPE_SERIAL;
343	kgdb_nmi_tty_driver->subtype		= SERIAL_TYPE_NORMAL;
344	kgdb_nmi_tty_driver->init_termios	= tty_std_termios;
345	tty_termios_encode_baud_rate(&kgdb_nmi_tty_driver->init_termios,
346				     KGDB_NMI_BAUD, KGDB_NMI_BAUD);
347	tty_set_operations(kgdb_nmi_tty_driver, &kgdb_nmi_tty_ops);
348
349	ret = tty_register_driver(kgdb_nmi_tty_driver);
350	if (ret) {
351		pr_err("%s: can't register tty driver: %d\n", __func__, ret);
352		goto err_drv_reg;
353	}
354
355	register_console(&kgdb_nmi_console);
356
357	return 0;
358err_drv_reg:
359	tty_driver_kref_put(kgdb_nmi_tty_driver);
360	return ret;
361}
362EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);
363
364int kgdb_unregister_nmi_console(void)
365{
366	int ret;
367
368	if (!arch_kgdb_ops.enable_nmi)
369		return 0;
370	arch_kgdb_ops.enable_nmi(0);
371
372	ret = unregister_console(&kgdb_nmi_console);
373	if (ret)
374		return ret;
375
376	tty_unregister_driver(kgdb_nmi_tty_driver);
377	tty_driver_kref_put(kgdb_nmi_tty_driver);
378
379	return 0;
380}
381EXPORT_SYMBOL_GPL(kgdb_unregister_nmi_console);