drivers/tty/serial/kgdboc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Based on the same principle as kgdboe using the NETPOLL api, this
   4  * driver uses a console polling api to implement a gdb serial inteface
   5  * which is multiplexed on a console port.
   6  *
   7  * Maintainer: Jason Wessel <jason.wessel@windriver.com>
   8  *
   9  * 2007-2008 (c) Jason Wessel - Wind River Systems, Inc.
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/kernel.h>
  15 #include <linux/ctype.h>
  16 #include <linux/kgdb.h>
  17 #include <linux/kdb.h>
  18 #include <linux/tty.h>
  19 #include <linux/console.h>
  20 #include <linux/vt_kern.h>
  21 #include <linux/input.h>
  22 #include <linux/irq_work.h>
  23 #include <linux/module.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/serial_core.h>
  26
  27 #define MAX_CONFIG_LEN          40
  28
  29 static struct kgdb_io           kgdboc_io_ops;
  30
  31 /* -1 = init not run yet, 0 = unconfigured, 1 = configured. */
  32 static int configured           = -1;
  33 static DEFINE_MUTEX(config_mutex);
  34
  35 static char config[MAX_CONFIG_LEN];
  36 static struct kparam_string kps = {
  37         .string                 = config,
  38         .maxlen                 = MAX_CONFIG_LEN,
  39 };
  40
  41 static int kgdboc_use_kms;  /* 1 if we use kernel mode switching */
  42 static struct tty_driver        *kgdb_tty_driver;
  43 static int                      kgdb_tty_line;
  44
  45 static struct platform_device *kgdboc_pdev;
  46
  47 #if IS_BUILTIN(CONFIG_KGDB_SERIAL_CONSOLE)
  48 static struct kgdb_io           kgdboc_earlycon_io_ops;
  49 static int                      (*earlycon_orig_exit)(struct console *con);
  50 #endif /* IS_BUILTIN(CONFIG_KGDB_SERIAL_CONSOLE) */
  51
  52 /*
  53  * When we leave the debug trap handler we need to reset the keyboard status
  54  * (since the original keyboard state gets partially clobbered by kdb use of
  55  * the keyboard).
  56  *
  57  * The path to deliver the reset is somewhat circuitous.
  58  *
  59  * To deliver the reset we register an input handler, reset the keyboard and
  60  * then deregister the input handler. However, to get this done right, we do
  61  * have to carefully manage the calling context because we can only register
  62  * input handlers from task context.
  63  *
  64  * In particular we need to trigger the action from the debug trap handler with
  65  * all its NMI and/or NMI-like oddities. To solve this the kgdboc trap exit code
  66  * (the "post_exception" callback) uses irq_work_queue(), which is NMI-safe, to
  67  * schedule a callback from a hardirq context. From there we have to defer the
  68  * work again, this time using schedule_work(), to get a callback using the
  69  * system workqueue, which runs in task context.
  70  */
  71 #ifdef CONFIG_KDB_KEYBOARD
  72 static int kgdboc_reset_connect(struct input_handler *handler,
  73                                 struct input_dev *dev,
  74                                 const struct input_device_id *id)
  75 {
  76         input_reset_device(dev);
  77
  78         /* Return an error - we do not want to bind, just to reset */
  79         return -ENODEV;
  80 }
  81
  82 static void kgdboc_reset_disconnect(struct input_handle *handle)
  83 {
  84         /* We do not expect anyone to actually bind to us */
  85         BUG();
  86 }
  87
  88 static const struct input_device_id kgdboc_reset_ids[] = {
  89         {
  90                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
  91                 .evbit = { BIT_MASK(EV_KEY) },
  92         },
  93         { }
  94 };
  95
  96 static struct input_handler kgdboc_reset_handler = {
  97         .connect        = kgdboc_reset_connect,
  98         .disconnect     = kgdboc_reset_disconnect,
  99         .name           = "kgdboc_reset",
 100         .id_table       = kgdboc_reset_ids,
 101 };
 102
 103 static DEFINE_MUTEX(kgdboc_reset_mutex);
 104
 105 static void kgdboc_restore_input_helper(struct work_struct *dummy)
 106 {
 107         /*
 108          * We need to take a mutex to prevent several instances of
 109          * this work running on different CPUs so they don't try
 110          * to register again already registered handler.
 111          */
 112         mutex_lock(&kgdboc_reset_mutex);
 113
 114         if (input_register_handler(&kgdboc_reset_handler) == 0)
 115                 input_unregister_handler(&kgdboc_reset_handler);
 116
 117         mutex_unlock(&kgdboc_reset_mutex);
 118 }
 119
 120 static DECLARE_WORK(kgdboc_restore_input_work, kgdboc_restore_input_helper);
 121
 122 static void kgdboc_queue_restore_input_helper(struct irq_work *unused)
 123 {
 124         schedule_work(&kgdboc_restore_input_work);
 125 }
 126
 127 static DEFINE_IRQ_WORK(kgdboc_restore_input_irq_work, kgdboc_queue_restore_input_helper);
 128
 129 static void kgdboc_restore_input(void)
 130 {
 131         if (likely(system_state == SYSTEM_RUNNING))
 132                 irq_work_queue(&kgdboc_restore_input_irq_work);
 133 }
 134
 135 static int kgdboc_register_kbd(char **cptr)
 136 {
 137         if (strncmp(*cptr, "kbd", 3) == 0 ||
 138                 strncmp(*cptr, "kdb", 3) == 0) {
 139                 if (kdb_poll_idx < KDB_POLL_FUNC_MAX) {
 140                         kdb_poll_funcs[kdb_poll_idx] = kdb_get_kbd_char;
 141                         kdb_poll_idx++;
 142                         if (cptr[0][3] == ',')
 143                                 *cptr += 4;
 144                         else
 145                                 return 1;
 146                 }
 147         }
 148         return 0;
 149 }
 150
 151 static void kgdboc_unregister_kbd(void)
 152 {
 153         int i;
 154
 155         for (i = 0; i < kdb_poll_idx; i++) {
 156                 if (kdb_poll_funcs[i] == kdb_get_kbd_char) {
 157                         kdb_poll_idx--;
 158                         kdb_poll_funcs[i] = kdb_poll_funcs[kdb_poll_idx];
 159                         kdb_poll_funcs[kdb_poll_idx] = NULL;
 160                         i--;
 161                 }
 162         }
 163         irq_work_sync(&kgdboc_restore_input_irq_work);
 164         flush_work(&kgdboc_restore_input_work);
 165 }
 166 #else /* ! CONFIG_KDB_KEYBOARD */
 167 #define kgdboc_register_kbd(x) 0
 168 #define kgdboc_unregister_kbd()
 169 #define kgdboc_restore_input()
 170 #endif /* ! CONFIG_KDB_KEYBOARD */
 171
 172 #if IS_BUILTIN(CONFIG_KGDB_SERIAL_CONSOLE)
 173 static void cleanup_earlycon(void)
 174 {
 175         if (kgdboc_earlycon_io_ops.cons)
 176                 kgdb_unregister_io_module(&kgdboc_earlycon_io_ops);
 177 }
 178 #else /* !IS_BUILTIN(CONFIG_KGDB_SERIAL_CONSOLE) */
 179 static inline void cleanup_earlycon(void) { }
 180 #endif /* !IS_BUILTIN(CONFIG_KGDB_SERIAL_CONSOLE) */
 181
 182 static void cleanup_kgdboc(void)
 183 {
 184         cleanup_earlycon();
 185
 186         if (configured != 1)
 187                 return;
 188
 189         if (kgdb_unregister_nmi_console())
 190                 return;
 191         kgdboc_unregister_kbd();
 192         kgdb_unregister_io_module(&kgdboc_io_ops);
 193 }
 194
 195 static int configure_kgdboc(void)
 196 {
 197         struct tty_driver *p;
 198         int tty_line = 0;
 199         int err = -ENODEV;
 200         char *cptr = config;
 201         struct console *cons;
 202
 203         if (!strlen(config) || isspace(config[0])) {
 204                 err = 0;
 205                 goto noconfig;
 206         }
 207
 208         kgdboc_io_ops.cons = NULL;
 209         kgdb_tty_driver = NULL;
 210
 211         kgdboc_use_kms = 0;
 212         if (strncmp(cptr, "kms,", 4) == 0) {
 213                 cptr += 4;
 214                 kgdboc_use_kms = 1;
 215         }
 216
 217         if (kgdboc_register_kbd(&cptr))
 218                 goto do_register;
 219
 220         p = tty_find_polling_driver(cptr, &tty_line);
 221         if (!p)
 222                 goto noconfig;
 223
 224         for_each_console(cons) {
 225                 int idx;
 226                 if (cons->device && cons->device(cons, &idx) == p &&
 227                     idx == tty_line) {
 228                         kgdboc_io_ops.cons = cons;
 229                         break;
 230                 }
 231         }
 232
 233         kgdb_tty_driver = p;
 234         kgdb_tty_line = tty_line;
 235
 236 do_register:
 237         err = kgdb_register_io_module(&kgdboc_io_ops);
 238         if (err)
 239                 goto noconfig;
 240
 241         err = kgdb_register_nmi_console();
 242         if (err)
 243                 goto nmi_con_failed;
 244
 245         configured = 1;
 246
 247         return 0;
 248
 249 nmi_con_failed:
 250         kgdb_unregister_io_module(&kgdboc_io_ops);
 251 noconfig:
 252         kgdboc_unregister_kbd();
 253         configured = 0;
 254
 255         return err;
 256 }
 257
 258 static int kgdboc_probe(struct platform_device *pdev)
 259 {
 260         int ret = 0;
 261
 262         mutex_lock(&config_mutex);
 263         if (configured != 1) {
 264                 ret = configure_kgdboc();
 265
 266                 /* Convert "no device" to "defer" so we'll keep trying */
 267                 if (ret == -ENODEV)
 268                         ret = -EPROBE_DEFER;
 269         }
 270         mutex_unlock(&config_mutex);
 271
 272         return ret;
 273 }
 274
 275 static struct platform_driver kgdboc_platform_driver = {
 276         .probe = kgdboc_probe,
 277         .driver = {
 278                 .name = "kgdboc",
 279                 .suppress_bind_attrs = true,
 280         },
 281 };
 282
 283 static int __init init_kgdboc(void)
 284 {
 285         int ret;
 286
 287         /*
 288          * kgdboc is a little bit of an odd "platform_driver".  It can be
 289          * up and running long before the platform_driver object is
 290          * created and thus doesn't actually store anything in it.  There's
 291          * only one instance of kgdb so anything is stored as global state.
 292          * The platform_driver is only created so that we can leverage the
 293          * kernel's mechanisms (like -EPROBE_DEFER) to call us when our
 294          * underlying tty is ready.  Here we init our platform driver and
 295          * then create the single kgdboc instance.
 296          */
 297         ret = platform_driver_register(&kgdboc_platform_driver);
 298         if (ret)
 299                 return ret;
 300
 301         kgdboc_pdev = platform_device_alloc("kgdboc", PLATFORM_DEVID_NONE);
 302         if (!kgdboc_pdev) {
 303                 ret = -ENOMEM;
 304                 goto err_did_register;
 305         }
 306
 307         ret = platform_device_add(kgdboc_pdev);
 308         if (!ret)
 309                 return 0;
 310
 311         platform_device_put(kgdboc_pdev);
 312
 313 err_did_register:
 314         platform_driver_unregister(&kgdboc_platform_driver);
 315         return ret;
 316 }
 317
 318 static void exit_kgdboc(void)
 319 {
 320         mutex_lock(&config_mutex);
 321         cleanup_kgdboc();
 322         mutex_unlock(&config_mutex);
 323
 324         platform_device_unregister(kgdboc_pdev);
 325         platform_driver_unregister(&kgdboc_platform_driver);
 326 }
 327
 328 static int kgdboc_get_char(void)
 329 {
 330         if (!kgdb_tty_driver)
 331                 return -1;
 332         return kgdb_tty_driver->ops->poll_get_char(kgdb_tty_driver,
 333                                                 kgdb_tty_line);
 334 }
 335
 336 static void kgdboc_put_char(u8 chr)
 337 {
 338         if (!kgdb_tty_driver)
 339                 return;
 340         kgdb_tty_driver->ops->poll_put_char(kgdb_tty_driver,
 341                                         kgdb_tty_line, chr);
 342 }
 343
 344 static int param_set_kgdboc_var(const char *kmessage,
 345                                 const struct kernel_param *kp)
 346 {
 347         size_t len = strlen(kmessage);
 348         int ret = 0;
 349
 350         if (len >= MAX_CONFIG_LEN) {
 351                 pr_err("config string too long\n");
 352                 return -ENOSPC;
 353         }
 354
 355         if (kgdb_connected) {
 356                 pr_err("Cannot reconfigure while KGDB is connected.\n");
 357                 return -EBUSY;
 358         }
 359
 360         mutex_lock(&config_mutex);
 361
 362         strcpy(config, kmessage);
 363         /* Chop out \n char as a result of echo */
 364         if (len && config[len - 1] == '\n')
 365                 config[len - 1] = '\0';
 366
 367         if (configured == 1)
 368                 cleanup_kgdboc();
 369
 370         /*
 371          * Configure with the new params as long as init already ran.
 372          * Note that we can get called before init if someone loads us
 373          * with "modprobe kgdboc kgdboc=..." or if they happen to use the
 374          * the odd syntax of "kgdboc.kgdboc=..." on the kernel command.
 375          */
 376         if (configured >= 0)
 377                 ret = configure_kgdboc();
 378
 379         /*
 380          * If we couldn't configure then clear out the config.  Note that
 381          * specifying an invalid config on the kernel command line vs.
 382          * through sysfs have slightly different behaviors.  If we fail
 383          * to configure what was specified on the kernel command line
 384          * we'll leave it in the 'config' and return -EPROBE_DEFER from
 385          * our probe.  When specified through sysfs userspace is
 386          * responsible for loading the tty driver before setting up.
 387          */
 388         if (ret)
 389                 config[0] = '\0';
 390
 391         mutex_unlock(&config_mutex);
 392
 393         return ret;
 394 }
 395
 396 static int dbg_restore_graphics;
 397
 398 static void kgdboc_pre_exp_handler(void)
 399 {
 400         if (!dbg_restore_graphics && kgdboc_use_kms) {
 401                 dbg_restore_graphics = 1;
 402                 con_debug_enter(vc_cons[fg_console].d);
 403         }
 404         /* Increment the module count when the debugger is active */
 405         if (!kgdb_connected)
 406                 try_module_get(THIS_MODULE);
 407 }
 408
 409 static void kgdboc_post_exp_handler(void)
 410 {
 411         /* decrement the module count when the debugger detaches */
 412         if (!kgdb_connected)
 413                 module_put(THIS_MODULE);
 414         if (kgdboc_use_kms && dbg_restore_graphics) {
 415                 dbg_restore_graphics = 0;
 416                 con_debug_leave();
 417         }
 418         kgdboc_restore_input();
 419 }
 420
 421 static struct kgdb_io kgdboc_io_ops = {
 422         .name                   = "kgdboc",
 423         .read_char              = kgdboc_get_char,
 424         .write_char             = kgdboc_put_char,
 425         .pre_exception          = kgdboc_pre_exp_handler,
 426         .post_exception         = kgdboc_post_exp_handler,
 427 };
 428
 429 #if IS_BUILTIN(CONFIG_KGDB_SERIAL_CONSOLE)
 430 static int kgdboc_option_setup(char *opt)
 431 {
 432         if (!opt) {
 433                 pr_err("config string not provided\n");
 434                 return 1;
 435         }
 436
 437         if (strlen(opt) >= MAX_CONFIG_LEN) {
 438                 pr_err("config string too long\n");
 439                 return 1;
 440         }
 441         strcpy(config, opt);
 442
 443         return 1;
 444 }
 445
 446 __setup("kgdboc=", kgdboc_option_setup);
 447
 448
 449 /* This is only available if kgdboc is a built in for early debugging */
 450 static int __init kgdboc_early_init(char *opt)
 451 {
 452         kgdboc_option_setup(opt);
 453         configure_kgdboc();
 454         return 0;
 455 }
 456
 457 early_param("ekgdboc", kgdboc_early_init);
 458
 459 static int kgdboc_earlycon_get_char(void)
 460 {
 461         char c;
 462
 463         if (!kgdboc_earlycon_io_ops.cons->read(kgdboc_earlycon_io_ops.cons,
 464                                                &c, 1))
 465                 return NO_POLL_CHAR;
 466
 467         return c;
 468 }
 469
 470 static void kgdboc_earlycon_put_char(u8 chr)
 471 {
 472         kgdboc_earlycon_io_ops.cons->write(kgdboc_earlycon_io_ops.cons, &chr,
 473                                            1);
 474 }
 475
 476 static void kgdboc_earlycon_pre_exp_handler(void)
 477 {
 478         struct console *con;
 479         static bool already_warned;
 480
 481         if (already_warned)
 482                 return;
 483
 484         /*
 485          * When the first normal console comes up the kernel will take all
 486          * the boot consoles out of the list.  Really, we should stop using
 487          * the boot console when it does that but until a TTY is registered
 488          * we have no other choice so we keep using it.  Since not all
 489          * serial drivers might be OK with this, print a warning once per
 490          * boot if we detect this case.
 491          */
 492         for_each_console(con)
 493                 if (con == kgdboc_earlycon_io_ops.cons)
 494                         return;
 495
 496         already_warned = true;
 497         pr_warn("kgdboc_earlycon is still using bootconsole\n");
 498 }
 499
 500 static int kgdboc_earlycon_deferred_exit(struct console *con)
 501 {
 502         /*
 503          * If we get here it means the boot console is going away but we
 504          * don't yet have a suitable replacement.  Don't pass through to
 505          * the original exit routine.  We'll call it later in our deinit()
 506          * function.  For now, restore the original exit() function pointer
 507          * as a sentinal that we've hit this point.
 508          */
 509         con->exit = earlycon_orig_exit;
 510
 511         return 0;
 512 }
 513
 514 static void kgdboc_earlycon_deinit(void)
 515 {
 516         if (!kgdboc_earlycon_io_ops.cons)
 517                 return;
 518
 519         if (kgdboc_earlycon_io_ops.cons->exit == kgdboc_earlycon_deferred_exit)
 520                 /*
 521                  * kgdboc_earlycon is exiting but original boot console exit
 522                  * was never called (AKA kgdboc_earlycon_deferred_exit()
 523                  * didn't ever run).  Undo our trap.
 524                  */
 525                 kgdboc_earlycon_io_ops.cons->exit = earlycon_orig_exit;
 526         else if (kgdboc_earlycon_io_ops.cons->exit)
 527                 /*
 528                  * We skipped calling the exit() routine so we could try to
 529                  * keep using the boot console even after it went away.  We're
 530                  * finally done so call the function now.
 531                  */
 532                 kgdboc_earlycon_io_ops.cons->exit(kgdboc_earlycon_io_ops.cons);
 533
 534         kgdboc_earlycon_io_ops.cons = NULL;
 535 }
 536
 537 static struct kgdb_io kgdboc_earlycon_io_ops = {
 538         .name                   = "kgdboc_earlycon",
 539         .read_char              = kgdboc_earlycon_get_char,
 540         .write_char             = kgdboc_earlycon_put_char,
 541         .pre_exception          = kgdboc_earlycon_pre_exp_handler,
 542         .deinit                 = kgdboc_earlycon_deinit,
 543 };
 544
 545 #define MAX_CONSOLE_NAME_LEN (sizeof((struct console *) 0)->name)
 546 static char kgdboc_earlycon_param[MAX_CONSOLE_NAME_LEN] __initdata;
 547 static bool kgdboc_earlycon_late_enable __initdata;
 548
 549 static int __init kgdboc_earlycon_init(char *opt)
 550 {
 551         struct console *con;
 552
 553         kdb_init(KDB_INIT_EARLY);
 554
 555         /*
 556          * Look for a matching console, or if the name was left blank just
 557          * pick the first one we find.
 558          */
 559         console_lock();
 560         for_each_console(con) {
 561                 if (con->write && con->read &&
 562                     (con->flags & (CON_BOOT | CON_ENABLED)) &&
 563                     (!opt || !opt[0] || strcmp(con->name, opt) == 0))
 564                         break;
 565         }
 566
 567         if (!con) {
 568                 /*
 569                  * Both earlycon and kgdboc_earlycon are initialized during
 570                  * early parameter parsing. We cannot guarantee earlycon gets
 571                  * in first and, in any case, on ACPI systems earlycon may
 572                  * defer its own initialization (usually to somewhere within
 573                  * setup_arch() ). To cope with either of these situations
 574                  * we can defer our own initialization to a little later in
 575                  * the boot.
 576                  */
 577                 if (!kgdboc_earlycon_late_enable) {
 578                         pr_info("No suitable earlycon yet, will try later\n");
 579                         if (opt)
 580                                 strscpy(kgdboc_earlycon_param, opt,
 581                                         sizeof(kgdboc_earlycon_param));
 582                         kgdboc_earlycon_late_enable = true;
 583                 } else {
 584                         pr_info("Couldn't find kgdb earlycon\n");
 585                 }
 586                 goto unlock;
 587         }
 588
 589         kgdboc_earlycon_io_ops.cons = con;
 590         pr_info("Going to register kgdb with earlycon '%s'\n", con->name);
 591         if (kgdb_register_io_module(&kgdboc_earlycon_io_ops) != 0) {
 592                 kgdboc_earlycon_io_ops.cons = NULL;
 593                 pr_info("Failed to register kgdb with earlycon\n");
 594         } else {
 595                 /* Trap exit so we can keep earlycon longer if needed. */
 596                 earlycon_orig_exit = con->exit;
 597                 con->exit = kgdboc_earlycon_deferred_exit;
 598         }
 599
 600 unlock:
 601         console_unlock();
 602
 603         /* Non-zero means malformed option so we always return zero */
 604         return 0;
 605 }
 606
 607 early_param("kgdboc_earlycon", kgdboc_earlycon_init);
 608
 609 /*
 610  * This is only intended for the late adoption of an early console.
 611  *
 612  * It is not a reliable way to adopt regular consoles because we can not
 613  * control what order console initcalls are made and, in any case, many
 614  * regular consoles are registered much later in the boot process than
 615  * the console initcalls!
 616  */
 617 static int __init kgdboc_earlycon_late_init(void)
 618 {
 619         if (kgdboc_earlycon_late_enable)
 620                 kgdboc_earlycon_init(kgdboc_earlycon_param);
 621         return 0;
 622 }
 623 console_initcall(kgdboc_earlycon_late_init);
 624
 625 #endif /* IS_BUILTIN(CONFIG_KGDB_SERIAL_CONSOLE) */
 626
 627 module_init(init_kgdboc);
 628 module_exit(exit_kgdboc);
 629 module_param_call(kgdboc, param_set_kgdboc_var, param_get_string, &kps, 0644);
 630 MODULE_PARM_DESC(kgdboc, "<serial_device>[,baud]");
 631 MODULE_DESCRIPTION("KGDB Console TTY Driver");
 632 MODULE_LICENSE("GPL");