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