drivers/tty/serial/kgdb_nmi.c

   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);