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