kdb: Improve console handling
Subsystems (3)
v4 cover kdb: Improve console handling
This patch-set is aimed to improve console handling especially when kdb operates in NMI context.
Brief description of enhancements:
- Add status check for console prior to invoking corresponding handler.
- Fixup to avoid possible deadlock in NMI context due to usage of locks in the console handlers.
- Prefer usage of polling I/O driver mode (lockless APIs) over invocation of console handlers.
Changes in v4:
- Use dbg_io_ops->write_char() directly instead of passing it as a function pointer.
- Use "struct console" rather than "struct tty_driver" for comparison.
- Make commit descriptions and comments more informative.
- Add review tag for patch #2.
Changes in v3:
- Split patch to have separate patch for console status check.
- New patch to re-factor kdb message emit code.
- New patch to prefer polling I/O over console mode.
- Add code comments to describe usage of oops_in_progress.
Changes in v2:
- Use oops_in_progress directly instead of bust_spinlocks().
Sumit Garg (4):
kdb: Re-factor kdb_printf() message write code
kdb: Check status of console prior to invoking handlers
kdb: Make kdb_printf() console handling more robust
kdb: Switch to use safer dbg_io_ops over console APIs
drivers/tty/serial/kgdb_nmi.c | 2 +- drivers/tty/serial/kgdboc.c | 4 +-- drivers/usb/early/ehci-dbgp.c | 3 +- include/linux/kgdb.h | 5 ++- kernel/debug/kdb/kdb_io.c | 76 ++++++++++++++++++++++++++----------------- 5 files changed, 54 insertions(+), 36 deletions(-)
Signature · 1 line
2.7.4
PATCH v4 1/4 kdb: Re-factor kdb_printf() message write code
Re-factor kdb_printf() message write code in order to avoid duplication of code and thereby increase readability.
--- kernel/debug/kdb/kdb_io.c | 61 +++++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 29 deletions(-)
kernel/debug/kdb/kdb_io.c +32 -29
@@ -542,6 +542,33 @@ static int kdb_search_string(char *searched, char *searchfor)return 0 ; } +static void kdb_io_write (char *cp,int len) +{ +if (len ==0 ) +return ; + +while (len--) { + dbg_io_ops->write_char (*cp); + cp++; + } +} + +static void kdb_msg_write (char *msg,int msg_len) +{ +struct console *c; + +if (msg_len ==0 ) +return ; + +if (dbg_io_ops && !dbg_io_ops->is_console) +kdb_io_write (msg, msg_len); + +for_each_console (c) { + c->write (c, msg, msg_len); +touch_nmi_watchdog (); + } +} +int vkdb_printf (enum kdb_msgsrc src,const char *fmt,va_list ap) {int diag;
@@ -553,7 +580,6 @@ int vkdb_printf(enum kdb_msgsrc src, const char *fmt, va_list ap)int this_cpu, old_cpu;char *cp, *cp2, *cphold =NULL , replaced_byte =' ' ;char *moreprompt ="more> " ; -struct console *c;unsigned long uninitialized_var (flags );/* Serialize kdb_printf if multiple cpus try to write at once.
@@ -687,22 +713,11 @@ int vkdb_printf(enum kdb_msgsrc src, const char *fmt, va_list ap)*/ retlen =strlen (kdb_buffer); cp = (char *)printk_skip_headers (kdb_buffer); -if (!dbg_kdb_mode && kgdb_connected) { +if (!dbg_kdb_mode && kgdb_connected)gdbstub_msg_write (cp, retlen - (cp - kdb_buffer)); - }else { -if (dbg_io_ops && !dbg_io_ops->is_console) { - len = retlen - (cp - kdb_buffer); - cp2 = cp; -while (len--) { - dbg_io_ops->write_char (*cp2); - cp2++; - } - } -for_each_console (c) { - c->write (c, cp, retlen - (cp - kdb_buffer)); -touch_nmi_watchdog (); - } - } +else +kdb_msg_write (cp, retlen - (cp - kdb_buffer)); +if (logging) { saved_loglevel = console_loglevel; console_loglevel =CONSOLE_LOGLEVEL_SILENT ;
@@ -751,19 +766,7 @@ int vkdb_printf(enum kdb_msgsrc src, const char *fmt, va_list ap) moreprompt ="more> " ;kdb_input_flush (); - -if (dbg_io_ops && !dbg_io_ops->is_console) { - len =strlen (moreprompt); - cp = moreprompt; -while (len--) { - dbg_io_ops->write_char (*cp); - cp++; - } - } -for_each_console (c) { - c->write (c, moreprompt,strlen (moreprompt)); -touch_nmi_watchdog (); - } +kdb_msg_write (moreprompt,strlen (moreprompt));if (logging)printk ("%s" , moreprompt);
Signature · 1 line
2.7.4
Doug Anderson
reviewerRe: [PATCH v4 1/4] kdb: Re-factor kdb_printf() message write code
Hi,
Quoted 14 lines · Sumit Garg
Re-factor
kdb_printf()message write code in order to avoid duplication of code and thereby increase readability.Signed-off-by Sumit Garg <[email protected]>--- kernel/debug/kdb/kdb_io.c | 61 +++++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 29 deletions(-)kernel/debug/kdb/kdb_io.c +0
-0
kernel/debug/kdb/kdb_io.c static int kdb_search_string(char *searched, char *searchfor) · line 545
Quoted 4 lines
kernel/debug/kdb/kdb_io.c +1
-0@@ -542,6 +542,33 @@ static int kdb_search_string(char *searched, char *searchfor)return 0 ; } +static void kdb_io_write (char *cp,int len)
nit: "const char *" just to make it obvious that we don't modify the string?
kernel/debug/kdb/kdb_io.c static int kdb_search_string(char *searched, char *searchfor) · line 548
Quoted 3 lines
kernel/debug/kdb/kdb_io.c +3
-0+{ +if (len ==0 ) +return ;
Remove the above check. It's double-overkill. Not only did you just check in kdb_msg_write() but also the while loop below will do a "no-op" just fine even without your check.
kernel/debug/kdb/kdb_io.c static int kdb_search_string(char *searched, char *searchfor) · line 556
Quoted 8 lines
kernel/debug/kdb/kdb_io.c +8
-0+ +while (len--) { + dbg_io_ops->write_char (*cp); + cp++; + } +} + +static void kdb_msg_write (char *msg,int msg_len)
nit: "const char *" just to make it obvious that we don't modify the string?
Other than those small things, this looks nice to me. Feel free to add my Reviewed-by tag once small things are fixed.
-Doug
Re: [PATCH v4 1/4] kdb: Re-factor kdb_printf() message write code
Quoted 26 lines · Doug Anderson
Hi,
Quoted 14 lines · Sumit Garg
Re-factor
kdb_printf()message write code in order to avoid duplication of code and thereby increase readability.Signed-off-by Sumit Garg <[email protected]>--- kernel/debug/kdb/kdb_io.c | 61 +++++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 29 deletions(-)kernel/debug/kdb/kdb_io.c +0
-0kernel/debug/kdb/kdb_io.c static int kdb_search_string(char *searched, char *searchfor) · line 545
Quoted 4 lines
kernel/debug/kdb/kdb_io.c +1
-0@@ -542,6 +542,33 @@ static int kdb_search_string(char *searched, char *searchfor)return 0 ; } +static void kdb_io_write (char *cp,int len)nit: "const char *" just to make it obvious that we don't modify the string?
Quoted 8 lines
kernel/debug/kdb/kdb_io.c static int kdb_search_string(char *searched, char *searchfor) · line 548
Quoted 3 lines
kernel/debug/kdb/kdb_io.c +3
-0+{ +if (len ==0 ) +return ;Remove the above check. It's double-overkill. Not only did you just check in
kdb_msg_write()but also the while loop below will do a "no-op" just fine even without your check.
I will get rid of kdb_io_write() as per Daniel's comment on patch #4.
Quoted 12 lines
kernel/debug/kdb/kdb_io.c static int kdb_search_string(char *searched, char *searchfor) · line 556
Quoted 9 lines
kernel/debug/kdb/kdb_io.c +8
-0+ +while (len--) { + dbg_io_ops->write_char (*cp); + cp++; + } +} + +static void kdb_msg_write (char *msg,int msg_len)nit: "const char *" just to make it obvious that we don't modify the string?
Okay.
Quoted 4 lines
Other than those small things, this looks nice to me. Feel free to add my Reviewed-by tag once small things are fixed.
Thanks.
-Sumit
Quoted 2 lines
-Doug
PATCH v4 2/4 kdb: Check status of console prior to invoking handlers
In reply to Sumit GargCheck if a console is enabled prior to invoking corresponding write handler.
--- kernel/debug/kdb/kdb_io.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/debug/kdb/kdb_io.c +2 -0
@@ -564,6 +564,8 @@ static void kdb_msg_write(char *msg, int msg_len)kdb_io_write (msg, msg_len);for_each_console (c) { +if (!(c->flags &CON_ENABLED )) +continue ; c->write (c, msg, msg_len);touch_nmi_watchdog (); }
Signature · 1 line
2.7.4
Re: [PATCH v4 2/4] kdb: Check status of console prior to invoking handlers
Hi,
Quoted 10 lines · Sumit Garg
Check if a console is enabled prior to invoking corresponding write handler.
Suggested-by Sergey Senozhatsky <[email protected]>Signed-off-by Sumit Garg <[email protected]>Reviewed-by Daniel Thompson <[email protected]>--- kernel/debug/kdb/kdb_io.c | 2 ++ 1 file changed, 2 insertions(+)
PATCH v4 3/4 kdb: Make kdb_printf() console handling more robust
In reply to Sumit GargWhile rounding up CPUs via NMIs, its possible that a rounded up CPU maybe holding a console port lock leading to kgdb master CPU stuck in a deadlock during invocation of console write operations. A similar deadlock could also be possible while using synchronous breakpoints.
So in order to avoid such a deadlock, set oops_in_progress to encourage the console drivers to disregard their internal spin locks: in the current calling context the risk of deadlock is a bigger problem than risks due to re-entering the console driver. We operate directly on oops_in_progress rather than using bust_spinlocks() because the calls bust_spinlocks() makes on exit are not appropriate for this calling context.
--- kernel/debug/kdb/kdb_io.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
kernel/debug/kdb/kdb_io.c +11 -0
@@ -566,7 +566,18 @@ static void kdb_msg_write(char *msg, int msg_len)for_each_console (c) {if (!(c->flags &CON_ENABLED ))continue ; +/* +* Set oops_in_progress to encourage the console drivers to +* disregard their internal spin locks: in the current calling +* context the risk of deadlock is a bigger problem than risks +* due to re-entering the console driver. We operate directly on +* oops_in_progress rather than using bust_spinlocks() because +* the calls bust_spinlocks() makes on exit are not appropriate +* for this calling context. +*/ + ++oops_in_progress; c->write (c, msg, msg_len); + --oops_in_progress;touch_nmi_watchdog (); } }
Signature · 1 line
2.7.4
Re: [PATCH v4 3/4] kdb: Make kdb_printf() console handling more robust
Hi,
Quoted 30 lines · Sumit Garg
While rounding up CPUs via NMIs, its possible that a rounded up CPU maybe holding a console port lock leading to kgdb master CPU stuck in a deadlock during invocation of console write operations. A similar deadlock could also be possible while using synchronous breakpoints.
So in order to avoid such a deadlock, set
oops_in_progressto encourage the console drivers to disregard their internal spin locks: in the current calling context the risk of deadlock is a bigger problem than risks due to re-entering the console driver. We operate directly onoops_in_progressrather than usingbust_spinlocks()because the callsbust_spinlocks()makes on exit are not appropriate for this calling context.Suggested-by Petr Mladek <[email protected]>Signed-off-by Sumit Garg <[email protected]>--- kernel/debug/kdb/kdb_io.c | 11 +++++++++++ 1 file changed, 11 insertions(+)kernel/debug/kdb/kdb_io.c +2
-0@@ -566,7 +566,18 @@ static void kdb_msg_write(char *msg, int msg_len)for_each_console (c) {if (!(c->flags &CON_ENABLED ))continue ; +/* +* Set oops_in_progress to encourage the console drivers to
kernel/debug/kdb/kdb_io.c static void kdb_msg_write(char *msg, int msg_len) · line 580
Quoted 10 lines
kernel/debug/kdb/kdb_io.c +9
-0+* disregard their internal spin locks: in the current calling +* context the risk of deadlock is a bigger problem than risks +* due to re-entering the console driver. We operate directly on +* oops_in_progress rather than using bust_spinlocks() because +* the calls bust_spinlocks() makes on exit are not appropriate +* for this calling context. +*/ + ++oops_in_progress; c->write (c, msg, msg_len); + --oops_in_progress;
This seems sane to me, especially when combined with your next patch that tries really hard not to run this flow. ;-)
PATCH v4 4/4 kdb: Switch to use safer dbg_io_ops over console APIs
In reply to Sumit GargIn kgdb context, calling console handlers aren't safe due to locks used in those handlers which could in turn lead to a deadlock. Although, using oops_in_progress increases the chance to bypass locks in most console handlers but it might not be sufficient enough in case a console uses more locks (VT/TTY is good example).
Currently when a driver provides both polling I/O and a console then kdb will output using the console. We can increase robustness by using the currently active polling I/O driver (which should be lockless) instead of the corresponding console. For several common cases (e.g. an embedded system with a single serial port that is used both for console output and debugger I/O) this will result in no console handler being used.
In order to achieve this we need to reverse the order of preference to use dbg_io_ops (uses polling I/O mode) over console APIs. So we just store "struct console" that represents debugger I/O in dbg_io_ops and while emitting kdb messages, skip console that matches dbg_io_ops console in order to avoid duplicate messages. After this change, "is_console" param becomes redundant and hence removed.
--- drivers/tty/serial/kgdb_nmi.c | 2 +- drivers/tty/serial/kgdboc.c | 4 ++-- drivers/usb/early/ehci-dbgp.c | 3 ++- include/linux/kgdb.h | 5 ++--- kernel/debug/kdb/kdb_io.c | 4 +++- 5 files changed, 10 insertions(+), 8 deletions(-)
drivers/tty/serial/kgdb_nmi.c +1 -1
@@ -50,7 +50,7 @@ static int kgdb_nmi_console_setup(struct console *co, char *options)* I/O utilities that messages sent to the console will automatically * be displayed on the dbg_io. */ - dbg_io_ops->is_console = true; + dbg_io_ops->cons = co;return 0 ; }
drivers/tty/serial/kgdboc.c +2 -2
@@ -153,7 +153,7 @@ static int configure_kgdboc(void) goto noconfig; } - kgdboc_io_ops.is_console =0 ; + kgdboc_io_ops.cons =NULL ; kgdb_tty_driver =NULL ; kgdboc_use_kms =0 ;
@@ -173,7 +173,7 @@ static int configure_kgdboc(void)int idx;if (cons->device && cons->device (cons, &idx) == p && idx == tty_line) { - kgdboc_io_ops.is_console =1 ; + kgdboc_io_ops.cons = cons;break ; } }
drivers/usb/early/ehci-dbgp.c +2 -1
@@ -1058,7 +1058,8 @@ static int __init kgdbdbgp_parse_config(char *str) kgdbdbgp_wait_time =simple_strtoul (ptr, &ptr,10 ); }kgdb_register_io_module (&kgdbdbgp_io_ops); - kgdbdbgp_io_ops.is_console = early_dbgp_console.index !=-1 ; +if (early_dbgp_console.index !=-1 ) + kgdbdbgp_io_ops.cons = early_dbgp_console;return 0 ; }
include/linux/kgdb.h +2 -3
@@ -273,8 +273,7 @@ struct kgdb_arch {* the I/O driver. * @post_exception: Pointer to a function that will do any cleanup work * for the I/O driver. -* @is_console: 1 if the end device is a console 0 if the I/O device is -* not a console +* @cons: valid if the I/O device is a console. */ struct kgdb_io {const char *name;
@@ -284,7 +283,7 @@ struct kgdb_io {int (*init) (void );void (*pre_exception) (void );void (*post_exception) (void ); -int is_console; +struct console *cons; };extern const struct kgdb_arch arch_kgdb_ops;
kernel/debug/kdb/kdb_io.c +3 -1
@@ -560,12 +560,14 @@ static void kdb_msg_write(char *msg, int msg_len)if (msg_len ==0 )return ; -if (dbg_io_ops && !dbg_io_ops->is_console) +if (dbg_io_ops)kdb_io_write (msg, msg_len);for_each_console (c) {if (!(c->flags &CON_ENABLED ))continue ; +if (c == dbg_io_ops->cons) +continue ;/* * Set oops_in_progress to encourage the console drivers to * disregard their internal spin locks: in the current calling
Signature · 1 line
2.7.4
kbuild test robot
build botRe: [PATCH v4 4/4] kdb: Switch to use safer dbg_io_ops over console APIs
I love your patch! Yet something to improve:
Hi Sumit,
I love your patch! Yet something to improve:
[auto build test ERROR on tty/tty-testing]
[also build test ERROR on usb/usb-testing v5.7-rc7 next-20200529] [cannot apply to kgdb/kgdb-next]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/Sumit-Garg/kdb-Improve-console-handling/20200531-075431 base: https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git tty-testing config: x86_64-allyesconfig (attached as .config) compiler: clang version 11.0.0 (https://github.com/llvm/llvm-project 2388a096e7865c043e83ece4e26654bd3d1a20d5)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>, old ones prefixed by <<):
>> drivers/usb/early/ehci-dbgp.c:1062:24: error: assigning to 'struct console *' from incompatible type 'struct console'; take the address with &
kgdbdbgp_io_ops.cons = early_dbgp_console;
^ ~~~~~~~~~~~~~~~~~~
&
1 error generated.
vim +1062 drivers/usb/early/ehci-dbgp.c
1046
1047 static int __init kgdbdbgp_parse_config(char *str)
1048 {
1049 char *ptr;
1050
1051 if (!ehci_debug) {
1052 if (early_dbgp_init(str))
1053 return -1;
1054 }
1055 ptr = strchr(str, ',');
1056 if (ptr) {
1057 ptr++;
1058 kgdbdbgp_wait_time = simple_strtoul(ptr, &ptr, 10);
1059 }
1060 kgdb_register_io_module(&kgdbdbgp_io_ops);
1061 if (early_dbgp_console.index != -1)
> 1062 kgdbdbgp_io_ops.cons = early_dbgp_console;
1063
1064 return 0;
1065 }
1066 early_param("kgdbdbgp", kgdbdbgp_parse_config);
1067
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [PATCH v4 4/4] kdb: Switch to use safer dbg_io_ops over console APIs
Quoted 27 lines · kbuild test robot
Hi Sumit,
I love your patch! Yet something to improve:
[auto build test ERROR on tty/tty-testing]
[also build test ERROR on usb/usb-testing v5.7-rc7 next-20200529] [cannot apply to kgdb/kgdb-next]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]url: https://github.com/0day-ci/linux/commits/Sumit-Garg/kdb-Improve-console-handling/20200531-075431 base: https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git tty-testing config: x86_64-allyesconfig (attached as .config) compiler: clang version 11.0.0 (https://github.com/llvm/llvm-project 2388a096e7865c043e83ece4e26654bd3d1a20d5)reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# installx86_64cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64If you fix the issue, kindly add following tag as appropriate
Reported-by kbuild test robot <[email protected]>
Quoted 8 lines
All errors (new ones prefixed by >>, old ones prefixed by <<):
Quoted 1 line
Quoted 1 line
drivers/usb/early/ehci-dbgp.c:1062:24: error: assigning to 'struct console *' from incompatible type 'struct console'; take the address with &kgdbdbgp_io_ops.cons =
early_dbgp_console;
^ ~~~~~~~~~~~~~~~~~~
&
1 error generated.
Ah, my bad. Will fix it up in the next version.
-Sumit
Quoted 28 lines
vim +1062
drivers/usb/early/ehci-dbgp.c1046
1047 static int__initkgdbdbgp_parse_config(char *str)1048 {
1049 char *ptr;
1050
1051 if (!ehci_debug) {
1052 if (early_dbgp_init(str))
1053 return -1;1054 } 1055 ptr = strchr(str, ','); 1056 if (ptr) { 1057 ptr++; 1058 kgdbdbgp_wait_time = simple_strtoul(ptr, &ptr, 10); 1059 } 1060 kgdb_register_io_module(&kgdbdbgp_io_ops); 1061 if (early_dbgp_console.index != -1)Quoted 1 line
1062 kgdbdbgp_io_ops.cons =
early_dbgp_console;1063
1064 return 0;
1065 }
1066early_param("kgdbdbgp", kgdbdbgp_parse_config); 1067---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [PATCH v4 4/4] kdb: Switch to use safer dbg_io_ops over console APIs
In reply to Sumit GargQuoted 21 lines · Sumit Garg
In kgdb context, calling console handlers aren't safe due to locks used in those handlers which could in turn lead to a deadlock. Although, using
oops_in_progressincreases the chance to bypass locks in most console handlers but it might not be sufficient enough in case a console uses more locks (VT/TTY is good example).Currently when a driver provides both polling I/O and a console then kdb will output using the console. We can increase robustness by using the currently active polling I/O driver (which should be lockless) instead of the corresponding console. For several common cases (e.g. an embedded system with a single serial port that is used both for console output and debugger I/O) this will result in no console handler being used.
In order to achieve this we need to reverse the order of preference to use
dbg_io_ops(uses polling I/O mode) over console APIs. So we just store "struct console" that represents debugger I/O indbg_io_opsand while emitting kdb messages, skip console that matchesdbg_io_opsconsole in order to avoid duplicate messages. After this change, "is_console" param becomes redundant and hence removed.
Quoted 2 lines
Suggested-by Daniel Thompson <[email protected]>Signed-off-by Sumit Garg <[email protected]>
Looking good, only one minor comment left on my side (including the three patches prior).
kernel/debug/kdb/kdb_io.c static void kdb_msg_write(char *msg, int msg_len) · line 564
Quoted 11 lines
kernel/debug/kdb/kdb_io.c +1
-1@@ -560,12 +560,14 @@ static void kdb_msg_write(char *msg, int msg_len)if (msg_len ==0 )return ; -if (dbg_io_ops && !dbg_io_ops->is_console) +if (dbg_io_ops)kdb_io_write (msg, msg_len);
Since this now slots on so cleanly and there are not multiple calls to kdb_io_write() then I think perhaps factoring this out into its own function (in patch 1) is no long necessary. The character write loop can go directly into this function.
Daniel.
Re: [PATCH v4 4/4] kdb: Switch to use safer dbg_io_ops over console APIs
Quoted 37 lines · Daniel Thompson
Quoted 21 lines · Sumit Garg
In kgdb context, calling console handlers aren't safe due to locks used in those handlers which could in turn lead to a deadlock. Although, using
oops_in_progressincreases the chance to bypass locks in most console handlers but it might not be sufficient enough in case a console uses more locks (VT/TTY is good example).Currently when a driver provides both polling I/O and a console then kdb will output using the console. We can increase robustness by using the currently active polling I/O driver (which should be lockless) instead of the corresponding console. For several common cases (e.g. an embedded system with a single serial port that is used both for console output and debugger I/O) this will result in no console handler being used.
In order to achieve this we need to reverse the order of preference to use
dbg_io_ops(uses polling I/O mode) over console APIs. So we just store "struct console" that represents debugger I/O indbg_io_opsand while emitting kdb messages, skip console that matchesdbg_io_opsconsole in order to avoid duplicate messages. After this change, "is_console" param becomes redundant and hence removed.Quoted 2 lines
Suggested-by Daniel Thompson <[email protected]>Signed-off-by Sumit Garg <[email protected]>Looking good, only one minor comment left on my side (including the three patches prior).
Quoted 8 lines
kernel/debug/kdb/kdb_io.c +0
-0@@ -560,12 +560,14 @@ static void kdb_msg_write(char *msg, int msg_len)if (msg_len ==0 )return ;
Quoted 9 lines
kernel/debug/kdb/kdb_io.c static void kdb_msg_write(char *msg, int msg_len) · line 564
Quoted 3 lines
kernel/debug/kdb/kdb_io.c +1
-1-if (dbg_io_ops && !dbg_io_ops->is_console) +if (dbg_io_ops)kdb_io_write (msg, msg_len);Since this now slots on so cleanly and there are not multiple calls to
kdb_io_write()then I think perhaps factoring this out into its own function (in patch 1) is no long necessary. The character write loop can go directly into this function.
Okay, will update it in the next version.
-Sumit
Quoted 2 lines
Daniel.
Doug Anderson
reviewerRe: [PATCH v4 4/4] kdb: Switch to use safer dbg_io_ops over console APIs
In reply to Sumit GargHi,
Quoted 22 lines · Sumit Garg
In kgdb context, calling console handlers aren't safe due to locks used in those handlers which could in turn lead to a deadlock. Although, using
oops_in_progressincreases the chance to bypass locks in most console handlers but it might not be sufficient enough in case a console uses more locks (VT/TTY is good example).Currently when a driver provides both polling I/O and a console then kdb will output using the console. We can increase robustness by using the currently active polling I/O driver (which should be lockless) instead of the corresponding console. For several common cases (e.g. an embedded system with a single serial port that is used both for console output and debugger I/O) this will result in no console handler being used.
In order to achieve this we need to reverse the order of preference to use
dbg_io_ops(uses polling I/O mode) over console APIs. So we just store "struct console" that represents debugger I/O indbg_io_opsand while emitting kdb messages, skip console that matchesdbg_io_opsconsole in order to avoid duplicate messages. After this change, "is_console" param becomes redundant and hence removed.
Quoted 5 lines
Suggested-by Daniel Thompson <[email protected]>Signed-off-by Sumit Garg <[email protected]>--- drivers/tty/serial/kgdb_nmi.c | 2 +- drivers/tty/serial/kgdboc.c | 4 ++--
I don't think this will compile against the "kgdboc_earlycon" patches that landed, will it? Specifically when I apply your patch I still see "is_console" in:
static struct kgdb_io kgdboc_earlycon_io_ops = {
.name = "kgdboc_earlycon",
.read_char = kgdboc_earlycon_get_char, .write_char = kgdboc_earlycon_put_char, .pre_exception = kgdboc_earlycon_pre_exp_handler, .deinit = kgdboc_earlycon_deinit, .is_console = true,
};
include/linux/kgdb.h struct kgdb_arch { · line 276
Quoted 11 lines
include/linux/kgdb.h +1
-2@@ -273,8 +273,7 @@ struct kgdb_arch {* the I/O driver. * @post_exception: Pointer to a function that will do any cleanup work * for the I/O driver. -* @is_console: 1 if the end device is a console 0 if the I/O device is -* not a console +* @cons: valid if the I/O device is a console.
optional nit: add "; else NULL"
Other than that this looks great. Feel free to add my Reviewed-by:
tag once you've fixed the error that the bot found and resolved with kgdb_earlycon.
-Doug
Re: [PATCH v4 4/4] kdb: Switch to use safer dbg_io_ops over console APIs
Quoted 32 lines · Doug Anderson
Hi,
Quoted 22 lines · Sumit Garg
In kgdb context, calling console handlers aren't safe due to locks used in those handlers which could in turn lead to a deadlock. Although, using
oops_in_progressincreases the chance to bypass locks in most console handlers but it might not be sufficient enough in case a console uses more locks (VT/TTY is good example).Currently when a driver provides both polling I/O and a console then kdb will output using the console. We can increase robustness by using the currently active polling I/O driver (which should be lockless) instead of the corresponding console. For several common cases (e.g. an embedded system with a single serial port that is used both for console output and debugger I/O) this will result in no console handler being used.
In order to achieve this we need to reverse the order of preference to use
dbg_io_ops(uses polling I/O mode) over console APIs. So we just store "struct console" that represents debugger I/O indbg_io_opsand while emitting kdb messages, skip console that matchesdbg_io_opsconsole in order to avoid duplicate messages. After this change, "is_console" param becomes redundant and hence removed.Quoted 5 lines
Suggested-by Daniel Thompson <[email protected]>Signed-off-by Sumit Garg <[email protected]>--- drivers/tty/serial/kgdb_nmi.c | 2 +- drivers/tty/serial/kgdboc.c | 4 ++--
Quoted 3 lines
I don't think this will compile against the "
kgdboc_earlycon" patches that landed, will it? Specifically when I apply your patch I still see "is_console" in:
Agree will fix this and rebase this patch-set onto Daniel's tree.
Quoted 11 lines
static struct
kgdb_iokgdboc_earlycon_io_ops= {
.name = "kgdboc_earlycon",
.read_char =kgdboc_earlycon_get_char, .write_char =kgdboc_earlycon_put_char, .pre_exception =kgdboc_earlycon_pre_exp_handler, .deinit =kgdboc_earlycon_deinit, .is_console = true,
};
Quoted 14 lines
include/linux/kgdb.h struct kgdb_arch { · line 276
Quoted 11 lines
include/linux/kgdb.h +1
-2@@ -273,8 +273,7 @@ struct kgdb_arch {* the I/O driver. * @post_exception: Pointer to a function that will do any cleanup work * for the I/O driver. -* @is_console: 1 if the end device is a console 0 if the I/O device is -* not a console +* @cons: valid if the I/O device is a console. optional nit: add "; else NULL"
Okay.
Quoted 5 lines
Other than that this looks great. Feel free to add my Reviewed-by:
tag once you've fixed the error that the bot found and resolved withkgdb_earlycon.
Thanks.
-Sumit
Quoted 2 lines
-Doug