9:49 a.m.
This patchset is a rebase/merged version of the following 3 patchsets:
1): [PATCH v10 0/5] Improve stack unwind on ppc64 [1]
2): [PATCH 0/5] x86_64 gdb stack unwinding support [2]
3): Clean up on top of one-thread-v2 [3]
A complete description of gdb stack unwinding support for crash can be
found in [1].
This patchset can be divided into the following 3 parts:
1) part1: preparations before stack unwinding support, some
bugs/regressions found when drafting this patchset.
2) part2: common part for all CPU archs, mainly dealing with
crash_target.c/gdb_interface.c files, in order to
support different archs.
3) part3: arch specific, for each ppc64/x86_64/arm64/vmware
stack unwinding support.
=== part 3
arm64: Add gdb stack unwinding support
vmware_guestdump: Various format versions support
x86_64: Add gdb stack unwinding support
ppc64: correct gdb passthroughs by implementing machdep->get_current_task_reg
=== part 2
Conditionally output gdb stack unwinding stop reasons
Stop stack unwinding at non-kernel address
Print task pid/command instead of CPU index
Rename get_cpu_reg to get_current_task_reg
Let crash change gdb context
Leave only one gdb thread for crash
Remove 'frame' from prohibited commands list
=== part 1
Fix gdb_interface: restore gdb's output streams at end of gdb_interface
x86_64: Fix invalid input "=>" for bt command
Fix cpumask_t recursive dependence issue
Fix the regression of cpumask_t for xen hyper
===
v7 -> v6:
1) Reorganise the patchset, re-divided them into 3 part against the
previous 2 parts.
2) Re-dealed with the cpumask_t part, which solved the comment No.4
pointed out by lianbo in [4].
3) Add conditional output for the failing message of gdb stack unwinding.
see [PATCH 11/15] Conditionally output gdb stack unwinding stop reasons
4) Redraft the commit messages, updated some outdated info.
5) Merged "Let crash change gdb context" and "set_context(): check if
context is already current" into one.
[4]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01067.html
v6 -> v5:
1) Refactor patch 4 & 9, which changed the function signature of struct
get_cpu_reg/get_current_task_reg, and let each patch compile with no
error when added on.
2) Rebased the patchset on top of latest upstream:
("79b93ecb2e72ec Fix a "Bus error" issue caused by 'crash
--osrelease' or
crash loading")
v5 -> v4:
1) Plenty of code refactoring based on Lianbo's comments on v4.
2) Removed the magic number when dealing with regs bitmap, see [6].
3) Rebased the patchset on top of latest upstream:
("1c6da3eaff8207 arm64: Fix bt command show wrong stacktrace on ramdump
source")
v4 -> v3:
Fixed the author issue in [PATCH v3 06/16] Fix gdb_interface: restore gdb's
output streams at end of gdb_interface.
v3 -> v2:
1) Updated CC list as pointed out in [4]
2) Compiling issues as in [5]
v2 -> v1:
1) Added the patch: x86_64: Fix invalid input "=>" for bt command,
thanks for Kazu's testing.
2) Modify the patch: x86_64: Add gdb stack unwinding support, added the
pcp_save, spp_save and sp, for restoring the value in match of the original
code logic.
[1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00469.html
[2]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00488.html
[3]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00554.html
[4]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00681.html
[5]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00715.html
[6]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00819.html
Aditya Gupta (3):
Fix gdb_interface: restore gdb's output streams at end of
gdb_interface
Remove 'frame' from prohibited commands list
ppc64: correct gdb passthroughs by implementing
machdep->get_current_task_reg
Alexey Makhalov (1):
vmware_guestdump: Various format versions support
Tao Liu (11):
Fix the regression of cpumask_t for xen hyper
Fix cpumask_t recursive dependence issue
x86_64: Fix invalid input "=>" for bt command
Leave only one gdb thread for crash
Let crash change gdb context
Rename get_cpu_reg to get_current_task_reg
Print task pid/command instead of CPU index
Stop stack unwinding at non-kernel address
Conditionally output gdb stack unwinding stop reasons
x86_64: Add gdb stack unwinding support
arm64: Add gdb stack unwinding support
arm64.c | 120 +++++++++++++++--
crash_target.c | 71 ++++++----
defs.h | 194 ++++++++++++++++++++++++++-
gdb-10.2.patch | 96 ++++++++++++++
gdb_interface.c | 39 ++----
kernel.c | 63 +++++++--
ppc64.c | 174 +++++++++++++++++++++++-
symbols.c | 15 +++
task.c | 34 +++--
tools.c | 16 ++-
unwind_x86_64.h | 4 -
vmware_guestdump.c | 321 +++++++++++++++++++++++++++++++-------------
x86_64.c | 323 ++++++++++++++++++++++++++++++++++++++++-----
13 files changed, 1247 insertions(+), 223 deletions(-)
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 01/15] Fix the regression of cpumask_t for xen hyper
There is a regression been found for xen hyper due to the commit:
f615f8fab7bf ("Fix "irq -a" exceeding the memory range issue").
The reason is for xen hyper, kt->cpu is not initialized due to
kernel_init() won't be called. So 0 would be assigned to cpulen and
fails the GETBUF().
Before:
crash> bt -c 2
bt: zero-size memory allocation! (called from 51f168)
After:
crash> bt -c 2
PCPU: 0 VCPU: ffff8300001b8080
#0 [ffff8300001bfe00] machine_crash_kexec at ffff83000010de72
#1 [ffff8300001bfe10] do_kexec_op at ffff83000010e3cb
#2 [ffff8300001bfe50] do_console_io at ffff83000011aff4
#3 [ffff8300001bfe90] mod_l1_entry at ffff830000129045
#4 [ffff8300001bfea0] toggle_guest_mode at ffff8300001641bf
#5 [ffff8300001bfeb0] do_iret at ffff830000164888
#6 [ffff8300001bff20] syscall_enter at ffff8300001633d2
Since xen hyper will initialize its own cpumask_t, this patch will reuse
it for XEN_HYPER_MODE. In addition, this patch won't modify the similar
code hunk in generic_get_irq_affinity(), because for xen, there is no
"irq" cmd, so the regression won't be triggered.
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
tools.c | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/tools.c b/tools.c
index 2b78b95..dec6e5b 100644
--- a/tools.c
+++ b/tools.c
@@ -16,6 +16,7 @@
*/
#include "defs.h"
+#include "xen_hyper_defs.h"
#include <ctype.h>
#ifdef VALGRIND
@@ -6720,6 +6721,11 @@ get_cpumask_buf(void)
{
int cpulen, len_cpumask;
+#ifdef XEN_HYPERVISOR_ARCH
+ if (XEN_HYPER_MODE() && XEN_HYPER_VALID_SIZE(cpumask_t))
+ return (ulong *)GETBUF(XEN_HYPER_SIZE(cpumask_t));
+#endif
+
cpulen = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) * sizeof(ulong);
len_cpumask = STRUCT_SIZE("cpumask_t");
if (len_cpumask > 0)
--
2.40.1
12:27 p.m.
New subject: [PATCH v7 01/15] Fix the regression of cpumask_t for xen hyper
Hi Tao,
Is this a separate independent patch or related to this series ?
- Aditya Gupta
On 04/09/24 13:19, Tao Liu wrote:
> There is a regression been found for xen hyper due to the commit:
> f615f8fab7bf ("Fix "irq -a" exceeding the memory range issue").
>
> The reason is for xen hyper, kt->cpu is not initialized due to
> kernel_init() won't be called. So 0 would be assigned to cpulen and
> fails the GETBUF().
>
> Before:
> crash> bt -c 2
> bt: zero-size memory allocation! (called from 51f168)
>
> After:
> crash> bt -c 2
> PCPU: 0 VCPU: ffff8300001b8080
> #0 [ffff8300001bfe00] machine_crash_kexec at ffff83000010de72
> #1 [ffff8300001bfe10] do_kexec_op at ffff83000010e3cb
> #2 [ffff8300001bfe50] do_console_io at ffff83000011aff4
> #3 [ffff8300001bfe90] mod_l1_entry at ffff830000129045
> #4 [ffff8300001bfea0] toggle_guest_mode at ffff8300001641bf
> #5 [ffff8300001bfeb0] do_iret at ffff830000164888
> #6 [ffff8300001bff20] syscall_enter at ffff8300001633d2
>
> Since xen hyper will initialize its own cpumask_t, this patch will reuse
> it for XEN_HYPER_MODE. In addition, this patch won't modify the similar
> code hunk in generic_get_irq_affinity(), because for xen, there is no
> "irq" cmd, so the regression won't be triggered.
>
> Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
> Cc: Hari Bathini <hbathini(a)linux.ibm.com>
> Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
> Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
> Cc: Lianbo Jiang <lijiang(a)redhat.com>
> Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
> Cc: Tao Liu <ltao(a)redhat.com>
> Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
> Cc: Aditya Gupta <adityag(a)linux.ibm.com>
> Signed-off-by: Tao Liu <ltao(a)redhat.com>
> ---
> tools.c | 6 ++++++
> 1 file changed, 6 insertions(+)
>
> diff --git a/tools.c b/tools.c
> index 2b78b95..dec6e5b 100644
> --- a/tools.c
> +++ b/tools.c
> @@ -16,6 +16,7 @@
> */
>
> #include "defs.h"
> +#include "xen_hyper_defs.h"
> #include <ctype.h>
>
> #ifdef VALGRIND
> @@ -6720,6 +6721,11 @@ get_cpumask_buf(void)
> {
> int cpulen, len_cpumask;
>
> +#ifdef XEN_HYPERVISOR_ARCH
> + if (XEN_HYPER_MODE() && XEN_HYPER_VALID_SIZE(cpumask_t))
> + return (ulong *)GETBUF(XEN_HYPER_SIZE(cpumask_t));
> +#endif
> +
> cpulen = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) * sizeof(ulong);
> len_cpumask = STRUCT_SIZE("cpumask_t");
> if (len_cpumask > 0)
12:10 a.m.
New subject: [PATCH v7 01/15] Fix the regression of cpumask_t for xen hyper
Hi Aditya,
On Wed, Sep 4, 2024 at 10:27 PM Aditya Gupta <adityag(a)linux.ibm.com> wrote:
Hi Tao,
Is this a separate independent patch or related to this series ?
This is an independent patch, but discovered when doing a regression
test against the stack unwinding patchset. Since we have done the
cpumask_t modification in [PATCH v6 10/14], the modification will
continue in v7 as well. So I posted it with v7 together.
Lianbo suggested that I separate some "less strongly connected with
stack unwinding" patches from v7, which formed the part 1 as mentioned
in [1]. Part 1 can be merged prior to the rest of part 2 & 3. So I
think part 1 is also suitable for the cpumask_t regression patch.
[1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01079.html
Thanks,
Tao Liu
- Aditya Gupta
On 04/09/24 13:19, Tao Liu wrote:
> There is a regression been found for xen hyper due to the commit:
> f615f8fab7bf ("Fix "irq -a" exceeding the memory range issue").
>
> The reason is for xen hyper, kt->cpu is not initialized due to
> kernel_init() won't be called. So 0 would be assigned to cpulen and
> fails the GETBUF().
>
> Before:
> crash> bt -c 2
> bt: zero-size memory allocation! (called from 51f168)
>
> After:
> crash> bt -c 2
> PCPU: 0 VCPU: ffff8300001b8080
> #0 [ffff8300001bfe00] machine_crash_kexec at ffff83000010de72
> #1 [ffff8300001bfe10] do_kexec_op at ffff83000010e3cb
> #2 [ffff8300001bfe50] do_console_io at ffff83000011aff4
> #3 [ffff8300001bfe90] mod_l1_entry at ffff830000129045
> #4 [ffff8300001bfea0] toggle_guest_mode at ffff8300001641bf
> #5 [ffff8300001bfeb0] do_iret at ffff830000164888
> #6 [ffff8300001bff20] syscall_enter at ffff8300001633d2
>
> Since xen hyper will initialize its own cpumask_t, this patch will reuse
> it for XEN_HYPER_MODE. In addition, this patch won't modify the similar
> code hunk in generic_get_irq_affinity(), because for xen, there is no
> "irq" cmd, so the regression won't be triggered.
>
> Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
> Cc: Hari Bathini <hbathini(a)linux.ibm.com>
> Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
> Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
> Cc: Lianbo Jiang <lijiang(a)redhat.com>
> Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
> Cc: Tao Liu <ltao(a)redhat.com>
> Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
> Cc: Aditya Gupta <adityag(a)linux.ibm.com>
> Signed-off-by: Tao Liu <ltao(a)redhat.com>
> ---
> tools.c | 6 ++++++
> 1 file changed, 6 insertions(+)
>
> diff --git a/tools.c b/tools.c
> index 2b78b95..dec6e5b 100644
> --- a/tools.c
> +++ b/tools.c
> @@ -16,6 +16,7 @@
> */
>
> #include "defs.h"
> +#include "xen_hyper_defs.h"
> #include <ctype.h>
>
> #ifdef VALGRIND
> @@ -6720,6 +6721,11 @@ get_cpumask_buf(void)
> {
> int cpulen, len_cpumask;
>
> +#ifdef XEN_HYPERVISOR_ARCH
> + if (XEN_HYPER_MODE() && XEN_HYPER_VALID_SIZE(cpumask_t))
> + return (ulong *)GETBUF(XEN_HYPER_SIZE(cpumask_t));
> +#endif
> +
> cpulen = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) * sizeof(ulong);
> len_cpumask = STRUCT_SIZE("cpumask_t");
> if (len_cpumask > 0)
9:48 a.m.
New subject: [PATCH v7 01/15] Fix the regression of cpumask_t for xen hyper
Hi Tao,
On 05/09/24 03:40, Tao Liu wrote:
Hi Aditya,
On Wed, Sep 4, 2024 at 10:27 PM Aditya Gupta <adityag(a)linux.ibm.com> wrote:
> Hi Tao,
>
> Is this a separate independent patch or related to this series ?
>
This is an independent patch, but discovered when doing a regression
test against the stack unwinding patchset. Since we have done the
cpumask_t modification in [PATCH v6 10/14], the modification will
continue in v7 as well. So I posted it with v7 together.
Lianbo suggested that I separate some "less strongly connected with
stack unwinding" patches from v7, which formed the part 1 as mentioned
in [1]. Part 1 can be merged prior to the rest of part 2 & 3. So I
think part 1 is also suitable for the cpumask_t regression patch.
Yes, I agree. We can move 'Fix gdb_interface' patch also as independent.
It originally was required for the patch series to work, since 'info
threads' used to break, but now that can go independently.
Thanks,
Aditya Gupta
> [1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01079.html
>
> Thanks,
> Tao Liu
>
>> - Aditya Gupta
>>
>>
>> On 04/09/24 13:19, Tao Liu wrote:
>>> There is a regression been found for xen hyper due to the commit:
>>> f615f8fab7bf ("Fix "irq -a" exceeding the memory range
issue").
>>>
>>> The reason is for xen hyper, kt->cpu is not initialized due to
>>> kernel_init() won't be called. So 0 would be assigned to cpulen and
>>> fails the GETBUF().
>>>
>>> Before:
>>> crash> bt -c 2
>>> bt: zero-size memory allocation! (called from 51f168)
>>>
>>> After:
>>> crash> bt -c 2
>>> PCPU: 0 VCPU: ffff8300001b8080
>>> #0 [ffff8300001bfe00] machine_crash_kexec at ffff83000010de72
>>> #1 [ffff8300001bfe10] do_kexec_op at ffff83000010e3cb
>>> #2 [ffff8300001bfe50] do_console_io at ffff83000011aff4
>>> #3 [ffff8300001bfe90] mod_l1_entry at ffff830000129045
>>> #4 [ffff8300001bfea0] toggle_guest_mode at ffff8300001641bf
>>> #5 [ffff8300001bfeb0] do_iret at ffff830000164888
>>> #6 [ffff8300001bff20] syscall_enter at ffff8300001633d2
>>>
>>> Since xen hyper will initialize its own cpumask_t, this patch will reuse
>>> it for XEN_HYPER_MODE. In addition, this patch won't modify the similar
>>> code hunk in generic_get_irq_affinity(), because for xen, there is no
>>> "irq" cmd, so the regression won't be triggered.
>>>
>>> Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
>>> Cc: Hari Bathini <hbathini(a)linux.ibm.com>
>>> Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
>>> Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
>>> Cc: Lianbo Jiang <lijiang(a)redhat.com>
>>> Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
>>> Cc: Tao Liu <ltao(a)redhat.com>
>>> Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
>>> Cc: Aditya Gupta <adityag(a)linux.ibm.com>
>>> Signed-off-by: Tao Liu <ltao(a)redhat.com>
>>> ---
>>> tools.c | 6 ++++++
>>> 1 file changed, 6 insertions(+)
>>>
>>> diff --git a/tools.c b/tools.c
>>> index 2b78b95..dec6e5b 100644
>>> --- a/tools.c
>>> +++ b/tools.c
>>> @@ -16,6 +16,7 @@
>>> */
>>>
>>> #include "defs.h"
>>> +#include "xen_hyper_defs.h"
>>> #include <ctype.h>
>>>
>>> #ifdef VALGRIND
>>> @@ -6720,6 +6721,11 @@ get_cpumask_buf(void)
>>> {
>>> int cpulen, len_cpumask;
>>>
>>> +#ifdef XEN_HYPERVISOR_ARCH
>>> + if (XEN_HYPER_MODE() && XEN_HYPER_VALID_SIZE(cpumask_t))
>>> + return (ulong *)GETBUF(XEN_HYPER_SIZE(cpumask_t));
>>> +#endif
>>> +
>>> cpulen = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) * sizeof(ulong);
>>> len_cpumask = STRUCT_SIZE("cpumask_t");
>>> if (len_cpumask > 0)
11:23 p.m.
New subject: [PATCH v7 01/15] Fix the regression of cpumask_t for xen hyper
Hi Aditya,
On Thu, Sep 5, 2024 at 7:49 PM Aditya Gupta <adityag(a)linux.ibm.com> wrote:
Hi Tao,
On 05/09/24 03:40, Tao Liu wrote:
> Hi Aditya,
>
> On Wed, Sep 4, 2024 at 10:27 PM Aditya Gupta <adityag(a)linux.ibm.com> wrote:
>> Hi Tao,
>>
>> Is this a separate independent patch or related to this series ?
>>
> This is an independent patch, but discovered when doing a regression
> test against the stack unwinding patchset. Since we have done the
> cpumask_t modification in [PATCH v6 10/14], the modification will
> continue in v7 as well. So I posted it with v7 together.
>
> Lianbo suggested that I separate some "less strongly connected with
> stack unwinding" patches from v7, which formed the part 1 as mentioned
> in [1]. Part 1 can be merged prior to the rest of part 2 & 3. So I
> think part 1 is also suitable for the cpumask_t regression patch.
Yes, I agree. We can move 'Fix gdb_interface' patch also as independent.
It originally was required for the patch series to work, since 'info
threads' used to break, but now that can go independently.
Thanks for your suggestion. Yes, the 'Fix gdb_interface' patch is
already in part 1 which can be merged prior. Let's wait for Lianbo's
comments for this.
Thanks,
Tao Liu
Thanks,
Aditya Gupta
> [1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01079.html
>
> Thanks,
> Tao Liu
>
>> - Aditya Gupta
>>
>>
>> On 04/09/24 13:19, Tao Liu wrote:
>>> There is a regression been found for xen hyper due to the commit:
>>> f615f8fab7bf ("Fix "irq -a" exceeding the memory range
issue").
>>>
>>> The reason is for xen hyper, kt->cpu is not initialized due to
>>> kernel_init() won't be called. So 0 would be assigned to cpulen and
>>> fails the GETBUF().
>>>
>>> Before:
>>> crash> bt -c 2
>>> bt: zero-size memory allocation! (called from 51f168)
>>>
>>> After:
>>> crash> bt -c 2
>>> PCPU: 0 VCPU: ffff8300001b8080
>>> #0 [ffff8300001bfe00] machine_crash_kexec at ffff83000010de72
>>> #1 [ffff8300001bfe10] do_kexec_op at ffff83000010e3cb
>>> #2 [ffff8300001bfe50] do_console_io at ffff83000011aff4
>>> #3 [ffff8300001bfe90] mod_l1_entry at ffff830000129045
>>> #4 [ffff8300001bfea0] toggle_guest_mode at ffff8300001641bf
>>> #5 [ffff8300001bfeb0] do_iret at ffff830000164888
>>> #6 [ffff8300001bff20] syscall_enter at ffff8300001633d2
>>>
>>> Since xen hyper will initialize its own cpumask_t, this patch will reuse
>>> it for XEN_HYPER_MODE. In addition, this patch won't modify the similar
>>> code hunk in generic_get_irq_affinity(), because for xen, there is no
>>> "irq" cmd, so the regression won't be triggered.
>>>
>>> Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
>>> Cc: Hari Bathini <hbathini(a)linux.ibm.com>
>>> Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
>>> Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
>>> Cc: Lianbo Jiang <lijiang(a)redhat.com>
>>> Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
>>> Cc: Tao Liu <ltao(a)redhat.com>
>>> Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
>>> Cc: Aditya Gupta <adityag(a)linux.ibm.com>
>>> Signed-off-by: Tao Liu <ltao(a)redhat.com>
>>> ---
>>> tools.c | 6 ++++++
>>> 1 file changed, 6 insertions(+)
>>>
>>> diff --git a/tools.c b/tools.c
>>> index 2b78b95..dec6e5b 100644
>>> --- a/tools.c
>>> +++ b/tools.c
>>> @@ -16,6 +16,7 @@
>>> */
>>>
>>> #include "defs.h"
>>> +#include "xen_hyper_defs.h"
>>> #include <ctype.h>
>>>
>>> #ifdef VALGRIND
>>> @@ -6720,6 +6721,11 @@ get_cpumask_buf(void)
>>> {
>>> int cpulen, len_cpumask;
>>>
>>> +#ifdef XEN_HYPERVISOR_ARCH
>>> + if (XEN_HYPER_MODE() && XEN_HYPER_VALID_SIZE(cpumask_t))
>>> + return (ulong *)GETBUF(XEN_HYPER_SIZE(cpumask_t));
>>> +#endif
>>> +
>>> cpulen = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) * sizeof(ulong);
>>> len_cpumask = STRUCT_SIZE("cpumask_t");
>>> if (len_cpumask > 0)
5:11 a.m.
New subject: [PATCH v7 01/15] Fix the regression of cpumask_t for xen hyper
V2 of this patch posted upstream. See
https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01140.html
On Fri, Sep 6, 2024 at 9:23 AM Tao Liu <ltao(a)redhat.com> wrote:
Hi Aditya,
On Thu, Sep 5, 2024 at 7:49 PM Aditya Gupta <adityag(a)linux.ibm.com> wrote:
>
> Hi Tao,
>
> On 05/09/24 03:40, Tao Liu wrote:
> > Hi Aditya,
> >
> > On Wed, Sep 4, 2024 at 10:27 PM Aditya Gupta <adityag(a)linux.ibm.com>
wrote:
> >> Hi Tao,
> >>
> >> Is this a separate independent patch or related to this series ?
> >>
> > This is an independent patch, but discovered when doing a regression
> > test against the stack unwinding patchset. Since we have done the
> > cpumask_t modification in [PATCH v6 10/14], the modification will
> > continue in v7 as well. So I posted it with v7 together.
> >
> > Lianbo suggested that I separate some "less strongly connected with
> > stack unwinding" patches from v7, which formed the part 1 as mentioned
> > in [1]. Part 1 can be merged prior to the rest of part 2 & 3. So I
> > think part 1 is also suitable for the cpumask_t regression patch.
>
> Yes, I agree. We can move 'Fix gdb_interface' patch also as independent.
> It originally was required for the patch series to work, since 'info
> threads' used to break, but now that can go independently.
>
Thanks for your suggestion. Yes, the 'Fix gdb_interface' patch is
already in part 1 which can be merged prior. Let's wait for Lianbo's
comments for this.
Thanks,
Tao Liu
>
> Thanks,
>
> Aditya Gupta
>
> > [1]:
https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01079.html
> >
> > Thanks,
> > Tao Liu
> >
> >> - Aditya Gupta
> >>
> >>
> >> On 04/09/24 13:19, Tao Liu wrote:
> >>> There is a regression been found for xen hyper due to the commit:
> >>> f615f8fab7bf ("Fix "irq -a" exceeding the memory range
issue").
> >>>
> >>> The reason is for xen hyper, kt->cpu is not initialized due to
> >>> kernel_init() won't be called. So 0 would be assigned to cpulen
and
> >>> fails the GETBUF().
> >>>
> >>> Before:
> >>> crash> bt -c 2
> >>> bt: zero-size memory allocation! (called from 51f168)
> >>>
> >>> After:
> >>> crash> bt -c 2
> >>> PCPU: 0 VCPU: ffff8300001b8080
> >>> #0 [ffff8300001bfe00] machine_crash_kexec at ffff83000010de72
> >>> #1 [ffff8300001bfe10] do_kexec_op at ffff83000010e3cb
> >>> #2 [ffff8300001bfe50] do_console_io at ffff83000011aff4
> >>> #3 [ffff8300001bfe90] mod_l1_entry at ffff830000129045
> >>> #4 [ffff8300001bfea0] toggle_guest_mode at ffff8300001641bf
> >>> #5 [ffff8300001bfeb0] do_iret at ffff830000164888
> >>> #6 [ffff8300001bff20] syscall_enter at ffff8300001633d2
> >>>
> >>> Since xen hyper will initialize its own cpumask_t, this patch will
reuse
> >>> it for XEN_HYPER_MODE. In addition, this patch won't modify the
similar
> >>> code hunk in generic_get_irq_affinity(), because for xen, there is no
> >>> "irq" cmd, so the regression won't be triggered.
> >>>
> >>> Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
> >>> Cc: Hari Bathini <hbathini(a)linux.ibm.com>
> >>> Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
> >>> Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
> >>> Cc: Lianbo Jiang <lijiang(a)redhat.com>
> >>> Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
> >>> Cc: Tao Liu <ltao(a)redhat.com>
> >>> Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
> >>> Cc: Aditya Gupta <adityag(a)linux.ibm.com>
> >>> Signed-off-by: Tao Liu <ltao(a)redhat.com>
> >>> ---
> >>> tools.c | 6 ++++++
> >>> 1 file changed, 6 insertions(+)
> >>>
> >>> diff --git a/tools.c b/tools.c
> >>> index 2b78b95..dec6e5b 100644
> >>> --- a/tools.c
> >>> +++ b/tools.c
> >>> @@ -16,6 +16,7 @@
> >>> */
> >>>
> >>> #include "defs.h"
> >>> +#include "xen_hyper_defs.h"
> >>> #include <ctype.h>
> >>>
> >>> #ifdef VALGRIND
> >>> @@ -6720,6 +6721,11 @@ get_cpumask_buf(void)
> >>> {
> >>> int cpulen, len_cpumask;
> >>>
> >>> +#ifdef XEN_HYPERVISOR_ARCH
> >>> + if (XEN_HYPER_MODE() && XEN_HYPER_VALID_SIZE(cpumask_t))
> >>> + return (ulong *)GETBUF(XEN_HYPER_SIZE(cpumask_t));
> >>> +#endif
> >>> +
> >>> cpulen = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) *
sizeof(ulong);
> >>> len_cpumask = STRUCT_SIZE("cpumask_t");
> >>> if (len_cpumask > 0)
>
9:49 a.m.
New subject: [PATCH v7 02/15] Fix cpumask_t recursive dependence issue
There is recursive dependence for cpumask_t and will exhause the stack,
see the following stack trace:
(gdb) bt
...snip...
#61965 0x00000000005de98c in datatype_info (name=name@entry=0xa5b1fd
"cpumask_t", member=member@entry=0x0, dm=dm@entry=0xfffffffffffffffc) at
symbols.c:6694
#61966 0x000000000057e4ea in cpu_map_size ...
#61967 0x000000000058e7bd in get_cpus_online ...
#61968 0x000000000061fa4b in diskdump_get_prstatus_percpu ...
#61969 0x0000000000616d74 in get_netdump_regs_x86_64 ...
#61970 0x0000000000585290 in get_dumpfile_regs ...
#61971 0x00000000005b7a3c in x86_64_get_current_task_reg ...
#61972 0x0000000000650389 in crash_target::fetch_registers ...
#61973 0x00000000008f385a in target_fetch_registers ...
#61974 0x000000000086ecda in regcache::raw_update ...
#61975 regcache::raw_update ...
#61976 0x000000000086ed7a in readable_regcache::raw_read ...
#61977 0x000000000086f063 in readable_regcache::cooked_read_value ...
#61978 0x000000000089c4ee in sentinel_frame_prev_register ...
#61979 0x0000000000786c76 in frame_unwind_register_value ...
#61980 0x0000000000786f18 in frame_register_unwind ...
#61981 0x0000000000787267 in frame_unwind_register ...
#61982 0x00000000007ad9b0 in i386_unwind_pc ...
#61983 0x00000000007866c0 in frame_unwind_pc ...
#61984 0x000000000078679c in get_frame_pc ...
#61985 get_frame_address_in_block ...
#61986 0x0000000000786849 in get_frame_address_in_block_if_available ...
#61987 0x0000000000691466 in get_frame_block ...
#61988 0x00000000008b9430 in get_selected_block ...
#61989 0x000000000084f8f2 in parse_exp_in_context ...
#61990 0x000000000084f9e5 in parse_exp_1 ...
#61991 parse_expression ...
#61992 0x00000000008d44da in gdb_get_datatype ...
#61993 gdb_command_funnel_1 ...
#61994 0x00000000008d48ae in gdb_command_funnel ...
#61995 0x000000000059cc42 in gdb_interface ...
#61996 0x00000000005de98c in datatype_info (name=name@entry=0xa5b1fd
"cpumask_t", member=member@entry=0x0, dm=dm@entry=0xfffffffffffffffc) at
symbols.c:6694
#61997 0x000000000057e4ea in cpu_map_size ...
#61998 0x000000000058e7bd in get_cpus_online () ...
#61999 0x000000000061fa4b in diskdump_get_prstatus_percpu ...
#62000 0x0000000000616d74 in get_netdump_regs_x86_64 ...
#62001 0x0000000000585290 in get_dumpfile_regs ...
#62002 0x00000000005b7a3c in x86_64_get_current_task_reg ...
#62003 0x0000000000650389 in crash_target::fetch_registers ...
The cpumask_t will be recursively evaluated. This patch will
fix the bug.
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
defs.h | 1 +
kernel.c | 19 ++++++++++---------
symbols.c | 1 +
tools.c | 2 +-
4 files changed, 13 insertions(+), 10 deletions(-)
diff --git a/defs.h b/defs.h
index dfbd241..9e0130f 100644
--- a/defs.h
+++ b/defs.h
@@ -2419,6 +2419,7 @@ struct size_table { /* stash of commonly-used sizes */
long module_memory;
long fred_frame;
long vmap_node;
+ long cpumask_t;
};
struct array_table {
diff --git a/kernel.c b/kernel.c
index adb19ad..57b8dce 100644
--- a/kernel.c
+++ b/kernel.c
@@ -157,6 +157,7 @@ kernel_init()
if (!(kt->cpu_flags = (ulong *)calloc(NR_CPUS, sizeof(ulong))))
error(FATAL, "cannot malloc cpu_flags array");
+ STRUCT_SIZE_INIT(cpumask_t, "cpumask_t");
cpu_maps_init();
kt->stext = symbol_value("_stext");
@@ -914,9 +915,9 @@ cpu_map_size(const char *type)
struct gnu_request req;
if (LKCD_KERNTYPES()) {
- if ((len = STRUCT_SIZE("cpumask_t")) < 0)
- error(FATAL, "cannot determine type cpumask_t\n");
- return len;
+ if (INVALID_SIZE(cpumask_t))
+ error(FATAL, "cannot determine type cpumask_t\n");
+ return SIZE(cpumask_t);
}
sprintf(map_symbol, "cpu_%s_map", type);
@@ -926,11 +927,9 @@ cpu_map_size(const char *type)
return len;
}
- len = STRUCT_SIZE("cpumask_t");
- if (len < 0)
+ if (INVALID_SIZE(cpumask_t))
return sizeof(ulong);
- else
- return len;
+ return SIZE(cpumask_t);
}
/*
@@ -953,8 +952,10 @@ cpu_maps_init(void)
{ ACTIVE_MAP, "active" },
};
- if ((len = STRUCT_SIZE("cpumask_t")) < 0)
+ if (INVALID_SIZE(cpumask_t))
len = sizeof(ulong);
+ else
+ len = SIZE(cpumask_t);
buf = GETBUF(len);
@@ -7383,7 +7384,7 @@ generic_get_irq_affinity(int irq)
return;
len = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) * sizeof(ulong);
- len_cpumask = STRUCT_SIZE("cpumask_t");
+ len_cpumask = VALID_SIZE(cpumask_t) ? SIZE(cpumask_t) : 0;
if (len_cpumask > 0)
len = len_cpumask > len ? len : len_cpumask;
diff --git a/symbols.c b/symbols.c
index 69a1fbb..acec109 100644
--- a/symbols.c
+++ b/symbols.c
@@ -12092,6 +12092,7 @@ dump_offset_table(char *spec, ulong makestruct)
fprintf(fp, " maple_node: %ld\n", SIZE(maple_node));
fprintf(fp, " percpu_counter: %ld\n", SIZE(percpu_counter));
+ fprintf(fp, " cpumask_t: %ld\n", SIZE(cpumask_t));
fprintf(fp, "\n array_table:\n");
/*
diff --git a/tools.c b/tools.c
index dec6e5b..8c73d10 100644
--- a/tools.c
+++ b/tools.c
@@ -6727,7 +6727,7 @@ get_cpumask_buf(void)
#endif
cpulen = DIV_ROUND_UP(kt->cpus, BITS_PER_LONG) * sizeof(ulong);
- len_cpumask = STRUCT_SIZE("cpumask_t");
+ len_cpumask = VALID_SIZE(cpumask_t) ? SIZE(cpumask_t) : 0;
if (len_cpumask > 0)
cpulen = len_cpumask > cpulen ? cpulen : len_cpumask;
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 03/15] x86_64: Fix invalid input "=>" for bt command
There may be extra "=>" prefix before gdb disassembly, as a result,
parse_line() will return string "=>" as arglist[0], which will be
converted to number by htol() and fails. E.g.:
crash> gdb x/40i __list_del_entry
...
0xffffffff8133c384 <__list_del_entry+36>: cmp %rcx,%rax
0xffffffff8133c387 <__list_del_entry+39>: je 0xffffffff8133c403
<__list_del_entry+163>
=> 0xffffffff8133c389 <__list_del_entry+41>: mov (%rax),%r8
0xffffffff8133c38c <__list_del_entry+44>: cmp %r8,%rdi
0xffffffff8133c38f <__list_del_entry+47>: jne 0xffffffff8133c3e4
<__list_del_entry+132>
0xffffffff8133c391 <__list_del_entry+49>: mov 0x8(%rdx),%r8
Before the patch:
crash> bt
...
#10 [ffff880095647c00] async_page_fault at ffffffff816a8638
[exception RIP: __list_del_entry+41]
RIP: ffffffff8133c389 RSP: ffff880095647cb0 RFLAGS: 00010207
RAX: 0000000000000000 RBX: ffffea0400408020 RCX: dead000000000200
RDX: 0000000000000000 RSI: 0000000000000246 RDI: ffffea0400408020
RBP: ffff880095647cb0 R8: 0000000080000431 R9: ffffffff81e835c0
R10: 0000000000000000 R11: 0000000000000400 R12: ffff880138795b58
R13: 0000000010010201 R14: ffff880095647d70 R15: 0000000400408040
ORIG_RAX: ffffffffffffffff CS: 0010 SS: 0018
bt: invalid input: "=>"
#11 [ffff880095647cb8] list_del at ffffffff8133c43d
#12 [ffff880095647cd0] devm_memremap_pages at ffffffff81180c53
After the patch:
No string as 'bt: invalid input: "=>"' of output.
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
x86_64.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/x86_64.c b/x86_64.c
index 469d26b..b18f622 100644
--- a/x86_64.c
+++ b/x86_64.c
@@ -8703,6 +8703,8 @@ x86_64_get_framesize(struct bt_info *bt, ulong textaddr, ulong rsp,
char *stack_
rewind(pc->tmpfile2);
while (fgets(buf, BUFSIZE, pc->tmpfile2)) {
+ if (STRNEQ(buf, "=>"))
+ shift_string_left(buf, 2);
strcpy(buf2, buf);
if (CRASHDEBUG(3))
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 04/15] Fix gdb_interface: restore gdb's output streams at end of gdb_interface
From: Aditya Gupta <adityag(a)linux.ibm.com>
Currently for most gdb_interface call, in which a non-null file pointer
is passed, GDB's output stream is replaced with the passed file pointer
Due to this, 'info threads', which is a gdb passthrough, doesn't print any
thread, after support was added to get registers from crash_target:
crash> info threads
Id Target Id Frame
This empty output of 'info threads' was due to a subtle bug in
gdb_interface.
After this gdb passthrough is run, 'datatype_info' is called, with file
pointer set to null_fp (pointing to /dev/null). And after
'datatype_info' returns, any output by gdb goes to /dev/null, and hence
the output is lost.
Fix this by restoring the original output streams, after gdb_interface
has handled the output
After this patch:
crash> info threads
Id Target Id Frame
* 1 2131 bash 0xc000000000051e40 in crash_fadump (regs=0x0,
str=0xc000000002c60510 <buf> "sysrq triggered crash") at
arch/powerpc/kernel/fadump.c:735
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
gdb-10.2.patch | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 53 insertions(+)
diff --git a/gdb-10.2.patch b/gdb-10.2.patch
index 3694b13..0bed96a 100644
--- a/gdb-10.2.patch
+++ b/gdb-10.2.patch
@@ -16118,3 +16118,56 @@ exit 0
subclass (SYMBOL_NONE)
{
/* We can't use an initializer list for members of a base class, and
+--- gdb-10.2/gdb/ui-file.h.orig
++++ gdb-10.2/gdb/ui-file.h
+@@ -195,6 +195,7 @@ public:
+
+ bool can_emit_style_escape () override;
+
++ FILE *get_stream(void);
+ /* Sets the internal stream to FILE, and saves the FILE's file
+ descriptor in M_FD. */
+ void set_stream (FILE *file);
+--- gdb-10.2/gdb/ui-file.c.orig
++++ gdb-10.2/gdb/ui-file.c
+@@ -161,6 +161,12 @@ stdio_file::~stdio_file ()
+ fclose (m_file);
+ }
+
++FILE*
++stdio_file::get_stream(void)
++{
++ return m_file;
++}
++
+ void
+ stdio_file::set_stream (FILE *file)
+ {
+--- gdb-10.2/gdb/symtab.c.orig
++++ gdb-10.2/gdb/symtab.c
+@@ -6964,8 +6964,12 @@ void
+ gdb_command_funnel_1(struct gnu_request *req)
+ {
+ struct symbol *sym;
++ FILE *original_stdout_stream = nullptr;
++ FILE *original_stderr_stream = nullptr;
+
+ if (req->command != GNU_VERSION && req->command !=
GNU_USER_PRINT_OPTION) {
++ original_stdout_stream = (dynamic_cast< stdio_file *
>gdb_stdout)->get_stream();
++ original_stderr_stream = (dynamic_cast< stdio_file *
>gdb_stderr)->get_stream();
+ (dynamic_cast<stdio_file
*>gdb_stdout)->set_stream(req->fp);
+ (dynamic_cast<stdio_file
*>gdb_stderr)->set_stream(req->fp);
+ }
+@@ -7068,6 +7072,12 @@ gdb_command_funnel_1(struct gnu_request *req)
+ req->flags |= GNU_COMMAND_FAILED;
+ break;
+ }
++
++ /* Restore the streams gdb output was using */
++ if (original_stdout_stream)
++ (dynamic_cast<stdio_file
*>gdb_stdout)->set_stream(original_stdout_stream);
++ if (original_stderr_stream)
++ (dynamic_cast<stdio_file
*>gdb_stderr)->set_stream(original_stderr_stream);
+ }
+
+ /*
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 05/15] Remove 'frame' from prohibited commands list
From: Aditya Gupta <adityag(a)linux.ibm.com>
Currently, 'frame' is prohibited on every architecture, even in gdb mode.
But with gdb stack unwinding working correctly on some architectures (eg. ppc64,
x86_64, arm64), so remove it from prohibited list, so that 'frame' command
can be used
This has an implication on all architectures, that 'frame' now outputs
this in default mode:
```
crash> frame
#0 <unavailable> in ?? ()
```
instead of the before prohibited message
```
crash> frame
crash: prohibited gdb command: frame
```
Though, 'frame' should work in gdb mode for architectures that implement
'machdep->get_cpu_reg', which will be renamed to
'machdep->get_current_task_reg' later.
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com>
---
gdb_interface.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/gdb_interface.c b/gdb_interface.c
index b14319c..8f99a0d 100644
--- a/gdb_interface.c
+++ b/gdb_interface.c
@@ -711,7 +711,7 @@ static char *prohibited_list[] = {
"watch", "rwatch", "awatch", "attach",
"continue", "c", "fg", "detach",
"finish", "handle", "interrupt", "jump",
"kill", "next", "nexti",
"signal", "step", "s", "stepi",
"target", "until", "delete",
- "clear", "disable", "enable", "condition",
"ignore", "frame", "catch",
+ "clear", "disable", "enable", "condition",
"ignore", "catch",
"tcatch", "return", "file", "exec-file",
"core-file", "symbol-file",
"load", "si", "ni", "shell", "sy",
NULL /* must be last */
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 06/15] Leave only one gdb thread for crash
This patch is a preparation of gdb stack unwinding support.
There are 3 designs for supporting arbitrary tasks stack unwinding:
1) One gdb thread represent a task[1][2].
2) One gdb thread represent a cpu[3].
3) Leaving only one gdb thread[4].
1 & 2 have a flaw that, when there are lots of tasks/cpus, it will slow
the startup of crash, introduce complexity of the registers context
synchronization between crash and gdb, hard to cover live debug mode
etc. So here we used the 3rd design.
To switch task, or view arbitrary tasks stack unwinding, we will reuse
the current gdb thread, and load the target task's regcache to the
thread(see the next patch). This will simplify many code.
Note this patch will change the behaviour of "info threads", and "thread
x":
before:
crash> gdb thread
[Current thread is 1 (CPU 0)]
crash> info threads
Id Target Id Frame
* 1 CPU 0 <unavailable> in ?? ()
2 CPU 1 <unavailable> in ?? ()
3 CPU 2 <unavailable> in ?? ()
...
crash> thread 2
[Switching to thread 2 (CPU 1)]
#0 <unavailable> in ?? ()
After:
crash> gdb thread
[Current thread is 1 (10715 bash)]
crash> info threads
Id Target Id Frame
* 1 10715 bash 0xc0000000002bde04 in crash_setup_regs ...
crash> thread 2
gdb: gdb request failed: thread 2
As a result, the "info threads" and "thread x" will be less useful.
We
will extend cmd "set" later to implement a similar function.
[1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00524.html
[2]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00529.html
[3]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00471.html
[4]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00541.html
Co-developed-by: Aditya Gupta <adityag(a)linux.ibm.com>
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
crash_target.c | 14 +++++---------
gdb_interface.c | 17 -----------------
2 files changed, 5 insertions(+), 26 deletions(-)
diff --git a/crash_target.c b/crash_target.c
index 4554806..1f62bf6 100644
--- a/crash_target.c
+++ b/crash_target.c
@@ -26,7 +26,6 @@
void crash_target_init (void);
extern "C" int gdb_readmem_callback(unsigned long, void *, int, int);
-extern "C" int crash_get_nr_cpus(void);
extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname,
int regsize, void *val);
@@ -110,7 +109,6 @@ crash_target::xfer_partial (enum target_object object, const char
*annex,
void
crash_target_init (void)
{
- int nr_cpus = crash_get_nr_cpus();
crash_target *target = new crash_target ();
/* Own the target until it is successfully pushed. */
@@ -119,13 +117,11 @@ crash_target_init (void)
push_target (std::move (target_holder));
inferior_appeared (current_inferior (), CRASH_INFERIOR_PID);
- for (int i = 0; i < nr_cpus; i++)
- {
- thread_info *thread = add_thread_silent (target,
- ptid_t(CRASH_INFERIOR_PID, 0, i));
- if (!i)
- switch_to_thread (thread);
- }
+
+ /*Only create 1 gdb threads to view tasks' stack unwinding*/
+ thread_info *thread = add_thread_silent (target,
+ ptid_t(CRASH_INFERIOR_PID, 0, 0));
+ switch_to_thread (thread);
/* Fetch all registers from core file. */
target_fetch_registers (get_current_regcache (), -1);
diff --git a/gdb_interface.c b/gdb_interface.c
index 8f99a0d..8e95e9e 100644
--- a/gdb_interface.c
+++ b/gdb_interface.c
@@ -1067,25 +1067,8 @@ unsigned long crash_get_kaslr_offset(void)
}
/* Callbacks for crash_target */
-int crash_get_nr_cpus(void);
int crash_get_cpu_reg (int cpu, int regno, const char *regname,
int regsize, void *val);
-
-int crash_get_nr_cpus(void)
-{
- if (SADUMP_DUMPFILE())
- return sadump_get_nr_cpus();
- else if (DISKDUMP_DUMPFILE())
- return diskdump_get_nr_cpus();
- else if (KDUMP_DUMPFILE())
- return kdump_get_nr_cpus();
- else if (VMSS_DUMPFILE())
- return vmware_vmss_get_nr_cpus();
-
- /* Just CPU #0 */
- return 1;
-}
-
int crash_get_cpu_reg (int cpu, int regno, const char *regname,
int regsize, void *value)
{
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 07/15] Let crash change gdb context
This patch is a preparation of gdb stack unwinding support. "set" command
is extended with gdb context change:
crash> set <pid>
or
crash> set <task>
Then the task context of crash and gdb will both be switched to
pid/task, so the following command: "bt" "gdb bt" will output
the same task context.
In addition, set_context() will check if context is already current
to avoid dropping gdb caches unnecessarily.
command "info threads" and "thread x", which were used to view all
active threads and switch gdb context to one, can be achieved by
command "ps" and "set <pid>|<task>", which are used to
view all
active/inactive tasks and switch gdb/crash context to it.
Co-developed-by: Aditya Gupta <adityag(a)linux.ibm.com>
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
crash_target.c | 46 ++++++++++++++++++++++++++++++----------------
defs.h | 5 ++++-
kernel.c | 11 ++++++++---
task.c | 25 +++++++++++++++++--------
tools.c | 8 ++++----
5 files changed, 63 insertions(+), 32 deletions(-)
diff --git a/crash_target.c b/crash_target.c
index 1f62bf6..41f0f3a 100644
--- a/crash_target.c
+++ b/crash_target.c
@@ -28,7 +28,7 @@ void crash_target_init (void);
extern "C" int gdb_readmem_callback(unsigned long, void *, int, int);
extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname,
int regsize, void *val);
-
+extern "C" int gdb_change_thread_context (void);
/* The crash target. */
@@ -63,26 +63,32 @@ public:
};
-/* We just get all the registers, so we don't use regno. */
-void
-crash_target::fetch_registers (struct regcache *regcache, int regno)
+static void supply_registers(struct regcache *regcache, int regno)
{
gdb_byte regval[16];
int cpu = inferior_ptid.tid();
struct gdbarch *arch = regcache->arch ();
+ const char *regname = gdbarch_register_name(arch, regno);
+ int regsize = register_size(arch, regno);
- for (int r = 0; r < gdbarch_num_regs (arch); r++)
- {
- const char *regname = gdbarch_register_name(arch, r);
- int regsize = register_size (arch, r);
- if (regsize > sizeof (regval))
- error (_("fatal error: buffer size is not enough to fit register
value"));
-
- if (crash_get_cpu_reg (cpu, r, regname, regsize, (void *)®val))
- regcache->raw_supply (r, regval);
- else
- regcache->raw_supply (r, NULL);
- }
+ if (regsize > sizeof (regval))
+ error (_("fatal error: buffer size is not enough to fit register value"));
+
+ if (crash_get_cpu_reg (cpu, regno, regname, regsize, (void *)®val))
+ regcache->raw_supply (regno, regval);
+ else
+ regcache->raw_supply (regno, NULL);
+}
+
+void
+crash_target::fetch_registers (struct regcache *regcache, int regno)
+{
+ if (regno >= 0) {
+ supply_registers(regcache, regno);
+ } else if (regno == -1) {
+ for (int r = 0; r < gdbarch_num_regs (regcache->arch ()); r++)
+ supply_registers(regcache, r);
+ }
}
@@ -129,3 +135,11 @@ crash_target_init (void)
/* Now, set up the frame cache. */
reinit_frame_cache ();
}
+
+extern "C" int
+gdb_change_thread_context (void)
+{
+ target_fetch_registers(get_current_regcache(), -1);
+ reinit_frame_cache();
+ return TRUE;
+}
diff --git a/defs.h b/defs.h
index 9e0130f..695c32d 100644
--- a/defs.h
+++ b/defs.h
@@ -6047,7 +6047,7 @@ extern char *help_map[];
* task.c
*/
void task_init(void);
-int set_context(ulong, ulong);
+int set_context(ulong, ulong, uint);
void show_context(struct task_context *);
ulong pid_to_task(ulong);
ulong task_to_pid(ulong);
@@ -8083,4 +8083,7 @@ enum x86_64_regnum {
LAST_REGNUM
};
+/* crash_target.c */
+extern int gdb_change_thread_context (void);
+
#endif /* !GDB_COMMON */
diff --git a/kernel.c b/kernel.c
index 57b8dce..edfd17c 100644
--- a/kernel.c
+++ b/kernel.c
@@ -6508,15 +6508,20 @@ set_cpu(int cpu)
if (hide_offline_cpu(cpu))
error(FATAL, "invalid cpu number: cpu %d is OFFLINE\n", cpu);
- if ((task = get_active_task(cpu)))
- set_context(task, NO_PID);
+ task = get_active_task(cpu);
+
+ /* Check if context is already set to given cpu */
+ if (task == CURRENT_TASK())
+ return;
+
+ if (task)
+ set_context(task, NO_PID, TRUE);
else
error(FATAL, "cannot determine active task on cpu %ld\n", cpu);
show_context(CURRENT_CONTEXT());
}
-
/*
* Collect the irq_desc[] entry along with its associated handler and
* action structures.
diff --git a/task.c b/task.c
index d52ce0b..37ac250 100644
--- a/task.c
+++ b/task.c
@@ -679,7 +679,7 @@ task_init(void)
if (ACTIVE()) {
active_pid = REMOTE() ? pc->server_pid :
LOCAL_ACTIVE() ? pc->program_pid : 1;
- set_context(NO_TASK, active_pid);
+ set_context(NO_TASK, active_pid, FALSE);
tt->this_task = pid_to_task(active_pid);
}
else {
@@ -691,7 +691,7 @@ task_init(void)
else if (ELF_NOTES_VALID() && DISKDUMP_DUMPFILE())
map_cpus_to_prstatus_kdump_cmprs();
please_wait("determining panic task");
- set_context(get_panic_context(), NO_PID);
+ set_context(get_panic_context(), NO_PID, TRUE);
please_wait_done();
}
@@ -2992,9 +2992,9 @@ refresh_context(ulong curtask, ulong curpid)
struct task_context *tc;
if (task_exists(curtask) && pid_exists(curpid)) {
- set_context(curtask, NO_PID);
+ set_context(curtask, NO_PID, FALSE);
} else {
- set_context(tt->this_task, NO_PID);
+ set_context(tt->this_task, NO_PID, FALSE);
complain = TRUE;
if (STREQ(args[0], "set") && (argcnt == 2) &&
@@ -3060,7 +3060,7 @@ sort_context_array(void)
curtask = CURRENT_TASK();
qsort((void *)tt->context_array, (size_t)tt->running_tasks,
sizeof(struct task_context), sort_by_pid);
- set_context(curtask, NO_PID);
+ set_context(curtask, NO_PID, TRUE);
sort_context_by_task();
}
@@ -3107,7 +3107,7 @@ sort_context_array_by_last_run(void)
curtask = CURRENT_TASK();
qsort((void *)tt->context_array, (size_t)tt->running_tasks,
sizeof(struct task_context), sort_by_last_run);
- set_context(curtask, NO_PID);
+ set_context(curtask, NO_PID, TRUE);
sort_context_by_task();
}
@@ -5288,12 +5288,16 @@ comm_exists(char *s)
* that pid is selected.
*/
int
-set_context(ulong task, ulong pid)
+set_context(ulong task, ulong pid, uint update_gdb_thread)
{
int i;
struct task_context *tc;
int found;
+ if (CURRENT_CONTEXT() &&
+ (CURRENT_TASK() == task || CURRENT_PID() == pid))
+ return TRUE;
+
tc = FIRST_CONTEXT();
for (i = 0, found = FALSE; i < RUNNING_TASKS(); i++, tc++) {
@@ -5308,7 +5312,12 @@ set_context(ulong task, ulong pid)
if (found) {
CURRENT_CONTEXT() = tc;
- return TRUE;
+
+ /* change the selected thread in gdb, according to current context */
+ if (update_gdb_thread)
+ return gdb_change_thread_context();
+ else
+ return TRUE;
} else {
if (task)
error(INFO, "cannot set context for task: %lx\n", task);
diff --git a/tools.c b/tools.c
index 8c73d10..a0d5b71 100644
--- a/tools.c
+++ b/tools.c
@@ -1872,7 +1872,7 @@ cmd_set(void)
return;
if (ACTIVE()) {
- set_context(tt->this_task, NO_PID);
+ set_context(tt->this_task, NO_PID, TRUE);
show_context(CURRENT_CONTEXT());
return;
}
@@ -1881,7 +1881,7 @@ cmd_set(void)
error(INFO, "no panic task found!\n");
return;
}
- set_context(tt->panic_task, NO_PID);
+ set_context(tt->panic_task, NO_PID, TRUE);
show_context(CURRENT_CONTEXT());
return;
@@ -2560,14 +2560,14 @@ cmd_set(void)
case STR_PID:
pid = value;
task = NO_TASK;
- if (set_context(task, pid))
+ if (set_context(task, pid, TRUE))
show_context(CURRENT_CONTEXT());
break;
case STR_TASK:
task = value;
pid = NO_PID;
- if (set_context(task, pid))
+ if (set_context(task, pid, TRUE))
show_context(CURRENT_CONTEXT());
break;
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 08/15] Rename get_cpu_reg to get_current_task_reg
Since we only leave one gdb thread, or 1 cpu thread, and can use cmd "set"
to switch task context by reusing the thread. So the word "get_cpu_reg",
which stands for "fetch registers' value for cpu thread x", is no longer
appropriate, better using "get_current_task_reg", which stands for "fetch
registers' value for the current task", and makes more sense.
Note: the x86_64_get_cpu_reg() function modification was originally in
the x86_64 stack unwinding support part later, put it here due to not
introducing compiling issues.
Co-developed-by: Aditya Gupta <adityag(a)linux.ibm.com>
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
crash_target.c | 5 ++---
defs.h | 2 +-
gdb_interface.c | 14 +++++++-------
x86_64.c | 22 +++++++++++++++-------
4 files changed, 25 insertions(+), 18 deletions(-)
diff --git a/crash_target.c b/crash_target.c
index 41f0f3a..6ee12d2 100644
--- a/crash_target.c
+++ b/crash_target.c
@@ -26,7 +26,7 @@
void crash_target_init (void);
extern "C" int gdb_readmem_callback(unsigned long, void *, int, int);
-extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname,
+extern "C" int crash_get_current_task_reg (int regno, const char *regname,
int regsize, void *val);
extern "C" int gdb_change_thread_context (void);
@@ -66,7 +66,6 @@ public:
static void supply_registers(struct regcache *regcache, int regno)
{
gdb_byte regval[16];
- int cpu = inferior_ptid.tid();
struct gdbarch *arch = regcache->arch ();
const char *regname = gdbarch_register_name(arch, regno);
int regsize = register_size(arch, regno);
@@ -74,7 +73,7 @@ static void supply_registers(struct regcache *regcache, int regno)
if (regsize > sizeof (regval))
error (_("fatal error: buffer size is not enough to fit register value"));
- if (crash_get_cpu_reg (cpu, regno, regname, regsize, (void *)®val))
+ if (crash_get_current_task_reg (regno, regname, regsize, (void *)®val))
regcache->raw_supply (regno, regval);
else
regcache->raw_supply (regno, NULL);
diff --git a/defs.h b/defs.h
index 695c32d..0d16721 100644
--- a/defs.h
+++ b/defs.h
@@ -1080,7 +1080,7 @@ struct machdep_table {
void (*get_irq_affinity)(int);
void (*show_interrupts)(int, ulong *);
int (*is_page_ptr)(ulong, physaddr_t *);
- int (*get_cpu_reg)(int, int, const char *, int, void *);
+ int (*get_current_task_reg)(int, const char *, int, void *);
int (*is_cpu_prstatus_valid)(int cpu);
};
diff --git a/gdb_interface.c b/gdb_interface.c
index 8e95e9e..ab4ebd3 100644
--- a/gdb_interface.c
+++ b/gdb_interface.c
@@ -1067,13 +1067,13 @@ unsigned long crash_get_kaslr_offset(void)
}
/* Callbacks for crash_target */
-int crash_get_cpu_reg (int cpu, int regno, const char *regname,
- int regsize, void *val);
-int crash_get_cpu_reg (int cpu, int regno, const char *regname,
- int regsize, void *value)
+int crash_get_current_task_reg (int regno, const char *regname,
+ int regsize, void *value);
+int crash_get_current_task_reg (int regno, const char *regname,
+ int regsize, void *value)
{
- if (!machdep->get_cpu_reg)
- return FALSE;
- return machdep->get_cpu_reg(cpu, regno, regname, regsize, value);
+ if (!machdep->get_current_task_reg)
+ return FALSE;
+ return machdep->get_current_task_reg(regno, regname, regsize, value);
}
diff --git a/x86_64.c b/x86_64.c
index b18f622..655b4a9 100644
--- a/x86_64.c
+++ b/x86_64.c
@@ -126,7 +126,7 @@ static int x86_64_get_framesize(struct bt_info *, ulong, ulong, char
*);
static void x86_64_framesize_debug(struct bt_info *);
static void x86_64_get_active_set(void);
static int x86_64_get_kvaddr_ranges(struct vaddr_range *);
-static int x86_64_get_cpu_reg(int, int, const char *, int, void *);
+static int x86_64_get_cpu_reg(int, const char *, int, void *);
static int x86_64_verify_paddr(uint64_t);
static void GART_init(void);
static void x86_64_exception_stacks_init(void);
@@ -195,7 +195,7 @@ x86_64_init(int when)
machdep->machspec->irq_eframe_link = UNINITIALIZED;
machdep->machspec->irq_stack_gap = UNINITIALIZED;
machdep->get_kvaddr_ranges = x86_64_get_kvaddr_ranges;
- machdep->get_cpu_reg = x86_64_get_cpu_reg;
+ machdep->get_current_task_reg = x86_64_get_cpu_reg;
if (machdep->cmdline_args[0])
parse_cmdline_args();
if ((string = pc->read_vmcoreinfo("relocate"))) {
@@ -9076,14 +9076,22 @@ x86_64_get_kvaddr_ranges(struct vaddr_range *vrp)
}
static int
-x86_64_get_cpu_reg(int cpu, int regno, const char *name,
+x86_64_get_cpu_reg(int regno, const char *name,
int size, void *value)
{
- if (regno >= LAST_REGNUM)
- return FALSE;
+ struct task_context *tc;
- if (VMSS_DUMPFILE())
- return vmware_vmss_get_cpu_reg(cpu, regno, name, size, value);
+ tc = CURRENT_CONTEXT();
+ if (!tc)
+ return FALSE;
+
+ if (regno >= LAST_REGNUM)
+ return FALSE;
+ /*
+ * Task is active, grab CPU's registers
+ */
+ if (is_task_active(tc->task) && VMSS_DUMPFILE())
+ return vmware_vmss_get_cpu_reg(tc->processor, regno, name, size, value);
return FALSE;
}
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 09/15] Print task pid/command instead of CPU index
This patch is a preparation of gdb stack unwinding support. "info threads"
will output useful info for current task, such as pid, command, stack frame.
Before the patch:
crash> info threads
Id Target Id Frame
* 1 CPU 0 crash_setup_regs (oldregs=0x0, newregs=0xffffbd1040c57c70) ...
After the patch:
crash> info threads
Id Target Id Frame
* 1 1231 bash crash_setup_regs (oldregs=0x0, newregs=0xffffbd1040c57c70) ...
Co-developed-by: Aditya Gupta <adityag(a)linux.ibm.com>
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
crash_target.c | 8 +++++++-
task.c | 9 +++++++++
2 files changed, 16 insertions(+), 1 deletion(-)
diff --git a/crash_target.c b/crash_target.c
index 6ee12d2..1080976 100644
--- a/crash_target.c
+++ b/crash_target.c
@@ -29,6 +29,7 @@ extern "C" int gdb_readmem_callback(unsigned long, void *,
int, int);
extern "C" int crash_get_current_task_reg (int regno, const char *regname,
int regsize, void *val);
extern "C" int gdb_change_thread_context (void);
+extern "C" void crash_get_current_task_info(unsigned long *pid, char **comm);
/* The crash target. */
@@ -59,7 +60,12 @@ public:
bool has_registers () override { return true; }
bool thread_alive (ptid_t ptid) override { return true; }
std::string pid_to_str (ptid_t ptid) override
- { return string_printf ("CPU %ld", ptid.tid ()); }
+ {
+ unsigned long pid;
+ char *comm;
+ crash_get_current_task_info(&pid, &comm);
+ return string_printf ("%ld %s", pid, comm);
+ }
};
diff --git a/task.c b/task.c
index 37ac250..c131cc3 100644
--- a/task.c
+++ b/task.c
@@ -120,6 +120,7 @@ static int has_sched_policy(ulong, ulong);
static ulong task_policy(ulong);
static ulong sched_policy_bit_from_str(const char *);
static ulong make_sched_policy(const char *);
+void crash_get_current_task_info(unsigned long *, char **);
static struct sched_policy_info {
ulong value;
@@ -11296,3 +11297,11 @@ check_stack_end_magic:
if (!total)
fprintf(fp, "No stack overflows detected\n");
}
+
+void crash_get_current_task_info(unsigned long *pid, char **comm)
+{
+ struct task_context *tc = CURRENT_CONTEXT();
+
+ *pid = tc->pid;
+ *comm = tc->comm;
+}
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 10/15] Stop stack unwinding at non-kernel address
The stack unwinding is for kernel addresses only. If non-kernel address
encountered, it is usually a user space address, or non-address value
like a function call parameter. So stopping stack unwinding at non-kernel
address will decrease the invalid unwind results.
Before:
crash> gdb bt
#0 0xffffffff816a8f65 in context_switch ...
#1 __schedule () ...
#2 0xffffffff816a94e9 in schedule ...
#3 0xffffffff816a86fd in schedule_hrtimeout_range_clock ...
#4 0xffffffff816a8733 in schedule_hrtimeout_range ...
#5 0xffffffff8124bb7e in ep_poll ...
#6 0xffffffff8124d00d in SYSC_epoll_wait ...
#7 SyS_epoll_wait ...
#8 <signal handler called>
#9 0x00007f0449407923 in ?? ()
#10 0xffff880100000001 in ?? ()
#11 0xffff880169b3c010 in ?? ()
#12 0x0000000000000040 in irq_stack_union ()
#13 0xffff880169b3c058 in ?? ()
#14 0xffff880169b3c048 in ?? ()
#15 0xffff880169b3c050 in ?? ()
#16 0x0000000000000000 in ?? ()
After:
crash> gdb bt
#0 0xffffffff816a8f65 in context_switch ...
#1 __schedule () ...
#2 0xffffffff816a94e9 in schedule () ...
#3 0xffffffff816a86fd in schedule_hrtimeout_range_clock ...
#4 0xffffffff816a8733 in schedule_hrtimeout_range ...
#5 0xffffffff8124bb7e in ep_poll ...
#6 0xffffffff8124d00d in SYSC_epoll_wait ...
#7 SyS_epoll_wait ...
#8 <signal handler called>
Backtrace stopped due to non-kernel addr: 0x7f0449407923
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
defs.h | 1 +
gdb-10.2.patch | 32 ++++++++++++++++++++++++++++++++
gdb_interface.c | 6 ++++++
3 files changed, 39 insertions(+)
diff --git a/defs.h b/defs.h
index 0d16721..adf45a1 100644
--- a/defs.h
+++ b/defs.h
@@ -7934,6 +7934,7 @@ extern unsigned char *gdb_prettyprint_arrays;
extern unsigned int *gdb_repeat_count_threshold;
extern unsigned char *gdb_stop_print_at_null;
extern unsigned int *gdb_output_radix;
+int is_kvaddr(ulong);
/*
* gdb/top.c
diff --git a/gdb-10.2.patch b/gdb-10.2.patch
index 0bed96a..7f66e5c 100644
--- a/gdb-10.2.patch
+++ b/gdb-10.2.patch
@@ -16171,3 +16171,35 @@ exit 0
}
/*
+--- gdb-10.2/gdb/stack.c.orig
++++ gdb-10.2/gdb/stack.c
+@@ -1990,6 +1990,11 @@
+ /* Print briefly all stack frames or just the innermost COUNT_EXP
+ frames. */
+
++#ifdef CRASH_MERGE
++extern "C" int is_kvaddr(ulong);
++extern "C" int gdb_CRASHDEBUG(ulong);
++#endif
++
+ static void
+ backtrace_command_1 (const frame_print_options &fp_opts,
+ const backtrace_cmd_options &bt_opts,
+@@ -2082,6 +2086,17 @@
+ hand, perhaps the code does or could be fixed to make sure
+ the frame->prev field gets set to NULL in that case). */
+
++#ifdef CRASH_MERGE
++ CORE_ADDR pc = 0;
++ get_frame_pc_if_available (fi, &pc);
++ if (!is_kvaddr(pc)) {
++ if (gdb_CRASHDEBUG(1)) {
++ printf_filtered (_("Backtrace stopped: due to non-kernel addr:
0x%lx\n"),pc);
++ }
++ fi = NULL;
++ break;
++ }
++#endif
+ print_frame_info (fp_opts, fi, 1, LOCATION, 1, 0);
+ if ((flags & PRINT_LOCALS) != 0)
+ {
diff --git a/gdb_interface.c b/gdb_interface.c
index ab4ebd3..315711e 100644
--- a/gdb_interface.c
+++ b/gdb_interface.c
@@ -947,6 +947,12 @@ gdb_lookup_module_symbol(ulong addr, ulong *offset)
}
}
+int
+is_kvaddr(ulong addr)
+{
+ return IS_KVADDR(addr);
+}
+
/*
* Used by gdb_interface() to catch gdb-related errors, if desired.
*/
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 11/15] Conditionally output gdb stack unwinding stop reasons
When gdb stack unwinding is enabled, gdb will output the stack trace
along with a unwinding stop reason. This is often seen at the end of
kernel stack unwinding where a userspace stack/context-switch is reached,
gdb fails to recongnize it and output the stop reason indicating the
error.
Though the stack unwinding is correct, but the error message might
confuse users. So we will output the message conditionally instead of
filter it out, since the message might be useful to experienced users.
To view the unwind stopping info:
crash> gdb bt
#0 0xc0000000002bde04 in crash_setup_regs ...
...
#12 0xc00000000000d05c in system_call_vectored_common () ...
crash> set debug 1
debug: 1
crash> gdb bt
#0 0xc0000000002bde04 in crash_setup_regs ...
...
#12 0xc00000000000d05c in system_call_vectored_common () ...
Backtrace stopped: previous frame inner to this frame (corrupt stack?)
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
gdb-10.2.patch | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/gdb-10.2.patch b/gdb-10.2.patch
index 7f66e5c..54716dc 100644
--- a/gdb-10.2.patch
+++ b/gdb-10.2.patch
@@ -16203,3 +16203,14 @@ exit 0
print_frame_info (fp_opts, fi, 1, LOCATION, 1, 0);
if ((flags & PRINT_LOCALS) != 0)
{
+--- gdb-10.2/gdb/stack.c.orig
++++ gdb-10.2/gdb/stack.c
+@@ -2127,7 +2127,7 @@
+ enum unwind_stop_reason reason;
+
+ reason = get_frame_unwind_stop_reason (trailing);
+- if (reason >= UNWIND_FIRST_ERROR)
++ if (reason >= UNWIND_FIRST_ERROR && gdb_CRASHDEBUG(1))
+ printf_filtered (_("Backtrace stopped: %s\n"),
+ frame_stop_reason_string (trailing));
+ }
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 12/15] ppc64: correct gdb passthroughs by implementing machdep->get_current_task_reg
From: Aditya Gupta <adityag(a)linux.ibm.com>
Currently, gdb passthroughs of 'bt', 'frame', 'up',
'down', 'info
locals' don't work. This is due to gdb not knowing the register values to
unwind the stack frames
Every gdb passthrough goes through `gdb_interface`. And then, gdb expects
`crash_target::fetch_registers` to give it the register values, which is
dependent on `machdep->get_current_task_reg` to read the register values for
specific architecture.
----------------------------
gdb passthrough (eg. "bt") | |
crash -------------------------> | |
| gdb_interface |
| |
| |
| ---------------------- |
fetch_registers | | | |
crash_target<-------------------------+--| gdb | |
--------------------------+->| | |
Registers (SP,NIP, etc.)| | | |
| | | |
| ---------------------- |
----------------------------
Implement `machdep->get_current_task_reg` on PPC64, so that crash provides the
register values to gdb to unwind stack frames properly
With these changes, on powerpc, 'bt' command output in gdb mode, will look
like this:
gdb> bt
#0 0xc0000000002a53e8 in crash_setup_regs (oldregs=<optimized out>,
newregs=0xc00000000486f8d8) at ./arch/powerpc/include/asm/kexec.h:69
#1 __crash_kexec (regs=<optimized out>) at kernel/kexec_core.c:974
#2 0xc000000000168918 in panic (fmt=<optimized out>) at kernel/panic.c:358
#3 0xc000000000b735f8 in sysrq_handle_crash (key=<optimized out>) at
drivers/tty/sysrq.c:155
#4 0xc000000000b742cc in __handle_sysrq (key=key@entry=99,
check_mask=check_mask@entry=false) at drivers/tty/sysrq.c:602
#5 0xc000000000b7506c in write_sysrq_trigger (file=<optimized out>,
buf=<optimized out>, count=2, ppos=<optimized out>) at
drivers/tty/sysrq.c:1163
#6 0xc00000000069a7bc in pde_write (ppos=<optimized out>, count=<optimized
out>, buf=<optimized out>, file=<optimized out>, pde=0xc000000009ed3a80) at
fs/proc/inode.c:340
#7 proc_reg_write (file=<optimized out>, buf=<optimized out>,
count=<optimized out>, ppos=<optimized out>) at fs/proc/inode.c:352
#8 0xc0000000005b3bbc in vfs_write (file=file@entry=0xc00000009dda7d00,
buf=buf@entry=0xebcfc7c6040 <error: Cannot access memory at address 0xebcfc7c6040>,
count=count@entry=2, pos=pos@entry=0xc00000000486fda0) at fs/read_write.c:582
instead of earlier output without this patch:
gdb> bt
#0 <unavailable> in ?? ()
Backtrace stopped: previous frame identical to this frame (corrupt stack?)
Also, 'get_dumpfile_regs' has been introduced to get registers from
multiple supported vmcore formats. Correspondingly a flag 'BT_NO_PRINT_REGS'
has been introduced to tell helper functions to get registers, to not
print registers with every call to backtrace in gdb.
Note: This feature to support GDB unwinding doesn't support live debugging
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Improved-by: Tao Liu <ltao(a)redhat.com>
Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com>
---
defs.h | 130 ++++++++++++++++++++++++++++++++++++
kernel.c | 33 +++++++++
ppc64.c | 174 ++++++++++++++++++++++++++++++++++++++++++++++--
unwind_x86_64.h | 4 --
4 files changed, 330 insertions(+), 11 deletions(-)
diff --git a/defs.h b/defs.h
index adf45a1..ffe8acf 100644
--- a/defs.h
+++ b/defs.h
@@ -982,6 +982,7 @@ struct bt_info {
ulong eframe_ip;
ulong radix;
ulong *cpumask;
+ bool need_free;
};
#define STACK_OFFSET_TYPE(OFF) \
@@ -6130,6 +6131,7 @@ int load_module_symbols_helper(char *);
void unlink_module(struct load_module *);
int check_specified_module_tree(char *, char *);
int is_system_call(char *, ulong);
+void get_dumpfile_regs(struct bt_info*, ulong*, ulong*);
void generic_dump_irq(int);
void generic_get_irq_affinity(int);
void generic_show_interrupts(int, ulong *);
@@ -6229,6 +6231,7 @@ ulong cpu_map_addr(const char *type);
#define BT_REGS_NOT_FOUND (0x4000000000000ULL)
#define BT_OVERFLOW_STACK (0x8000000000000ULL)
#define BT_SKIP_IDLE (0x10000000000000ULL)
+#define BT_NO_PRINT_REGS (0x20000000000000ULL)
#define BT_SYMBOL_OFFSET (BT_SYMBOLIC_ARGS)
#define BT_REF_HEXVAL (0x1)
@@ -8035,6 +8038,13 @@ extern int have_full_symbols(void);
#define XEN_HYPERVISOR_ARCH
#endif
+#ifndef offsetof
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
+#define REG_SEQ(TYPE, MEMBER) \
+ (offsetof(struct TYPE, MEMBER) / FIELD_SIZEOF(struct TYPE, MEMBER))
+
/*
* Register numbers must be in sync with gdb/features/i386/64bit-core.c
* to make crash_target->fetch_registers() ---> machdep->get_cpu_reg()
@@ -8084,6 +8094,126 @@ enum x86_64_regnum {
LAST_REGNUM
};
+/*
+ * Register numbers to make crash_target->fetch_registers()
+ * ---> machdep->get_current_task_reg() work properly.
+ *
+ * These register numbers and names are given according to output of
+ * `rs6000_register_name`, because that is what was being used by
+ * crash_target::fetch_registers in case of PPC64
+ */
+enum ppc64_regnum {
+ PPC64_R0_REGNUM = 0,
+ PPC64_R1_REGNUM,
+ PPC64_R2_REGNUM,
+ PPC64_R3_REGNUM,
+ PPC64_R4_REGNUM,
+ PPC64_R5_REGNUM,
+ PPC64_R6_REGNUM,
+ PPC64_R7_REGNUM,
+ PPC64_R8_REGNUM,
+ PPC64_R9_REGNUM,
+ PPC64_R10_REGNUM,
+ PPC64_R11_REGNUM,
+ PPC64_R12_REGNUM,
+ PPC64_R13_REGNUM,
+ PPC64_R14_REGNUM,
+ PPC64_R15_REGNUM,
+ PPC64_R16_REGNUM,
+ PPC64_R17_REGNUM,
+ PPC64_R18_REGNUM,
+ PPC64_R19_REGNUM,
+ PPC64_R20_REGNUM,
+ PPC64_R21_REGNUM,
+ PPC64_R22_REGNUM,
+ PPC64_R23_REGNUM,
+ PPC64_R24_REGNUM,
+ PPC64_R25_REGNUM,
+ PPC64_R26_REGNUM,
+ PPC64_R27_REGNUM,
+ PPC64_R28_REGNUM,
+ PPC64_R29_REGNUM,
+ PPC64_R30_REGNUM,
+ PPC64_R31_REGNUM,
+
+ PPC64_F0_REGNUM = 32,
+ PPC64_F1_REGNUM,
+ PPC64_F2_REGNUM,
+ PPC64_F3_REGNUM,
+ PPC64_F4_REGNUM,
+ PPC64_F5_REGNUM,
+ PPC64_F6_REGNUM,
+ PPC64_F7_REGNUM,
+ PPC64_F8_REGNUM,
+ PPC64_F9_REGNUM,
+ PPC64_F10_REGNUM,
+ PPC64_F11_REGNUM,
+ PPC64_F12_REGNUM,
+ PPC64_F13_REGNUM,
+ PPC64_F14_REGNUM,
+ PPC64_F15_REGNUM,
+ PPC64_F16_REGNUM,
+ PPC64_F17_REGNUM,
+ PPC64_F18_REGNUM,
+ PPC64_F19_REGNUM,
+ PPC64_F20_REGNUM,
+ PPC64_F21_REGNUM,
+ PPC64_F22_REGNUM,
+ PPC64_F23_REGNUM,
+ PPC64_F24_REGNUM,
+ PPC64_F25_REGNUM,
+ PPC64_F26_REGNUM,
+ PPC64_F27_REGNUM,
+ PPC64_F28_REGNUM,
+ PPC64_F29_REGNUM,
+ PPC64_F30_REGNUM,
+ PPC64_F31_REGNUM,
+
+ PPC64_PC_REGNUM = 64,
+ PPC64_MSR_REGNUM = 65,
+ PPC64_CR_REGNUM = 66,
+ PPC64_LR_REGNUM = 67,
+ PPC64_CTR_REGNUM = 68,
+ PPC64_XER_REGNUM = 69,
+ PPC64_FPSCR_REGNUM = 70,
+
+ PPC64_VR0_REGNUM = 106,
+ PPC64_VR1_REGNUM,
+ PPC64_VR2_REGNUM,
+ PPC64_VR3_REGNUM,
+ PPC64_VR4_REGNUM,
+ PPC64_VR5_REGNUM,
+ PPC64_VR6_REGNUM,
+ PPC64_VR7_REGNUM,
+ PPC64_VR8_REGNUM,
+ PPC64_VR9_REGNUM,
+ PPC64_VR10_REGNUM,
+ PPC64_VR11_REGNUM,
+ PPC64_VR12_REGNUM,
+ PPC64_VR13_REGNUM,
+ PPC64_VR14_REGNUM,
+ PPC64_VR15_REGNUM,
+ PPC64_VR16_REGNUM,
+ PPC64_VR17_REGNUM,
+ PPC64_VR18_REGNUM,
+ PPC64_VR19_REGNUM,
+ PPC64_VR20_REGNUM,
+ PPC64_VR21_REGNUM,
+ PPC64_VR22_REGNUM,
+ PPC64_VR23_REGNUM,
+ PPC64_VR24_REGNUM,
+ PPC64_VR25_REGNUM,
+ PPC64_VR26_REGNUM,
+ PPC64_VR27_REGNUM,
+ PPC64_VR28_REGNUM,
+ PPC64_VR29_REGNUM,
+ PPC64_VR30_REGNUM,
+ PPC64_VR31_REGNUM,
+
+ PPC64_VSCR_REGNUM = 138,
+ PPC64_VRSAVE_REGNU = 139
+};
+
/* crash_target.c */
extern int gdb_change_thread_context (void);
diff --git a/kernel.c b/kernel.c
index edfd17c..8c2e0ca 100644
--- a/kernel.c
+++ b/kernel.c
@@ -3535,6 +3535,39 @@ get_lkcd_regs(struct bt_info *bt, ulong *eip, ulong *esp)
machdep->get_stack_frame(bt, eip, esp);
}
+void
+get_dumpfile_regs(struct bt_info *bt, ulong *eip, ulong *esp)
+{
+ bt->flags |= BT_NO_PRINT_REGS;
+
+ if (NETDUMP_DUMPFILE())
+ get_netdump_regs(bt, eip, esp);
+ else if (KDUMP_DUMPFILE())
+ get_kdump_regs(bt, eip, esp);
+ else if (DISKDUMP_DUMPFILE())
+ get_diskdump_regs(bt, eip, esp);
+ else if (KVMDUMP_DUMPFILE())
+ get_kvmdump_regs(bt, eip, esp);
+ else if (LKCD_DUMPFILE())
+ get_lkcd_regs(bt, eip, esp);
+ else if (XENDUMP_DUMPFILE())
+ get_xendump_regs(bt, eip, esp);
+ else if (SADUMP_DUMPFILE())
+ get_sadump_regs(bt, eip, esp);
+ else if (VMSS_DUMPFILE())
+ get_vmware_vmss_regs(bt, eip, esp);
+ else if (REMOTE_PAUSED()) {
+ if (!is_task_active(bt->task) || !get_remote_regs(bt, eip, esp))
+ machdep->get_stack_frame(bt, eip, esp);
+ } else
+ machdep->get_stack_frame(bt, eip, esp);
+
+ bt->flags &= ~BT_NO_PRINT_REGS;
+
+ bt->instptr = *eip;
+ bt->stkptr = *esp;
+}
+
/*
* Store the head of the kernel module list for future use.
diff --git a/ppc64.c b/ppc64.c
index e8930a1..782107b 100644
--- a/ppc64.c
+++ b/ppc64.c
@@ -55,6 +55,8 @@ static void ppc64_set_bt_emergency_stack(enum emergency_stack_type
type,
static char * ppc64_check_eframe(struct ppc64_pt_regs *);
static void ppc64_print_eframe(char *, struct ppc64_pt_regs *,
struct bt_info *);
+static int ppc64_get_current_task_reg(int regno, const char *name, int size,
+ void *value);
static void parse_cmdline_args(void);
static int ppc64_paca_percpu_offset_init(int);
static void ppc64_init_cpu_info(void);
@@ -73,6 +75,11 @@ static ulong pmd_page_vaddr_l4(ulong pmd);
static int is_opal_context(ulong sp, ulong nip);
void opalmsg(void);
+struct user_regs_bitmap_struct {
+ struct ppc64_pt_regs ur;
+ ulong bitmap[32];
+};
+
static int is_opal_context(ulong sp, ulong nip)
{
uint64_t opal_start, opal_end;
@@ -704,6 +711,8 @@ ppc64_init(int when)
error(FATAL, "cannot malloc hwirqstack buffer space.");
}
+ machdep->get_current_task_reg = ppc64_get_current_task_reg;
+
ppc64_init_paca_info();
if (!machdep->hz) {
@@ -2501,6 +2510,145 @@ ppc64_print_eframe(char *efrm_str, struct ppc64_pt_regs *regs,
ppc64_print_nip_lr(regs, 1);
}
+static int
+ppc64_get_current_task_reg(int regno, const char *name, int size,
+ void *value)
+{
+ struct bt_info bt_info, bt_setup;
+ struct task_context *tc;
+ struct user_regs_bitmap_struct *ur_bitmap;
+ ulong ip, sp;
+ bool ret = FALSE;
+
+ /* Currently only handling registers available in ppc64_pt_regs:
+ *
+ * 0-31: r0-r31
+ * 64: pc/nip
+ * 65: msr
+ *
+ * 67: lr
+ * 68: ctr
+ */
+ switch (regno) {
+ case PPC64_R0_REGNUM ... PPC64_R31_REGNUM:
+
+ case PPC64_PC_REGNUM:
+ case PPC64_MSR_REGNUM:
+ case PPC64_LR_REGNUM:
+ case PPC64_CTR_REGNUM:
+ break;
+
+ default:
+ // return false if we can't get that register
+ if (CRASHDEBUG(1))
+ error(WARNING, "unsupported register, regno=%d\n", regno);
+ return FALSE;
+ }
+
+ tc = CURRENT_CONTEXT();
+ if (!tc)
+ return FALSE;
+ BZERO(&bt_setup, sizeof(struct bt_info));
+ clone_bt_info(&bt_setup, &bt_info, tc);
+ fill_stackbuf(&bt_info);
+
+ // reusing the get_dumpfile_regs function to get pt regs structure
+ get_dumpfile_regs(&bt_info, &sp, &ip);
+ if (bt_info.stackbuf)
+ FREEBUF(bt_info.stackbuf);
+ ur_bitmap = (struct user_regs_bitmap_struct *)bt_info.machdep;
+
+ if (!ur_bitmap) {
+ error(WARNING, "pt_regs not available for cpu %d\n", tc->processor);
+ return FALSE;
+ }
+ if (!bt_info.need_free) {
+ goto get_all;
+ }
+
+ switch (regno) {
+ case PPC64_R0_REGNUM ... PPC64_R31_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(ppc64_pt_regs, gpr[0]) + regno - PPC64_R0_REGNUM)) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ case PPC64_PC_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(ppc64_pt_regs, nip))) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ case PPC64_MSR_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(ppc64_pt_regs, msr))) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ case PPC64_LR_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(ppc64_pt_regs, link))) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ case PPC64_CTR_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(ppc64_pt_regs, ctr))) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ }
+
+get_all:
+ switch (regno) {
+ case PPC64_R0_REGNUM ... PPC64_R31_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.gpr[regno]))
+ break;
+ memcpy(value, &ur_bitmap->ur.gpr[regno], size);
+ ret = TRUE;
+ break;
+
+ case PPC64_PC_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.nip))
+ break;
+ memcpy(value, &ur_bitmap->ur.nip, size);
+ ret = TRUE;
+ break;
+
+ case PPC64_MSR_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.msr))
+ break;
+ memcpy(value, &ur_bitmap->ur.msr, size);
+ ret = TRUE;
+ break;
+
+ case PPC64_LR_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.link))
+ break;
+ memcpy(value, &ur_bitmap->ur.link, size);
+ ret = TRUE;
+ break;
+
+ case PPC64_CTR_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.ctr))
+ break;
+ memcpy(value, &ur_bitmap->ur.ctr, size);
+ ret = TRUE;
+ break;
+ }
+ if (bt_info.need_free) {
+ FREEBUF(ur_bitmap);
+ bt_info.need_free = FALSE;
+ }
+
+ return ret;
+}
+
/*
* For vmcore typically saved with KDump or FADump, get SP and IP values
* from the saved ptregs.
@@ -2613,9 +2761,11 @@ ppc64_get_dumpfile_stack_frame(struct bt_info *bt_in, ulong *nip,
ulong *ksp)
pt_regs = (struct ppc64_pt_regs *)bt->machdep;
ur_nip = pt_regs->nip;
ur_ksp = pt_regs->gpr[1];
- /* Print the collected regs for panic task. */
- ppc64_print_regs(pt_regs);
- ppc64_print_nip_lr(pt_regs, 1);
+ if (!(bt->flags & BT_NO_PRINT_REGS)) {
+ /* Print the collected regs for panic task. */
+ ppc64_print_regs(pt_regs);
+ ppc64_print_nip_lr(pt_regs, 1);
+ }
} else if ((pc->flags & KDUMP) ||
((pc->flags & DISKDUMP) &&
(*diskdump_flags & KDUMP_CMPRS_LOCAL))) {
@@ -2779,19 +2929,29 @@ static void
ppc64_get_stack_frame(struct bt_info *bt, ulong *pcp, ulong *spp)
{
ulong ksp, nip;
-
+ struct user_regs_bitmap_struct *ur_bitmap;
+
nip = ksp = 0;
- if (DUMPFILE() && is_task_active(bt->task))
+ if (DUMPFILE() && is_task_active(bt->task)) {
ppc64_get_dumpfile_stack_frame(bt, &nip, &ksp);
- else
+ bt->need_free = FALSE;
+ } else {
get_ppc64_frame(bt, &nip, &ksp);
+ ur_bitmap = (struct user_regs_bitmap_struct *)GETBUF(sizeof(*ur_bitmap));
+ memset(ur_bitmap, 0, sizeof(*ur_bitmap));
+ ur_bitmap->ur.nip = nip;
+ ur_bitmap->ur.gpr[1] = ksp;
+ SET_BIT(ur_bitmap->bitmap, REG_SEQ(ppc64_pt_regs, nip));
+ SET_BIT(ur_bitmap->bitmap, REG_SEQ(ppc64_pt_regs, gpr[0]) + 1);
+ bt->machdep = ur_bitmap;
+ bt->need_free = TRUE;
+ }
if (pcp)
*pcp = nip;
if (spp)
*spp = ksp;
-
}
static ulong
diff --git a/unwind_x86_64.h b/unwind_x86_64.h
index 850d488..d16da14 100644
--- a/unwind_x86_64.h
+++ b/unwind_x86_64.h
@@ -58,13 +58,9 @@ extern int unwind(struct unwind_frame_info *, int);
extern void init_unwind_table(void);
extern void free_unwind_table(void);
-#ifndef offsetof
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-#endif
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
-#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
#define get_unaligned(ptr) (*(ptr))
//#define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
#define THREAD_ORDER 1
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 13/15] x86_64: Add gdb stack unwinding support
This patch will add stack unwinding support for x86_64 CPU arch. It
follows the tech path of ppc64_get_stack_frame() & ppc64_get_current_task_reg()
in ppc64.c, to get and consume the cpu regs.
One different case is, we need to handle inactive_task_frame structure
specifically in x86_64.
If inactive_task_frame structure enabled, for inactive tasks, 7 regs can
be get from inactive_task_frame in stack, and sp need to rewind back to
skip inactive_task_frame structure (See code comments in
x86_64.c:x86_64_get_current_task_reg()); for active tasks, we get regs by the
original way.
If inactive_task_frame structure is not enabled, for inactive tasks, the
stack frame is organized as linked list, and sp/bp can be get from stack;
for active tasks, we get regs by the original way.
vmware_vmss_get_cpu_reg() whould be called only for active tasks
to get their registers from corresponding CPUs.
Otherwise, the standard path of fetching pt_regs from the memory
(inactive_task_frame) should be used.
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
Signed-off-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
---
defs.h | 19 +++-
symbols.c | 14 +++
x86_64.c | 309 +++++++++++++++++++++++++++++++++++++++++++++++++-----
3 files changed, 312 insertions(+), 30 deletions(-)
diff --git a/defs.h b/defs.h
index ffe8acf..abfa923 100644
--- a/defs.h
+++ b/defs.h
@@ -2244,6 +2244,20 @@ struct offset_table { /* stash of commonly-used
offsets */
long vmap_node_busy;
long rb_list_head;
long file_f_inode;
+ long inactive_task_frame_r15;
+ long inactive_task_frame_r14;
+ long inactive_task_frame_r13;
+ long inactive_task_frame_r12;
+ long inactive_task_frame_flags;
+ long inactive_task_frame_si;
+ long inactive_task_frame_di;
+ long inactive_task_frame_bx;
+ long thread_struct_es;
+ long thread_struct_ds;
+ long thread_struct_fsbase;
+ long thread_struct_gsbase;
+ long thread_struct_fs;
+ long thread_struct_gs;
};
struct size_table { /* stash of commonly-used sizes */
@@ -8047,7 +8061,7 @@ extern int have_full_symbols(void);
/*
* Register numbers must be in sync with gdb/features/i386/64bit-core.c
- * to make crash_target->fetch_registers() ---> machdep->get_cpu_reg()
+ * to make crash_target->fetch_registers() ---> machdep->get_current_task_reg()
* working properly.
*/
enum x86_64_regnum {
@@ -8091,6 +8105,9 @@ enum x86_64_regnum {
FOSEG_REGNUM,
FOOFF_REGNUM,
FOP_REGNUM,
+ FS_BASE_REGNUM = 152,
+ GS_BASE_REGNUM,
+ ORIG_RAX_REGNUM,
LAST_REGNUM
};
diff --git a/symbols.c b/symbols.c
index acec109..b05ba33 100644
--- a/symbols.c
+++ b/symbols.c
@@ -11813,6 +11813,20 @@ dump_offset_table(char *spec, ulong makestruct)
fprintf(fp, " zs_pool_size_class: %ld\n",
OFFSET(zs_pool_size_class));
fprintf(fp, " size_class_size: %ld\n",
OFFSET(size_class_size));
fprintf(fp, " zspage_huge: %ld\n", OFFSET(zspage_huge));
+ fprintf(fp, " inactive_task_frame_r15: %ld\n",
OFFSET(inactive_task_frame_r15));
+ fprintf(fp, " inactive_task_frame_r14: %ld\n",
OFFSET(inactive_task_frame_r14));
+ fprintf(fp, " inactive_task_frame_r13: %ld\n",
OFFSET(inactive_task_frame_r13));
+ fprintf(fp, " inactive_task_frame_r12: %ld\n",
OFFSET(inactive_task_frame_r12));
+ fprintf(fp, " inactive_task_frame_flags: %ld\n",
OFFSET(inactive_task_frame_flags));
+ fprintf(fp, " inactive_task_frame_si: %ld\n",
OFFSET(inactive_task_frame_si));
+ fprintf(fp, " inactive_task_frame_di: %ld\n",
OFFSET(inactive_task_frame_di));
+ fprintf(fp, " inactive_task_frame_bx: %ld\n",
OFFSET(inactive_task_frame_bx));
+ fprintf(fp, " thread_struct_es: %ld\n",
OFFSET(thread_struct_es));
+ fprintf(fp, " thread_struct_ds: %ld\n",
OFFSET(thread_struct_ds));
+ fprintf(fp, " thread_struct_fsbase: %ld\n",
OFFSET(thread_struct_fsbase));
+ fprintf(fp, " thread_struct_gsbase: %ld\n",
OFFSET(thread_struct_gsbase));
+ fprintf(fp, " thread_struct_fs: %ld\n",
OFFSET(thread_struct_fs));
+ fprintf(fp, " thread_struct_gs: %ld\n",
OFFSET(thread_struct_gs));
fprintf(fp, "\n size_table:\n");
fprintf(fp, " page: %ld\n", SIZE(page));
diff --git a/x86_64.c b/x86_64.c
index 655b4a9..d4df730 100644
--- a/x86_64.c
+++ b/x86_64.c
@@ -126,7 +126,7 @@ static int x86_64_get_framesize(struct bt_info *, ulong, ulong, char
*);
static void x86_64_framesize_debug(struct bt_info *);
static void x86_64_get_active_set(void);
static int x86_64_get_kvaddr_ranges(struct vaddr_range *);
-static int x86_64_get_cpu_reg(int, const char *, int, void *);
+static int x86_64_get_current_task_reg(int, const char *, int, void *);
static int x86_64_verify_paddr(uint64_t);
static void GART_init(void);
static void x86_64_exception_stacks_init(void);
@@ -143,6 +143,23 @@ struct machine_specific x86_64_machine_specific = { 0 };
static const char *exception_functions_orig[];
static const char *exception_functions_5_8[];
+/* Use this hardwired version -- sometimes the
+ * debuginfo doesn't pick this up even though
+ * it exists in the kernel; it shouldn't change.
+ */
+struct x86_64_user_regs_struct {
+ unsigned long r15, r14, r13, r12, bp, bx;
+ unsigned long r11, r10, r9, r8, ax, cx, dx;
+ unsigned long si, di, orig_ax, ip, cs;
+ unsigned long flags, sp, ss, fs_base;
+ unsigned long gs_base, ds, es, fs, gs;
+};
+
+struct user_regs_bitmap_struct {
+ struct x86_64_user_regs_struct ur;
+ ulong bitmap[32];
+};
+
/*
* Do all necessary machine-specific setup here. This is called several
* times during initialization.
@@ -195,7 +212,7 @@ x86_64_init(int when)
machdep->machspec->irq_eframe_link = UNINITIALIZED;
machdep->machspec->irq_stack_gap = UNINITIALIZED;
machdep->get_kvaddr_ranges = x86_64_get_kvaddr_ranges;
- machdep->get_current_task_reg = x86_64_get_cpu_reg;
+ machdep->get_current_task_reg = x86_64_get_current_task_reg;
if (machdep->cmdline_args[0])
parse_cmdline_args();
if ((string = pc->read_vmcoreinfo("relocate"))) {
@@ -500,6 +517,12 @@ x86_64_init(int when)
MEMBER_OFFSET_INIT(thread_struct_rsp, "thread_struct", "sp");
if (INVALID_MEMBER(thread_struct_rsp0))
MEMBER_OFFSET_INIT(thread_struct_rsp0, "thread_struct", "sp0");
+ MEMBER_OFFSET_INIT(thread_struct_es, "thread_struct", "es");
+ MEMBER_OFFSET_INIT(thread_struct_ds, "thread_struct", "ds");
+ MEMBER_OFFSET_INIT(thread_struct_fsbase, "thread_struct",
"fsbase");
+ MEMBER_OFFSET_INIT(thread_struct_gsbase, "thread_struct",
"gsbase");
+ MEMBER_OFFSET_INIT(thread_struct_fs, "thread_struct", "fs");
+ MEMBER_OFFSET_INIT(thread_struct_gs, "thread_struct", "gs");
STRUCT_SIZE_INIT(tss_struct, "tss_struct");
MEMBER_OFFSET_INIT(tss_struct_ist, "tss_struct", "ist");
if (INVALID_MEMBER(tss_struct_ist)) {
@@ -583,17 +606,6 @@ x86_64_init(int when)
"user_regs_struct", "r15");
STRUCT_SIZE_INIT(user_regs_struct, "user_regs_struct");
if (!VALID_STRUCT(user_regs_struct)) {
- /* Use this hardwired version -- sometimes the
- * debuginfo doesn't pick this up even though
- * it exists in the kernel; it shouldn't change.
- */
- struct x86_64_user_regs_struct {
- unsigned long r15, r14, r13, r12, bp, bx;
- unsigned long r11, r10, r9, r8, ax, cx, dx;
- unsigned long si, di, orig_ax, ip, cs;
- unsigned long flags, sp, ss, fs_base;
- unsigned long gs_base, ds, es, fs, gs;
- };
ASSIGN_SIZE(user_regs_struct) =
sizeof(struct x86_64_user_regs_struct);
ASSIGN_OFFSET(user_regs_struct_rip) =
@@ -891,7 +903,7 @@ x86_64_dump_machdep_table(ulong arg)
fprintf(fp, " is_page_ptr: x86_64_is_page_ptr()\n");
fprintf(fp, " verify_paddr: x86_64_verify_paddr()\n");
fprintf(fp, " get_kvaddr_ranges: x86_64_get_kvaddr_ranges()\n");
- fprintf(fp, " get_cpu_reg: x86_64_get_cpu_reg()\n");
+ fprintf(fp, "get_current_task_reg: x86_64_get_current_task_reg()\n");
fprintf(fp, " init_kernel_pgd: x86_64_init_kernel_pgd()\n");
fprintf(fp, "clear_machdep_cache: x86_64_clear_machdep_cache()\n");
fprintf(fp, " xendump_p2m_create: %s\n", PVOPS_XEN() ?
@@ -4973,22 +4985,143 @@ x86_64_eframe_verify(struct bt_info *bt, long kvaddr, long cs,
long ss,
return FALSE;
}
+static ulong
+get_reg_from_inactive_task_frame(struct bt_info *bt, char *reg_name,
+ ulong reg_offset)
+{
+ ulong reg_value = 0, rsp = 0;
+ char reg_info[64];
+
+ snprintf(reg_info, sizeof(reg_info), "inactive_task_frame.%s", reg_name);
+
+ readmem(bt->task + OFFSET(task_struct_thread) +
+ OFFSET(thread_struct_rsp), KVADDR, &rsp,
+ sizeof(ulong), "thread_struct.rsp", FAULT_ON_ERROR);
+ readmem(rsp + reg_offset, KVADDR, ®_value,
+ sizeof(ulong), reg_info, FAULT_ON_ERROR);
+ return reg_value;
+}
+
+#define SET_REG_BITMAP(REGMAP, TYPE, MEMBER) \
+ SET_BIT(REGMAP, REG_SEQ(TYPE, MEMBER))
+
/*
* Get a stack frame combination of pc and ra from the most relevent spot.
*/
static void
x86_64_get_stack_frame(struct bt_info *bt, ulong *pcp, ulong *spp)
{
- if (bt->flags & BT_DUMPFILE_SEARCH)
- return x86_64_get_dumpfile_stack_frame(bt, pcp, spp);
+ struct user_regs_bitmap_struct *ur_bitmap;
+ ulong pcp_save = *pcp;
+ ulong spp_save = *spp;
+ ulong sp;
if (bt->flags & BT_SKIP_IDLE)
bt->flags &= ~BT_SKIP_IDLE;
+ if (pcp)
+ *pcp = x86_64_get_pc(bt);
+ if (spp)
+ sp = *spp = x86_64_get_sp(bt);
+ ur_bitmap = (struct user_regs_bitmap_struct *)GETBUF(sizeof(*ur_bitmap));
+ memset(ur_bitmap, 0, sizeof(*ur_bitmap));
+
+ if (VALID_MEMBER(inactive_task_frame_bp)) {
+ if (!is_task_active(bt->task)) {
+ /*
+ * For inactive tasks in live and dumpfile, regs can be
+ * get from inactive_task_frame struct.
+ */
+ ur_bitmap->ur.r15 = get_reg_from_inactive_task_frame(bt,
+ "r15", OFFSET(inactive_task_frame_r15));
+ ur_bitmap->ur.r14 = get_reg_from_inactive_task_frame(bt,
+ "r14", OFFSET(inactive_task_frame_r14));
+ ur_bitmap->ur.r13 = get_reg_from_inactive_task_frame(bt,
+ "r13", OFFSET(inactive_task_frame_r13));
+ ur_bitmap->ur.r12 = get_reg_from_inactive_task_frame(bt,
+ "r12", OFFSET(inactive_task_frame_r12));
+ ur_bitmap->ur.bx = get_reg_from_inactive_task_frame(bt,
+ "bx", OFFSET(inactive_task_frame_bx));
+ ur_bitmap->ur.bp = get_reg_from_inactive_task_frame(bt,
+ "bp", OFFSET(inactive_task_frame_bp));
+ /*
+ For inactive tasks:
+ crash> task -x 1|grep sp
+ sp = 0xffffc90000013d00
+ crash> rd ffffc90000013d00 32
+ ffffc90000013d00: ffff888104dad4a8 0000000000000000 r15,r14
+ ffffc90000013d10: ffff888100280000 ffff888100216500 r13,r12
+ ffffc90000013d20: ffff888100217018 ffff88817fd2c800 rbx,rbp
+ ffffc90000013d30: ffffffff81a6a1b3 ffffc90000013de0 saved_rip,...
+ ffffc90000013d40: ffff888100000004 99ccbf53ea493000
+ ffffc90000013d50: ffff888100216500 ffff888100216500
+
+ crash> dis __schedule
+ ...
+ 0xffffffff81a6a1ab <__schedule+507>: mov %r13,%rsi
+ 0xffffffff81a6a1ae <__schedule+510>: call 0xffffffff81003490
<__switch_to_asm>
+ 0xffffffff81a6a1b3 <__schedule+515>: mov %rax,%rdi <<=== saved_rip
+ ...
+ crash> dis __switch_to_asm
+ 0xffffffff81003490 <__switch_to_asm>: push %rbp
+ 0xffffffff81003491 <__switch_to_asm+1>: push %rbx
+ 0xffffffff81003492 <__switch_to_asm+2>: push %r12
+ 0xffffffff81003494 <__switch_to_asm+4>: push %r13
+ 0xffffffff81003496 <__switch_to_asm+6>: push %r14
+ 0xffffffff81003498 <__switch_to_asm+8>: push %r15
+ 0xffffffff8100349a <__switch_to_asm+10>: mov %rsp,0x14d8(%rdi)
+ ...
+ Now saved_rip = ffffffff81a6a1b3, and we are starting
+ the stack unwind at saved_rip, which is function __schedule()
+ instead of function __switch_to_asm(), so the stack pointer should
+ be rewind from ffffc90000013d00 back to ffffc90000013d38,
+ aka *spp += 7 * reg_len. Otherwise we are unwinding function
+ __schedule() but with __switch_to_asm()'s stack frame, which
+ will fail.
+ */
+ sp += 7 * sizeof(unsigned long);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, r15);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, r14);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, r13);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, r12);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, bx);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, bp);
+ } else {
+ /*
+ * For active tasks in dumpfile, we get regs through the
+ * original way. For active tasks in live, we only get
+ * ip and sp in the end of the function.
+ */
+ if (bt->flags & BT_DUMPFILE_SEARCH) {
+ FREEBUF(ur_bitmap);
+ bt->need_free = FALSE;
+ *pcp = pcp_save;
+ *spp = spp_save;
+ return x86_64_get_dumpfile_stack_frame(bt, pcp, spp);
+ }
+ }
+ } else {
+ if (!is_task_active(bt->task)) {
+ readmem(*spp, KVADDR, &(ur_bitmap->ur.bp),
+ sizeof(ulong), "ur_bitmap->ur.bp", FAULT_ON_ERROR);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, bp);
+ } else {
+ if (bt->flags & BT_DUMPFILE_SEARCH) {
+ FREEBUF(ur_bitmap);
+ bt->need_free = FALSE;
+ *pcp = pcp_save;
+ *spp = spp_save;
+ return x86_64_get_dumpfile_stack_frame(bt, pcp, spp);
+ }
+ }
+ }
- if (pcp)
- *pcp = x86_64_get_pc(bt);
- if (spp)
- *spp = x86_64_get_sp(bt);
+ ur_bitmap->ur.ip = *pcp;
+ ur_bitmap->ur.sp = sp;
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, ip);
+ SET_REG_BITMAP(ur_bitmap->bitmap, x86_64_user_regs_struct, sp);
+
+ bt->machdep = ur_bitmap;
+ bt->need_free = TRUE;
}
/*
@@ -6401,6 +6534,17 @@ x86_64_ORC_init(void)
};
struct ORC_data *orc;
+ MEMBER_OFFSET_INIT(inactive_task_frame_bp, "inactive_task_frame",
"bp");
+ MEMBER_OFFSET_INIT(inactive_task_frame_ret_addr, "inactive_task_frame",
"ret_addr");
+ MEMBER_OFFSET_INIT(inactive_task_frame_r15, "inactive_task_frame",
"r15");
+ MEMBER_OFFSET_INIT(inactive_task_frame_r14, "inactive_task_frame",
"r14");
+ MEMBER_OFFSET_INIT(inactive_task_frame_r13, "inactive_task_frame",
"r13");
+ MEMBER_OFFSET_INIT(inactive_task_frame_r12, "inactive_task_frame",
"r12");
+ MEMBER_OFFSET_INIT(inactive_task_frame_flags, "inactive_task_frame",
"flags");
+ MEMBER_OFFSET_INIT(inactive_task_frame_si, "inactive_task_frame",
"si");
+ MEMBER_OFFSET_INIT(inactive_task_frame_di, "inactive_task_frame",
"di");
+ MEMBER_OFFSET_INIT(inactive_task_frame_bx, "inactive_task_frame",
"bx");
+
if (machdep->flags & FRAMEPOINTER)
return;
@@ -6458,9 +6602,6 @@ x86_64_ORC_init(void)
orc->__stop_orc_unwind = symbol_value("__stop_orc_unwind");
orc->orc_lookup = symbol_value("orc_lookup");
- MEMBER_OFFSET_INIT(inactive_task_frame_bp, "inactive_task_frame",
"bp");
- MEMBER_OFFSET_INIT(inactive_task_frame_ret_addr, "inactive_task_frame",
"ret_addr");
-
orc->has_signal = MEMBER_EXISTS("orc_entry", "signal"); /* added
at 6.3 */
orc->has_end = MEMBER_EXISTS("orc_entry", "end"); /* removed at
6.4 */
@@ -9075,25 +9216,135 @@ x86_64_get_kvaddr_ranges(struct vaddr_range *vrp)
return cnt;
}
+#define CHECK_REG_CASE(R, r) \
+ case R##_REGNUM: \
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap, \
+ REG_SEQ(x86_64_user_regs_struct, r))) { \
+ FREEBUF(ur_bitmap); \
+ return FALSE; \
+ } \
+ break;
+
+#define COPY_REG_CASE(R, r) \
+ case R##_REGNUM: \
+ if (size != sizeof(ur_bitmap->ur.r)) \
+ break; \
+ memcpy(value, &ur_bitmap->ur.r, size); \
+ ret = TRUE; \
+ break;
+
static int
-x86_64_get_cpu_reg(int regno, const char *name,
- int size, void *value)
+x86_64_get_current_task_reg(int regno, const char *name,
+ int size, void *value)
{
+ struct bt_info bt_info, bt_setup;
struct task_context *tc;
+ struct user_regs_bitmap_struct *ur_bitmap;
+ ulong ip, sp;
+ bool ret = FALSE;
+
+ switch (regno) {
+ case RAX_REGNUM ... GS_REGNUM:
+ case FS_BASE_REGNUM ... ORIG_RAX_REGNUM:
+ break;
+ default:
+ return FALSE;
+ }
tc = CURRENT_CONTEXT();
if (!tc)
return FALSE;
-
- if (regno >= LAST_REGNUM)
- return FALSE;
+
/*
* Task is active, grab CPU's registers
*/
if (is_task_active(tc->task) && VMSS_DUMPFILE())
return vmware_vmss_get_cpu_reg(tc->processor, regno, name, size, value);
- return FALSE;
+ BZERO(&bt_setup, sizeof(struct bt_info));
+ clone_bt_info(&bt_setup, &bt_info, tc);
+ fill_stackbuf(&bt_info);
+
+ // reusing the get_dumpfile_regs function to get pt regs structure
+ get_dumpfile_regs(&bt_info, &sp, &ip);
+ if (bt_info.stackbuf)
+ FREEBUF(bt_info.stackbuf);
+ ur_bitmap = (struct user_regs_bitmap_struct *)bt_info.machdep;
+ if (!ur_bitmap)
+ return FALSE;
+
+ /* Get all registers from elf notes*/
+ if (!bt_info.need_free) {
+ goto get_all;
+ }
+
+ /* Get subset registers from stack frame*/
+ switch (regno) {
+ CHECK_REG_CASE(RAX, ax);
+ CHECK_REG_CASE(RBX, bx);
+ CHECK_REG_CASE(RCX, cx);
+ CHECK_REG_CASE(RDX, dx);
+ CHECK_REG_CASE(RSI, si);
+ CHECK_REG_CASE(RDI, di);
+ CHECK_REG_CASE(RBP, bp);
+ CHECK_REG_CASE(RSP, sp);
+ CHECK_REG_CASE(R8, r8);
+ CHECK_REG_CASE(R9, r9);
+ CHECK_REG_CASE(R10, r10);
+ CHECK_REG_CASE(R11, r11);
+ CHECK_REG_CASE(R12, r12);
+ CHECK_REG_CASE(R13, r13);
+ CHECK_REG_CASE(R14, r14);
+ CHECK_REG_CASE(R15, r15);
+ CHECK_REG_CASE(RIP, ip);
+ CHECK_REG_CASE(EFLAGS, flags);
+ CHECK_REG_CASE(CS, cs);
+ CHECK_REG_CASE(SS, ss);
+ CHECK_REG_CASE(DS, ds);
+ CHECK_REG_CASE(ES, es);
+ CHECK_REG_CASE(FS, fs);
+ CHECK_REG_CASE(GS, gs);
+ CHECK_REG_CASE(FS_BASE, fs_base);
+ CHECK_REG_CASE(GS_BASE, gs_base);
+ CHECK_REG_CASE(ORIG_RAX, orig_ax);
+ }
+
+get_all:
+ switch (regno) {
+ COPY_REG_CASE(RAX, ax);
+ COPY_REG_CASE(RBX, bx);
+ COPY_REG_CASE(RCX, cx);
+ COPY_REG_CASE(RDX, dx);
+ COPY_REG_CASE(RSI, si);
+ COPY_REG_CASE(RDI, di);
+ COPY_REG_CASE(RBP, bp);
+ COPY_REG_CASE(RSP, sp);
+ COPY_REG_CASE(R8, r8);
+ COPY_REG_CASE(R9, r9);
+ COPY_REG_CASE(R10, r10);
+ COPY_REG_CASE(R11, r11);
+ COPY_REG_CASE(R12, r12);
+ COPY_REG_CASE(R13, r13);
+ COPY_REG_CASE(R14, r14);
+ COPY_REG_CASE(R15, r15);
+ COPY_REG_CASE(RIP, ip);
+ COPY_REG_CASE(EFLAGS, flags);
+ COPY_REG_CASE(CS, cs);
+ COPY_REG_CASE(SS, ss);
+ COPY_REG_CASE(DS, ds);
+ COPY_REG_CASE(ES, es);
+ COPY_REG_CASE(FS, fs);
+ COPY_REG_CASE(GS, gs);
+ COPY_REG_CASE(FS_BASE, fs_base);
+ COPY_REG_CASE(GS_BASE, gs_base);
+ COPY_REG_CASE(ORIG_RAX, orig_ax);
+ }
+
+ if (bt_info.need_free) {
+ FREEBUF(ur_bitmap);
+ bt_info.need_free = FALSE;
+ }
+ return ret;
}
/*
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 14/15] vmware_guestdump: Various format versions support
From: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
There are several versions of debug.guest format. Current version of
the code is able to parse only version 4.
Improve parser to support other known versions. Split data structures
on sub-structures and introduce a helper functions to calculate a gap
between them based on the version number. Implement additional data
structure (struct mainmeminfo_old) and logic specifically for original
(version 1) format support.
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
---
vmware_guestdump.c | 321 ++++++++++++++++++++++++++++++++-------------
1 file changed, 229 insertions(+), 92 deletions(-)
diff --git a/vmware_guestdump.c b/vmware_guestdump.c
index 5be26c8..78f37fb 100644
--- a/vmware_guestdump.c
+++ b/vmware_guestdump.c
@@ -2,6 +2,8 @@
* vmware_guestdump.c
*
* Copyright (c) 2020 VMware, Inc.
+ * Copyright (c) 2024 Broadcom. All Rights Reserved. The term "Broadcom"
+ * refers to Broadcom Inc. and/or its subsidiaries.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -13,7 +15,7 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
- * Author: Alexey Makhalov <amakhalov(a)vmware.com>
+ * Author: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
*/
#include "defs.h"
@@ -21,20 +23,31 @@
#define LOGPRX "vmw: "
-#define GUESTDUMP_VERSION 4
-#define GUESTDUMP_MAGIC1 1
-#define GUESTDUMP_MAGIC2 0
-
+/*
+ * debug.guest file layout
+ * 00000000: guest dump header, it includes:
+ * 1. Version (4 bytes) \
+ * 2. Number of Virtual CPUs (4 bytes) } - struct guestdumpheader
+ * 3. Reserved gap
+ * 4. Main Memory information - struct mainmeminfo{,_old}
+ * (use get_vcpus_offset() to get total size of guestdumpheader)
+ * vcpus_offset: ---------\
+ * 1. struct vcpu_state1 \
+ * 2. reserved gap } num_vcpus times
+ * 3. struct vcpu_state2 /
+ * 4. 4KB of reserved data /
+ * --------/
+ *
+ */
struct guestdumpheader {
uint32_t version;
uint32_t num_vcpus;
- uint8_t magic1;
- uint8_t reserved1;
- uint32_t cpu_vendor;
- uint64_t magic2;
+} __attribute__((packed)) hdr;
+
+struct mainmeminfo {
uint64_t last_addr;
uint64_t memsize_in_pages;
- uint32_t reserved2;
+ uint32_t reserved1;
uint32_t mem_holes;
struct memhole {
uint64_t ppn;
@@ -42,14 +55,36 @@ struct guestdumpheader {
} holes[2];
} __attribute__((packed));
-struct vcpu_state {
+/* Used by version 1 only */
+struct mainmeminfo_old {
+ uint64_t last_addr;
+ uint32_t memsize_in_pages;
+ uint32_t reserved1;
+ uint32_t mem_holes;
+ struct memhole1 {
+ uint32_t ppn;
+ uint32_t pages;
+ } holes[2];
+ /* There are additional fields, see get_vcpus_offset() calculation. */
+} __attribute__((packed));
+
+/* First half of vcpu_state */
+struct vcpu_state1 {
uint32_t cr0;
uint64_t cr2;
uint64_t cr3;
uint64_t cr4;
uint64_t reserved1[10];
uint64_t idt_base;
- uint16_t reserved2[21];
+} __attribute__((packed));
+
+/*
+ * Unused fields between vcpu_state1 and vcpu_state2 swill be skipped.
+ * See get_vcpu_gapsize() calculation.
+ */
+
+/* Second half of vcpu_state */
+struct vcpu_state2 {
struct x86_64_pt_regs {
uint64_t r15;
uint64_t r14;
@@ -76,9 +111,41 @@ struct vcpu_state {
uint8_t reserved3[65];
} __attribute__((packed));
+/*
+ * Returns the size of the guest dump header.
+ */
+static inline long
+get_vcpus_offset(uint32_t version, int mem_holes)
+{
+ switch (version) {
+ case 1: /* ESXi 6.7 and older */
+ return sizeof(struct guestdumpheader) + 13 + sizeof(struct mainmeminfo_old) +
+ (mem_holes == -1 ? 0 : 8 * mem_holes + 4);
+ case 3: /* ESXi 6.8 */
+ return sizeof(struct guestdumpheader) + 14 + sizeof(struct mainmeminfo);
+ case 4: /* ESXi 7.0 */
+ case 5: /* ESXi 8.0 */
+ return sizeof(struct guestdumpheader) + 14 + sizeof(struct mainmeminfo);
+ case 6: /* ESXi 8.0u2 */
+ return sizeof(struct guestdumpheader) + 15 + sizeof(struct mainmeminfo);
+
+ }
+ return 0;
+}
+
+/*
+ * Returns the size of reserved (unused) fields in the middle of vcpu_state structure.
+ */
+static inline long
+get_vcpu_gapsize(uint32_t version)
+{
+ if (version < 4)
+ return 45;
+ return 42;
+}
/*
- * vmware_guestdump is extension to vmware_vmss with ability to debug
+ * vmware_guestdump is an extension to the vmware_vmss with ability to debug
* debug.guest and debug.vmem files.
*
* debug.guest.gz and debug.vmem.gz can be obtained using following
@@ -86,81 +153,139 @@ struct vcpu_state {
* monitor.mini-suspend_on_panic = TRUE
* monitor.suspend_on_triplefault = TRUE
*
- * guestdump (debug.guest) is simplified version of *.vmss which does
- * not contain full VM state, but minimal guest state, such as memory
+ * guestdump (debug.guest) is a simplified version of the *.vmss which does
+ * not contain a full VM state, but minimal guest state, such as a memory
* layout and CPUs state, needed for debugger. is_vmware_guestdump()
* and vmware_guestdump_init() functions parse guestdump header and
- * populate vmss data structure (from vmware_vmss.c). As result, all
+ * populate vmss data structure (from vmware_vmss.c). In result, all
* handlers (except mempry_dump) from vmware_vmss.c can be reused.
*
- * debug.guest does not have dedicated header magic or signature for
- * its format. To probe debug.guest we need to perform header fields
- * and file size validity. In addition, check for the filename
- * extension, which must be ".guest".
+ * debug.guest does not have a dedicated header magic or file format signature
+ * To probe debug.guest we need to perform series of validations. In addition,
+ * we check for the filename extension, which must be ".guest".
*/
-
int
is_vmware_guestdump(char *filename)
{
- struct guestdumpheader hdr;
+ struct mainmeminfo mmi;
+ long vcpus_offset;
FILE *fp;
- uint64_t filesize, holes_sum = 0;
+ uint64_t filesize, expected_filesize, holes_sum = 0;
int i;
if (strcmp(filename + strlen(filename) - 6, ".guest"))
return FALSE;
- if ((fp = fopen(filename, "r")) == NULL) {
+ if ((fp = fopen(filename, "r")) == NULL) {
error(INFO, LOGPRX"Failed to open '%s': [Error %d] %s\n",
- filename, errno, strerror(errno));
+ filename, errno, strerror(errno));
return FALSE;
- }
+ }
if (fread(&hdr, sizeof(struct guestdumpheader), 1, fp) != 1) {
error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d]
%s\n",
- "guestdumpheader", filename, errno, strerror(errno));
+ "guestdumpheader", filename, errno, strerror(errno));
fclose(fp);
return FALSE;
}
+ vcpus_offset = get_vcpus_offset(hdr.version, -1 /* Unknown yet, adjust it later */);
+
+ if (!vcpus_offset) {
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Not supported version %d\n", hdr.version);
+ fclose(fp);
+ return FALSE;
+ }
+
+ if (hdr.version == 1) {
+ struct mainmeminfo_old tmp;
+ if (fseek(fp, vcpus_offset - sizeof(struct mainmeminfo_old), SEEK_SET) == -1) {
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n",
+ filename, errno, strerror(errno));
+ fclose(fp);
+ return FALSE;
+ }
+
+ if (fread(&tmp, sizeof(struct mainmeminfo_old), 1, fp) != 1) {
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error
%d] %s\n",
+ "mainmeminfo_old", filename, errno, strerror(errno));
+ fclose(fp);
+ return FALSE;
+ }
+ mmi.last_addr = tmp.last_addr;
+ mmi.memsize_in_pages = tmp.memsize_in_pages;
+ mmi.mem_holes = tmp.mem_holes;
+ mmi.holes[0].ppn = tmp.holes[0].ppn;
+ mmi.holes[0].pages = tmp.holes[0].pages;
+ mmi.holes[1].ppn = tmp.holes[1].ppn;
+ mmi.holes[1].pages = tmp.holes[1].pages;
+ /* vcpu_offset adjustment for mem_holes is required only for version 1. */
+ vcpus_offset = get_vcpus_offset(hdr.version, mmi.mem_holes);
+ } else {
+ if (fseek(fp, vcpus_offset - sizeof(struct mainmeminfo), SEEK_SET) == -1) {
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n",
+ filename, errno, strerror(errno));
+ fclose(fp);
+ return FALSE;
+ }
+
+ if (fread(&mmi, sizeof(struct mainmeminfo), 1, fp) != 1) {
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error
%d] %s\n",
+ "mainmeminfo", filename, errno, strerror(errno));
+ fclose(fp);
+ return FALSE;
+ }
+ }
if (fseek(fp, 0L, SEEK_END) == -1) {
- error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n",
- filename, errno, strerror(errno));
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n",
+ filename, errno, strerror(errno));
fclose(fp);
return FALSE;
}
filesize = ftell(fp);
fclose(fp);
- if (hdr.mem_holes > 2)
- goto unrecognized;
+ if (mmi.mem_holes > 2) {
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Unexpected mmi.mem_holes value %d\n",
+ mmi.mem_holes);
+ return FALSE;
+ }
- for (i = 0; i < hdr.mem_holes; i++) {
+ for (i = 0; i < mmi.mem_holes; i++) {
/* hole start page */
- vmss.regions[i].startpagenum = hdr.holes[i].ppn;
+ vmss.regions[i].startpagenum = mmi.holes[i].ppn;
/* hole end page */
- vmss.regions[i].startppn = hdr.holes[i].ppn + hdr.holes[i].pages;
- holes_sum += hdr.holes[i].pages;
+ vmss.regions[i].startppn = mmi.holes[i].ppn + mmi.holes[i].pages;
+ holes_sum += mmi.holes[i].pages;
}
- if (hdr.version != GUESTDUMP_VERSION ||
- hdr.magic1 != GUESTDUMP_MAGIC1 ||
- hdr.magic2 != GUESTDUMP_MAGIC2 ||
- (hdr.last_addr + 1) != ((hdr.memsize_in_pages + holes_sum) << VMW_PAGE_SHIFT)
||
- filesize != sizeof(struct guestdumpheader) +
- hdr.num_vcpus * (sizeof (struct vcpu_state) + VMW_PAGE_SIZE))
- goto unrecognized;
+ if ((mmi.last_addr + 1) != ((mmi.memsize_in_pages + holes_sum) << VMW_PAGE_SHIFT))
{
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Memory size check failed\n");
+ return FALSE;
+ }
+
+ expected_filesize = vcpus_offset + hdr.num_vcpus * (sizeof(struct vcpu_state1) +
+ get_vcpu_gapsize(hdr.version) + sizeof(struct vcpu_state2) + VMW_PAGE_SIZE);
+ if (filesize != expected_filesize) {
+ if (CRASHDEBUG(1))
+ error(INFO, LOGPRX"Incorrect file size: %d != %d\n",
+ filesize, expected_filesize);
+ return FALSE;
+ }
- vmss.memsize = hdr.memsize_in_pages << VMW_PAGE_SHIFT;
- vmss.regionscount = hdr.mem_holes + 1;
+ vmss.memsize = mmi.memsize_in_pages << VMW_PAGE_SHIFT;
+ vmss.regionscount = mmi.mem_holes + 1;
vmss.memoffset = 0;
vmss.num_vcpus = hdr.num_vcpus;
return TRUE;
-
-unrecognized:
- if (CRASHDEBUG(1))
- error(INFO, LOGPRX"Unrecognized debug.guest file.\n");
- return FALSE;
}
int
@@ -169,7 +294,8 @@ vmware_guestdump_init(char *filename, FILE *ofp)
FILE *fp = NULL;
int i, result = TRUE;
char *vmem_filename = NULL;
- struct vcpu_state vs;
+ struct vcpu_state1 vs1;
+ struct vcpu_state2 vs2;
char *p;
if (!machine_type("X86") && !machine_type("X86_64")) {
@@ -180,14 +306,14 @@ vmware_guestdump_init(char *filename, FILE *ofp)
goto exit;
}
- if ((fp = fopen(filename, "r")) == NULL) {
+ if ((fp = fopen(filename, "r")) == NULL) {
error(INFO, LOGPRX"Failed to open '%s': [Error %d] %s\n",
filename, errno, strerror(errno));
result = FALSE;
goto exit;
- }
+ }
- if (fseek(fp, sizeof(struct guestdumpheader), SEEK_SET) == -1) {
+ if (fseek(fp, get_vcpus_offset(hdr.version, vmss.regionscount - 1), SEEK_SET) == -1) {
error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n",
filename, errno, strerror(errno));
result = FALSE;
@@ -203,7 +329,19 @@ vmware_guestdump_init(char *filename, FILE *ofp)
}
for (i = 0; i < vmss.num_vcpus; i++) {
- if (fread(&vs, sizeof(struct vcpu_state), 1, fp) != 1) {
+ if (fread(&vs1, sizeof(struct vcpu_state1), 1, fp) != 1) {
+ error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d]
%s\n",
+ "vcpu_state", filename, errno, strerror(errno));
+ result = FALSE;
+ goto exit;
+ }
+ if (fseek(fp, get_vcpu_gapsize(hdr.version), SEEK_CUR) == -1) {
+ error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d]
%s\n",
+ "vcpu_state", filename, errno, strerror(errno));
+ result = FALSE;
+ goto exit;
+ }
+ if (fread(&vs2, sizeof(struct vcpu_state2), 1, fp) != 1) {
error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d]
%s\n",
"vcpu_state", filename, errno, strerror(errno));
result = FALSE;
@@ -217,29 +355,29 @@ vmware_guestdump_init(char *filename, FILE *ofp)
}
vmss.vcpu_regs[i] = 0;
- vmss.regs64[i]->rax = vs.regs64.rax;
- vmss.regs64[i]->rcx = vs.regs64.rcx;
- vmss.regs64[i]->rdx = vs.regs64.rdx;
- vmss.regs64[i]->rbx = vs.regs64.rbx;
- vmss.regs64[i]->rbp = vs.regs64.rbp;
- vmss.regs64[i]->rsp = vs.regs64.rsp;
- vmss.regs64[i]->rsi = vs.regs64.rsi;
- vmss.regs64[i]->rdi = vs.regs64.rdi;
- vmss.regs64[i]->r8 = vs.regs64.r8;
- vmss.regs64[i]->r9 = vs.regs64.r9;
- vmss.regs64[i]->r10 = vs.regs64.r10;
- vmss.regs64[i]->r11 = vs.regs64.r11;
- vmss.regs64[i]->r12 = vs.regs64.r12;
- vmss.regs64[i]->r13 = vs.regs64.r13;
- vmss.regs64[i]->r14 = vs.regs64.r14;
- vmss.regs64[i]->r15 = vs.regs64.r15;
- vmss.regs64[i]->idtr = vs.idt_base;
- vmss.regs64[i]->cr[0] = vs.cr0;
- vmss.regs64[i]->cr[2] = vs.cr2;
- vmss.regs64[i]->cr[3] = vs.cr3;
- vmss.regs64[i]->cr[4] = vs.cr4;
- vmss.regs64[i]->rip = vs.regs64.rip;
- vmss.regs64[i]->rflags = vs.regs64.eflags;
+ vmss.regs64[i]->rax = vs2.regs64.rax;
+ vmss.regs64[i]->rcx = vs2.regs64.rcx;
+ vmss.regs64[i]->rdx = vs2.regs64.rdx;
+ vmss.regs64[i]->rbx = vs2.regs64.rbx;
+ vmss.regs64[i]->rbp = vs2.regs64.rbp;
+ vmss.regs64[i]->rsp = vs2.regs64.rsp;
+ vmss.regs64[i]->rsi = vs2.regs64.rsi;
+ vmss.regs64[i]->rdi = vs2.regs64.rdi;
+ vmss.regs64[i]->r8 = vs2.regs64.r8;
+ vmss.regs64[i]->r9 = vs2.regs64.r9;
+ vmss.regs64[i]->r10 = vs2.regs64.r10;
+ vmss.regs64[i]->r11 = vs2.regs64.r11;
+ vmss.regs64[i]->r12 = vs2.regs64.r12;
+ vmss.regs64[i]->r13 = vs2.regs64.r13;
+ vmss.regs64[i]->r14 = vs2.regs64.r14;
+ vmss.regs64[i]->r15 = vs2.regs64.r15;
+ vmss.regs64[i]->idtr = vs1.idt_base;
+ vmss.regs64[i]->cr[0] = vs1.cr0;
+ vmss.regs64[i]->cr[2] = vs1.cr2;
+ vmss.regs64[i]->cr[3] = vs1.cr3;
+ vmss.regs64[i]->cr[4] = vs1.cr4;
+ vmss.regs64[i]->rip = vs2.regs64.rip;
+ vmss.regs64[i]->rflags = vs2.regs64.eflags;
vmss.vcpu_regs[i] = REGS_PRESENT_ALL;
}
@@ -268,9 +406,9 @@ vmware_guestdump_init(char *filename, FILE *ofp)
fprintf(ofp, LOGPRX"vmem file: %s\n\n", vmem_filename);
if (CRASHDEBUG(1)) {
- vmware_guestdump_memory_dump(ofp);
- dump_registers_for_vmss_dump();
- }
+ vmware_guestdump_memory_dump(ofp);
+ dump_registers_for_vmss_dump();
+ }
exit:
if (fp)
@@ -296,24 +434,23 @@ exit:
int
vmware_guestdump_memory_dump(FILE *ofp)
{
+ uint64_t holes_sum = 0;
+ unsigned i;
+
fprintf(ofp, "vmware_guestdump:\n");
fprintf(ofp, " Header: version=%d num_vcpus=%llu\n",
- GUESTDUMP_VERSION, (ulonglong)vmss.num_vcpus);
+ hdr.version, (ulonglong)vmss.num_vcpus);
fprintf(ofp, "Total memory: %llu\n", (ulonglong)vmss.memsize);
- if (vmss.regionscount > 1) {
- uint64_t holes_sum = 0;
- unsigned i;
- fprintf(ofp, "Memory regions[%d]:\n", vmss.regionscount);
- fprintf(ofp, " [0x%016x-", 0);
- for (i = 0; i < vmss.regionscount - 1; i++) {
- fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.regions[i].startpagenum
<< VMW_PAGE_SHIFT);
- fprintf(ofp, " [0x%016llx-", (ulonglong)vmss.regions[i].startppn <<
VMW_PAGE_SHIFT);
- holes_sum += vmss.regions[i].startppn - vmss.regions[i].startpagenum;
- }
- fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.memsize + (holes_sum <<
VMW_PAGE_SHIFT));
+ fprintf(ofp, "Memory regions[%d]:\n", vmss.regionscount);
+ fprintf(ofp, " [0x%016x-", 0);
+ for (i = 0; i < vmss.regionscount - 1; i++) {
+ fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.regions[i].startpagenum <<
VMW_PAGE_SHIFT);
+ fprintf(ofp, " [0x%016llx-", (ulonglong)vmss.regions[i].startppn <<
VMW_PAGE_SHIFT);
+ holes_sum += vmss.regions[i].startppn - vmss.regions[i].startpagenum;
}
+ fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.memsize + (holes_sum <<
VMW_PAGE_SHIFT));
return TRUE;
}
--
2.40.1
9:49 a.m.
New subject: [PATCH v7 15/15] arm64: Add gdb stack unwinding support
Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
Cc: Hari Bathini <hbathini(a)linux.ibm.com>
Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
Cc: Lianbo Jiang <lijiang(a)redhat.com>
Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
Cc: Tao Liu <ltao(a)redhat.com>
Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Cc: Aditya Gupta <adityag(a)linux.ibm.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
arm64.c | 120 ++++++++++++++++++++++++++++++++++++++++++++++++++++----
defs.h | 36 +++++++++++++++++
2 files changed, 148 insertions(+), 8 deletions(-)
diff --git a/arm64.c b/arm64.c
index 06e7451..cedaee9 100644
--- a/arm64.c
+++ b/arm64.c
@@ -120,6 +120,11 @@ static void arm64_get_struct_page_size(struct machine_specific *ms);
#define mte_tag_reset(addr) (((ulong)addr & ~mte_tag_shifted(KASAN_TAG_KERNEL)) | \
mte_tag_shifted(KASAN_TAG_KERNEL))
+struct user_regs_bitmap_struct {
+ struct arm64_pt_regs ur;
+ ulong bitmap[32];
+};
+
static inline bool is_mte_kvaddr(ulong addr)
{
/* check for ARM64_MTE enabled */
@@ -196,6 +201,94 @@ out:
machdep->is_page_ptr = arm64_vmemmap_is_page_ptr;
}
+static int
+arm64_get_current_task_reg(int regno, const char *name,
+ int size, void *value)
+{
+ struct bt_info bt_info, bt_setup;
+ struct task_context *tc;
+ struct user_regs_bitmap_struct *ur_bitmap;
+ ulong ip, sp;
+ bool ret = FALSE;
+
+ switch (regno) {
+ case X0_REGNUM ... PC_REGNUM:
+ break;
+ default:
+ return FALSE;
+ }
+
+ tc = CURRENT_CONTEXT();
+ if (!tc)
+ return FALSE;
+ BZERO(&bt_setup, sizeof(struct bt_info));
+ clone_bt_info(&bt_setup, &bt_info, tc);
+ fill_stackbuf(&bt_info);
+
+ get_dumpfile_regs(&bt_info, &sp, &ip);
+ if (bt_info.stackbuf)
+ FREEBUF(bt_info.stackbuf);
+ ur_bitmap = (struct user_regs_bitmap_struct *)bt_info.machdep;
+ if (!ur_bitmap)
+ return FALSE;
+
+ if (!bt_info.need_free) {
+ goto get_all;
+ }
+
+ switch (regno) {
+ case X0_REGNUM ... X30_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(arm64_pt_regs, regs[0]) + regno - X0_REGNUM)) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ case SP_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(arm64_pt_regs, sp))) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ case PC_REGNUM:
+ if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
+ REG_SEQ(arm64_pt_regs, pc))) {
+ FREEBUF(ur_bitmap);
+ return FALSE;
+ }
+ break;
+ }
+
+get_all:
+ switch (regno) {
+ case X0_REGNUM ... X30_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.regs[regno]))
+ break;
+ memcpy(value, &ur_bitmap->ur.regs[regno], size);
+ ret = TRUE;
+ break;
+ case SP_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.sp))
+ break;
+ memcpy(value, &ur_bitmap->ur.sp, size);
+ ret = TRUE;
+ break;
+ case PC_REGNUM:
+ if (size != sizeof(ur_bitmap->ur.pc))
+ break;
+ memcpy(value, &ur_bitmap->ur.pc, size);
+ ret = TRUE;
+ break;
+ }
+
+ if (bt_info.need_free) {
+ FREEBUF(ur_bitmap);
+ bt_info.need_free = FALSE;
+ }
+ return ret;
+}
+
/*
* Do all necessary machine-specific setup here. This is called several times
* during initialization.
@@ -520,6 +613,7 @@ arm64_init(int when)
machdep->dumpfile_init = NULL;
machdep->verify_line_number = NULL;
machdep->init_kernel_pgd = arm64_init_kernel_pgd;
+ machdep->get_current_task_reg = arm64_get_current_task_reg;
/* use machdep parameters */
arm64_calc_phys_offset();
@@ -654,6 +748,7 @@ arm64_init(int when)
*/
if (!LIVE())
arm64_get_crash_notes();
+ gdb_change_thread_context();
break;
case LOG_ONLY:
@@ -4011,6 +4106,7 @@ arm64_get_dumpfile_stackframe(struct bt_info *bt, struct
arm64_stackframe *frame
try_kernel:
frame->sp = ptregs->sp;
frame->fp = ptregs->regs[29];
+ bt->machdep = ptregs;
}
if (arm64_in_kdump_text(bt, frame) ||
@@ -4039,23 +4135,31 @@ arm64_get_stackframe(struct bt_info *bt, struct arm64_stackframe
*frame)
static void
arm64_get_stack_frame(struct bt_info *bt, ulong *pcp, ulong *spp)
{
- int ret;
+ struct user_regs_bitmap_struct *ur_bitmap;
struct arm64_stackframe stackframe = { 0 };
if (DUMPFILE() && is_task_active(bt->task)) {
- ret = arm64_get_dumpfile_stackframe(bt, &stackframe);
+ arm64_get_dumpfile_stackframe(bt, &stackframe);
+ bt->need_free = FALSE;
} else {
if (bt->flags & BT_SKIP_IDLE)
bt->flags &= ~BT_SKIP_IDLE;
- ret = arm64_get_stackframe(bt, &stackframe);
+ arm64_get_stackframe(bt, &stackframe);
+
+ ur_bitmap = (struct user_regs_bitmap_struct *)GETBUF(sizeof(*ur_bitmap));
+ memset(ur_bitmap, 0, sizeof(*ur_bitmap));
+ ur_bitmap->ur.pc = stackframe.pc;
+ ur_bitmap->ur.sp = stackframe.sp;
+ ur_bitmap->ur.regs[29] = stackframe.fp;
+ SET_BIT(ur_bitmap->bitmap, REG_SEQ(arm64_pt_regs, pc));
+ SET_BIT(ur_bitmap->bitmap, REG_SEQ(arm64_pt_regs, sp));
+ SET_BIT(ur_bitmap->bitmap, REG_SEQ(arm64_pt_regs, regs[0])
+ + X29_REGNUM - X0_REGNUM);
+ bt->machdep = ur_bitmap;
+ bt->need_free = TRUE;
}
- if (!ret)
- error(WARNING,
- "cannot determine starting stack frame for task %lx\n",
- bt->task);
-
bt->frameptr = stackframe.fp;
if (pcp)
*pcp = stackframe.pc;
diff --git a/defs.h b/defs.h
index abfa923..104ec48 100644
--- a/defs.h
+++ b/defs.h
@@ -8111,6 +8111,42 @@ enum x86_64_regnum {
LAST_REGNUM
};
+enum arm64_regnum {
+ X0_REGNUM,
+ X1_REGNUM,
+ X2_REGNUM,
+ X3_REGNUM,
+ X4_REGNUM,
+ X5_REGNUM,
+ X6_REGNUM,
+ X7_REGNUM,
+ X8_REGNUM,
+ X9_REGNUM,
+ X10_REGNUM,
+ X11_REGNUM,
+ X12_REGNUM,
+ X13_REGNUM,
+ X14_REGNUM,
+ X15_REGNUM,
+ X16_REGNUM,
+ X17_REGNUM,
+ X18_REGNUM,
+ X19_REGNUM,
+ X20_REGNUM,
+ X21_REGNUM,
+ X22_REGNUM,
+ X23_REGNUM,
+ X24_REGNUM,
+ X25_REGNUM,
+ X26_REGNUM,
+ X27_REGNUM,
+ X28_REGNUM,
+ X29_REGNUM,
+ X30_REGNUM,
+ SP_REGNUM,
+ PC_REGNUM,
+};
+
/*
* Register numbers to make crash_target->fetch_registers()
* ---> machdep->get_current_task_reg() work properly.
--
2.40.1
0
days inactive
15
days old
devel@lists.crash-utility.osci.io
20 comments
2 participants
participants (2)
-
Aditya Gupta -
Tao Liu