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/module.h>
  23 #include <linux/platform_device.h>
  24
  25 #define MAX_CONFIG_LEN          40
  26
  27 static struct kgdb_io           kgdboc_io_ops;
  28
  29 /* -1 = init not run yet, 0 = unconfigured, 1 = configured. */
  30 static int configured           = -1;
  31 static DEFINE_MUTEX(config_mutex);
  32
  33 static char config[MAX_CONFIG_LEN];
  34 static struct kparam_string kps = {
  35         .string                 = config,
  36         .maxlen                 = MAX_CONFIG_LEN,
  37 };
  38
  39 static int kgdboc_use_kms;  /* 1 if we use kernel mode switching */
  40 static struct tty_driver        *kgdb_tty_driver;
  41 static int                      kgdb_tty_line;
  42
  43 static struct platform_device *kgdboc_pdev;
  44
  45 #ifdef CONFIG_KDB_KEYBOARD
  46 static int kgdboc_reset_connect(struct input_handler *handler,
  47                                 struct input_dev *dev,
  48                                 const struct input_device_id *id)
  49 {
  50         input_reset_device(dev);
  51
  52         /* Return an error - we do not want to bind, just to reset */
  53         return -ENODEV;
  54 }
  55
  56 static void kgdboc_reset_disconnect(struct input_handle *handle)
  57 {
  58         /* We do not expect anyone to actually bind to us */
  59         BUG();
  60 }
  61
  62 static const struct input_device_id kgdboc_reset_ids[] = {
  63         {
  64                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
  65                 .evbit = { BIT_MASK(EV_KEY) },
  66         },
  67         { }
  68 };
  69
  70 static struct input_handler kgdboc_reset_handler = {
  71         .connect        = kgdboc_reset_connect,
  72         .disconnect     = kgdboc_reset_disconnect,
  73         .name           = "kgdboc_reset",
  74         .id_table       = kgdboc_reset_ids,
  75 };
  76
  77 static DEFINE_MUTEX(kgdboc_reset_mutex);
  78
  79 static void kgdboc_restore_input_helper(struct work_struct *dummy)
  80 {
  81         /*
  82          * We need to take a mutex to prevent several instances of
  83          * this work running on different CPUs so they don't try
  84          * to register again already registered handler.
  85          */
  86         mutex_lock(&kgdboc_reset_mutex);
  87
  88         if (input_register_handler(&kgdboc_reset_handler) == 0)
  89                 input_unregister_handler(&kgdboc_reset_handler);
  90
  91         mutex_unlock(&kgdboc_reset_mutex);
  92 }
  93
  94 static DECLARE_WORK(kgdboc_restore_input_work, kgdboc_restore_input_helper);
  95
  96 static void kgdboc_restore_input(void)
  97 {
  98         if (likely(system_state == SYSTEM_RUNNING))
  99                 schedule_work(&kgdboc_restore_input_work);
 100 }
 101
 102 static int kgdboc_register_kbd(char **cptr)
 103 {
 104         if (strncmp(*cptr, "kbd", 3) == 0 ||
 105                 strncmp(*cptr, "kdb", 3) == 0) {
 106                 if (kdb_poll_idx < KDB_POLL_FUNC_MAX) {
 107                         kdb_poll_funcs[kdb_poll_idx] = kdb_get_kbd_char;
 108                         kdb_poll_idx++;
 109                         if (cptr[0][3] == ',')
 110                                 *cptr += 4;
 111                         else
 112                                 return 1;
 113                 }
 114         }
 115         return 0;
 116 }
 117
 118 static void kgdboc_unregister_kbd(void)
 119 {
 120         int i;
 121
 122         for (i = 0; i < kdb_poll_idx; i++) {
 123                 if (kdb_poll_funcs[i] == kdb_get_kbd_char) {
 124                         kdb_poll_idx--;
 125                         kdb_poll_funcs[i] = kdb_poll_funcs[kdb_poll_idx];
 126                         kdb_poll_funcs[kdb_poll_idx] = NULL;
 127                         i--;
 128                 }
 129         }
 130         flush_work(&kgdboc_restore_input_work);
 131 }
 132 #else /* ! CONFIG_KDB_KEYBOARD */
 133 #define kgdboc_register_kbd(x) 0
 134 #define kgdboc_unregister_kbd()
 135 #define kgdboc_restore_input()
 136 #endif /* ! CONFIG_KDB_KEYBOARD */
 137
 138 static void cleanup_kgdboc(void)
 139 {
 140         if (configured != 1)
 141                 return;
 142
 143         if (kgdb_unregister_nmi_console())
 144                 return;
 145         kgdboc_unregister_kbd();
 146         kgdb_unregister_io_module(&kgdboc_io_ops);
 147 }
 148
 149 static int configure_kgdboc(void)
 150 {
 151         struct tty_driver *p;
 152         int tty_line = 0;
 153         int err = -ENODEV;
 154         char *cptr = config;
 155         struct console *cons;
 156
 157         if (!strlen(config) || isspace(config[0])) {
 158                 err = 0;
 159                 goto noconfig;
 160         }
 161
 162         kgdboc_io_ops.is_console = 0;
 163         kgdb_tty_driver = NULL;
 164
 165         kgdboc_use_kms = 0;
 166         if (strncmp(cptr, "kms,", 4) == 0) {
 167                 cptr += 4;
 168                 kgdboc_use_kms = 1;
 169         }
 170
 171         if (kgdboc_register_kbd(&cptr))
 172                 goto do_register;
 173
 174         p = tty_find_polling_driver(cptr, &tty_line);
 175         if (!p)
 176                 goto noconfig;
 177
 178         for_each_console(cons) {
 179                 int idx;
 180                 if (cons->device && cons->device(cons, &idx) == p &&
 181                     idx == tty_line) {
 182                         kgdboc_io_ops.is_console = 1;
 183                         break;
 184                 }
 185         }
 186
 187         kgdb_tty_driver = p;
 188         kgdb_tty_line = tty_line;
 189
 190 do_register:
 191         err = kgdb_register_io_module(&kgdboc_io_ops);
 192         if (err)
 193                 goto noconfig;
 194
 195         err = kgdb_register_nmi_console();
 196         if (err)
 197                 goto nmi_con_failed;
 198
 199         configured = 1;
 200
 201         return 0;
 202
 203 nmi_con_failed:
 204         kgdb_unregister_io_module(&kgdboc_io_ops);
 205 noconfig:
 206         kgdboc_unregister_kbd();
 207         configured = 0;
 208
 209         return err;
 210 }
 211
 212 static int kgdboc_probe(struct platform_device *pdev)
 213 {
 214         int ret = 0;
 215
 216         mutex_lock(&config_mutex);
 217         if (configured != 1) {
 218                 ret = configure_kgdboc();
 219
 220                 /* Convert "no device" to "defer" so we'll keep trying */
 221                 if (ret == -ENODEV)
 222                         ret = -EPROBE_DEFER;
 223         }
 224         mutex_unlock(&config_mutex);
 225
 226         return ret;
 227 }
 228
 229 static struct platform_driver kgdboc_platform_driver = {
 230         .probe = kgdboc_probe,
 231         .driver = {
 232                 .name = "kgdboc",
 233                 .suppress_bind_attrs = true,
 234         },
 235 };
 236
 237 static int __init init_kgdboc(void)
 238 {
 239         int ret;
 240
 241         /*
 242          * kgdboc is a little bit of an odd "platform_driver".  It can be
 243          * up and running long before the platform_driver object is
 244          * created and thus doesn't actually store anything in it.  There's
 245          * only one instance of kgdb so anything is stored as global state.
 246          * The platform_driver is only created so that we can leverage the
 247          * kernel's mechanisms (like -EPROBE_DEFER) to call us when our
 248          * underlying tty is ready.  Here we init our platform driver and
 249          * then create the single kgdboc instance.
 250          */
 251         ret = platform_driver_register(&kgdboc_platform_driver);
 252         if (ret)
 253                 return ret;
 254
 255         kgdboc_pdev = platform_device_alloc("kgdboc", PLATFORM_DEVID_NONE);
 256         if (!kgdboc_pdev) {
 257                 ret = -ENOMEM;
 258                 goto err_did_register;
 259         }
 260
 261         ret = platform_device_add(kgdboc_pdev);
 262         if (!ret)
 263                 return 0;
 264
 265         platform_device_put(kgdboc_pdev);
 266
 267 err_did_register:
 268         platform_driver_unregister(&kgdboc_platform_driver);
 269         return ret;
 270 }
 271
 272 static void exit_kgdboc(void)
 273 {
 274         mutex_lock(&config_mutex);
 275         cleanup_kgdboc();
 276         mutex_unlock(&config_mutex);
 277
 278         platform_device_unregister(kgdboc_pdev);
 279         platform_driver_unregister(&kgdboc_platform_driver);
 280 }
 281
 282 static int kgdboc_get_char(void)
 283 {
 284         if (!kgdb_tty_driver)
 285                 return -1;
 286         return kgdb_tty_driver->ops->poll_get_char(kgdb_tty_driver,
 287                                                 kgdb_tty_line);
 288 }
 289
 290 static void kgdboc_put_char(u8 chr)
 291 {
 292         if (!kgdb_tty_driver)
 293                 return;
 294         kgdb_tty_driver->ops->poll_put_char(kgdb_tty_driver,
 295                                         kgdb_tty_line, chr);
 296 }
 297
 298 static int param_set_kgdboc_var(const char *kmessage,
 299                                 const struct kernel_param *kp)
 300 {
 301         size_t len = strlen(kmessage);
 302         int ret = 0;
 303
 304         if (len >= MAX_CONFIG_LEN) {
 305                 pr_err("config string too long\n");
 306                 return -ENOSPC;
 307         }
 308
 309         if (kgdb_connected) {
 310                 pr_err("Cannot reconfigure while KGDB is connected.\n");
 311                 return -EBUSY;
 312         }
 313
 314         mutex_lock(&config_mutex);
 315
 316         strcpy(config, kmessage);
 317         /* Chop out \n char as a result of echo */
 318         if (len && config[len - 1] == '\n')
 319                 config[len - 1] = '\0';
 320
 321         if (configured == 1)
 322                 cleanup_kgdboc();
 323
 324         /*
 325          * Configure with the new params as long as init already ran.
 326          * Note that we can get called before init if someone loads us
 327          * with "modprobe kgdboc kgdboc=..." or if they happen to use the
 328          * the odd syntax of "kgdboc.kgdboc=..." on the kernel command.
 329          */
 330         if (configured >= 0)
 331                 ret = configure_kgdboc();
 332
 333         /*
 334          * If we couldn't configure then clear out the config.  Note that
 335          * specifying an invalid config on the kernel command line vs.
 336          * through sysfs have slightly different behaviors.  If we fail
 337          * to configure what was specified on the kernel command line
 338          * we'll leave it in the 'config' and return -EPROBE_DEFER from
 339          * our probe.  When specified through sysfs userspace is
 340          * responsible for loading the tty driver before setting up.
 341          */
 342         if (ret)
 343                 config[0] = '\0';
 344
 345         mutex_unlock(&config_mutex);
 346
 347         return ret;
 348 }
 349
 350 static int dbg_restore_graphics;
 351
 352 static void kgdboc_pre_exp_handler(void)
 353 {
 354         if (!dbg_restore_graphics && kgdboc_use_kms) {
 355                 dbg_restore_graphics = 1;
 356                 con_debug_enter(vc_cons[fg_console].d);
 357         }
 358         /* Increment the module count when the debugger is active */
 359         if (!kgdb_connected)
 360                 try_module_get(THIS_MODULE);
 361
 362         atomic_inc(&ignore_console_lock_warning);
 363 }
 364
 365 static void kgdboc_post_exp_handler(void)
 366 {
 367         atomic_dec(&ignore_console_lock_warning);
 368
 369         /* decrement the module count when the debugger detaches */
 370         if (!kgdb_connected)
 371                 module_put(THIS_MODULE);
 372         if (kgdboc_use_kms && dbg_restore_graphics) {
 373                 dbg_restore_graphics = 0;
 374                 con_debug_leave();
 375         }
 376         kgdboc_restore_input();
 377 }
 378
 379 static struct kgdb_io kgdboc_io_ops = {
 380         .name                   = "kgdboc",
 381         .read_char              = kgdboc_get_char,
 382         .write_char             = kgdboc_put_char,
 383         .pre_exception          = kgdboc_pre_exp_handler,
 384         .post_exception         = kgdboc_post_exp_handler,
 385 };
 386
 387 #ifdef CONFIG_KGDB_SERIAL_CONSOLE
 388 static int kgdboc_option_setup(char *opt)
 389 {
 390         if (!opt) {
 391                 pr_err("config string not provided\n");
 392                 return -EINVAL;
 393         }
 394
 395         if (strlen(opt) >= MAX_CONFIG_LEN) {
 396                 pr_err("config string too long\n");
 397                 return -ENOSPC;
 398         }
 399         strcpy(config, opt);
 400
 401         return 0;
 402 }
 403
 404 __setup("kgdboc=", kgdboc_option_setup);
 405
 406
 407 /* This is only available if kgdboc is a built in for early debugging */
 408 static int __init kgdboc_early_init(char *opt)
 409 {
 410         kgdboc_option_setup(opt);
 411         configure_kgdboc();
 412         return 0;
 413 }
 414
 415 early_param("ekgdboc", kgdboc_early_init);
 416 #endif /* CONFIG_KGDB_SERIAL_CONSOLE */
 417
 418 module_init(init_kgdboc);
 419 module_exit(exit_kgdboc);
 420 module_param_call(kgdboc, param_set_kgdboc_var, param_get_string, &kps, 0644);
 421 MODULE_PARM_DESC(kgdboc, "<serial_device>[,baud]");
 422 MODULE_DESCRIPTION("KGDB Console TTY Driver");
 423 MODULE_LICENSE("GPL");