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