----- Original Message ----- > Hi Dave > > I have experienced some problems in the bt command for ARM64. It seems that > the test in arm64_print_exception_frame in arm64.c if the task is running > in > 32 or 64-bit mode in userland does not work. It "always" becomes 32-bit > mode. Example: > > crash> bt 1 > PID: 1 TASK: ffffffe1f90f8000 CPU: 2 COMMAND: "init" > #0 [ffffffe1f9103c80] __switch_to at ffffff85b6a862f8 > #1 [ffffffe1f9103ca0] __schedule at ffffff85b7b0d9b0 > #2 [ffffffe1f9103d00] schedule at ffffff85b7b0df28 > #3 [ffffffe1f9103d20] schedule_hrtimeout_range_clock at ffffff85b7b11308 > #4 [ffffffe1f9103da0] schedule_hrtimeout_range at ffffff85b7b11320 > #5 [ffffffe1f9103db0] sys_epoll_wait at ffffff85b6c394c8 > #6 [ffffffe1f9103e70] sys_epoll_pwait at ffffff85b6c396fc > #7 [ffffffe1f9103ed0] el0_svc_naked at ffffff85b6a8312c > PC: 00000004 LR: 00000000 SP: 00000000 PSTATE: 00000016 > X12: 00546694 X11: 3431206c616e6769 X10: 00546338 X9: 00000000 > X8: 00000112 X7: dfdab819254dd1e8 X6: 00000016 X5: 0000000a > X4: 00000031 X3: 00000008 X2: 00000000 X1: ffffffff > X0: 00000001 > > The register values are: > r0: 4 r1: 7ff0b27f90 > r2: 1 r3: ffffffff > r4: 0 r5: 8 > r6: 31 r7: a > r8: 16 r9: dfdab819254dd1e8 > r10: 112 r11: 0 > r12: 546338 r13: 3431206c616e6769 > r14: 546694 r15: 0 > r16: 0 r17: f04245b7 > r18: 51f2a993 r19: 5783c0 > r20: 415254 r21: 527a5c > r22: 527e04 r23: ffffffff > r24: ffffffff r25: 576000 > r26: 578000 r27: 578000 > r28: 3e8 fp: 7ff0b27ec0 > lr: 4f4f24 sp: 7ff0b27eb0 > pc: 4fb8d4 psr: 40000000 > > I have unfortunately not had the time to look for a solution, so I just want > to report what I have seen. The kernel running in the example above is > 4.4.74 and I have seen the same problem for a 4.9.40 kernel. > > Jan Yeah, even the functions that do show 64-bit user mode exception frames appear to have invalid contents. It looks like the pt_regs is not at the same fixed location on the stack where it has always been, i.e., as it gets set here unconditionally at the bottom of arm64_back_trace_cmd(): complete_user: exception_frame = bt->stacktop - USER_EFRAME_OFFSET; arm64_print_exception_frame(bt, exception_frame, USER_MODE, ofp);

Ok. I have seen this change in the pt_regs struct before but did not connect it to this problem. I see these new field in pt_regs in earlier kernel versions than 4.7, but it is probably backports. It really does not matter for the solution of the problem. The following change works for me: Change: #define USER_EFRAME_OFFSET (304) to: #define USER_EFRAME_OFFSET (STRUCT_SIZE("pt_regs") + 16) Then you might want to avoid the recalculation of the struct size. I think your patch does the same thing.

----- Original Message ----- > Ok. I have seen this change in the pt_regs struct before but did not connect > it to this problem. I see these new field in pt_regs in earlier kernel > versions than 4.7, but it is probably backports. It really does not matter > for the solution of the problem. The following change works for me: > Change: > #define USER_EFRAME_OFFSET (304) > to: > #define USER_EFRAME_OFFSET (STRUCT_SIZE("pt_regs") + 16) > > Then you might want to avoid the recalculation of the struct size. I think > your patch does the same thing. Yeah, but doing it your way makes better sense. In fact, I see that there's another commit coming down the pike in 4.14-rc1 that changes the size yet again: diff --git a/arch/arm64/include/asm/ptrace.h b/arch/arm64/include/asm/ptrace.h index 11403fd..ee72aa9 100644 --- a/arch/arm64/include/asm/ptrace.h +++ b/arch/arm64/include/asm/ptrace.h @@ -119,6 +119,7 @@ struct pt_regs { u64 syscallno; u64 orig_addr_limit; u64 unused; // maintain 16 byte alignment + u64 stackframe[2]; };

Thanks, Dave -- Crash-utility mailing list Crash-utility(a)redhat.com https://www.redhat.com/mailman/listinfo/crash-utility

----- Original Message ----- > > ----- Original Message ----- > > Ok. I have seen this change in the pt_regs struct before but did not > > connect > > it to this problem. I see these new field in pt_regs in earlier kernel > > versions than 4.7, but it is probably backports. It really does not > > matter > > for the solution of the problem. The following change works for me: > > Change: > > #define USER_EFRAME_OFFSET (304) > > to: > > #define USER_EFRAME_OFFSET (STRUCT_SIZE("pt_regs") + 16) > > > > Then you might want to avoid the recalculation of the struct size. I > > think > > your patch does the same thing. > > Yeah, but doing it your way makes better sense. In fact, I see that > there's > another commit coming down the pike in 4.14-rc1 that changes the size yet > again: > > diff --git a/arch/arm64/include/asm/ptrace.h > b/arch/arm64/include/asm/ptrace.h > index 11403fd..ee72aa9 100644 > --- a/arch/arm64/include/asm/ptrace.h > +++ b/arch/arm64/include/asm/ptrace.h > @@ -119,6 +119,7 @@ struct pt_regs { > u64 syscallno; > u64 orig_addr_limit; > u64 unused; // maintain 16 byte alignment > + u64 stackframe[2]; > }; > > Thanks, > Dave As it turns out, neither patch works for 4.14 with the kernel commit above. The stackframe[2] addition essentially accounts for the 16 bytes at the top of the stack. The pt_regs structure in 4.14 is 320 bytes: crash> pt_regs struct pt_regs { union { struct user_pt_regs user_regs; struct { u64 regs[31]; u64 sp; u64 pc; u64 pstate; }; }; u64 orig_x0; s32 syscallno; u32 unused2; u64 orig_addr_limit; u64 unused; u64 stackframe[2]; } SIZE: 320 crash> So for example, taking a user-space task with a stacktop address of ffff00000807c000: crash> eval ffff00000807c000 - 320 hexadecimal: ffff00000807bec0 decimal: 18446462598867566272 (-281474841985344) octal: 1777770000001001737300 binary: 1111111111111111000000000000000000001000000001111011111011000000 crash> Here is the pt_regs: crash> pt_regs ffff00000807bec0 -x struct pt_regs { { user_regs = { regs = {0x4, 0xffffe4ef4db0, 0x25, 0xffffffffffffffff, 0x0, 0x8, 0xffffffbb, 0x0, 0x16, 0x74, 0x65, 0x67, 0x10, 0x0, 0x1bb58f1f76129a, 0xce, 0xaaaaab21c660, 0xffffab4d35a8, 0xaaaaab1a0aa8, 0x4, 0x0, 0xffffe4ef4db0, 0x0, 0x1, 0xaaaaab180778, 0xaaaaab21c000, 0xaaaaab1803f0, 0xaaaaab21c000, 0xffffe4ef52b8, 0xffffe4ef4d70, 0xffffab4d3830}, sp = 0xffffe4ef4d70, pc = 0xffffab4d385c, pstate = 0x80000000 }, { regs = {0x4, 0xffffe4ef4db0, 0x25, 0xffffffffffffffff, 0x0, 0x8, 0xffffffbb, 0x0, 0x16, 0x74, 0x65, 0x67, 0x10, 0x0, 0x1bb58f1f76129a, 0xce, 0xaaaaab21c660, 0xffffab4d35a8, 0xaaaaab1a0aa8, 0x4, 0x0, 0xffffe4ef4db0, 0x0, 0x1, 0xaaaaab180778, 0xaaaaab21c000, 0xaaaaab1803f0, 0xaaaaab21c000, 0xffffe4ef52b8, 0xffffe4ef4d70, 0xffffab4d3830}, sp = 0xffffe4ef4d70, pc = 0xffffab4d385c, pstate = 0x80000000 } }, orig_x0 = 0x4, syscallno = 0x16, unused2 = 0x0, orig_addr_limit = 0x0, unused = 0x0, stackframe = {0x0, 0x0} } crash> So for backwards compatibility, it will be necessary to look for the new stackframe[2] field. Unfortunately there have been some other significant changes to the unwind code in 4.14, and because of them, "bt" fails completely. Dave

Dave, On Fri, Sep 22, 2017 at 03:06:00PM -0400, Dave Anderson wrote: > > Jan, > > I went back to creating a machdep->machspec->user_eframe_offset value > to be able to account for both the 4.7 and the upcoming 4.14 pt_regs > changes: > > https://github.com/crash-utility/crash/commit/c975008e61121ef8785622c3bc2... > > Again, though, note that "bt" does not work with 4.14. Even with your latest changes in 7.2.0, "bt" still has some issues: a.register dump at exception frame doesn't have correct values (due to added stackframe[] in pt_regs) b. tracing irq stack to process stack fails (due to irq-stack implementation changes and VMAP_STACK) c."bt -o" seems to have been broken for a while Attached is my tentative patch, which hopefully addresses (a) and (b). While it is still far from perfect, it may help give you a heads-up. Thanks, -Takahiro AKASHI ===8<=== From 156ec115b2a436a0738908153d676f8eeed84cb1 Mon Sep 17 00:00:00 2001 From: AKASHI Takahiro <takahiro.akashi(a)linaro.org&gt; Date: Thu, 12 Oct 2017 10:46:34 +0900 Subject: [PATCH] arm64: backtrace for v4.14 --- arm64.c | 172 ++++++++++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 136 insertions(+), 36 deletions(-) diff --git a/arm64.c b/arm64.c index 20c5d34..22c8556 100644 --- a/arm64.c +++ b/arm64.c @@ -72,6 +72,7 @@ static void arm64_cmd_mach(void); static void arm64_display_machine_stats(void); static int arm64_get_smp_cpus(void); static void arm64_clear_machdep_cache(void); +static int arm64_on_process_stack(struct bt_info *, ulong); static int arm64_in_alternate_stack(int, ulong); static int arm64_on_irq_stack(int, ulong); static void arm64_set_irq_stack(struct bt_info *); @@ -1336,29 +1337,60 @@ arm64_irq_stack_init(void) req = &request; struct machine_specific *ms = machdep->machspec; - if (!symbol_exists("irq_stack") || - !(sp = per_cpu_symbol_search("irq_stack")) || - !get_symbol_type("irq_stack", NULL, req) || - (req->typecode != TYPE_CODE_ARRAY) || - (req->target_typecode != TYPE_CODE_INT)) - return; + if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus + * sizeof(ulong))))) + error(FATAL, "cannot malloc irq_stack addresses\n"); - if (CRASHDEBUG(1)) { - fprintf(fp, "irq_stack: \n"); - fprintf(fp, " type: %s\n", - (req->typecode == TYPE_CODE_ARRAY) ? "TYPE_CODE_ARRAY" : "other"); - fprintf(fp, " target_typecode: %s\n", - req->target_typecode == TYPE_CODE_INT ? "TYPE_CODE_INT" : "other"); - fprintf(fp, " target_length: %ld\n", req->target_length); - fprintf(fp, " length: %ld\n", req->length); - } + if (symbol_exists("irq_stack") && + (sp = per_cpu_symbol_search("irq_stack")) && + get_symbol_type("irq_stack", NULL, req)) { + /* before v4.14 or CONFIG_VMAP_STACK disabled */ + if (CRASHDEBUG(1)) { + fprintf(fp, "irq_stack: \n"); + fprintf(fp, " type: %s\n", + (req->typecode == TYPE_CODE_ARRAY) ? + "TYPE_CODE_ARRAY" : "other"); + fprintf(fp, " target_typecode: %s\n", + req->target_typecode == TYPE_CODE_INT ? + "TYPE_CODE_INT" : "other"); + fprintf(fp, " target_length: %ld\n", + req->target_length); + fprintf(fp, " length: %ld\n", req->length); + } - ms->irq_stack_size = req->length; - if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus * sizeof(ulong))))) - error(FATAL, "cannot malloc irq_stack addresses\n"); + ms->irq_stack_size = req->length; + + for (i = 0; i < kt->cpus; i++) + ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; + } else if (symbol_exists("irq_stack_ptr") && + (sp = per_cpu_symbol_search("irq_stack_ptr")) && + get_symbol_type("irq_stack_ptr", NULL, req)) { + /* v4.14 and later with CONFIG_VMAP_STACK enabled */ + if (CRASHDEBUG(1)) { + fprintf(fp, "irq_stack_ptr: \n"); + fprintf(fp, " type: %x, %s\n", + (int)req->typecode, + (req->typecode == TYPE_CODE_PTR) ? + "TYPE_CODE_PTR" : "other"); + fprintf(fp, " target_typecode: %x, %s\n", + (int)req->target_typecode, + req->target_typecode == TYPE_CODE_INT ? + "TYPE_CODE_INT" : "other"); + fprintf(fp, " target_length: %ld\n", + req->target_length); + fprintf(fp, " length: %ld\n", req->length); + } + + ms->irq_stack_size = 16384; + + for (i = 0; i < kt->cpus; i++) { + ulong p; - for (i = 0; i < kt->cpus; i++) - ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; + p = kt->__per_cpu_offset[i] + sp->value; + readmem(p, KVADDR, &(ms->irq_stacks[i]), sizeof(ulong), + "IRQ stack pointer", RETURN_ON_ERROR); + } + } machdep->flags |= IRQ_STACKS; } @@ -1750,11 +1782,20 @@ arm64_display_full_frame(struct bt_info *bt, ulong sp) if (bt->frameptr == sp) return; - if (!INSTACK(sp, bt) || !INSTACK(bt->frameptr, bt)) { - if (sp == 0) - sp = bt->stacktop - USER_EFRAME_OFFSET; - else - return; + if (INSTACK(bt->frameptr, bt)) { + if (INSTACK(sp, bt)) { + /* normal case */; + } else { + if (sp == 0) + /* interrupt in user mode */ + sp = bt->stacktop - USER_EFRAME_OFFSET; + else + /* interrupt in kernel mode */ + sp = bt->stacktop; + } + } else { + error(WARNING, "full display ?\n"); + return; } words = (sp - bt->frameptr) / sizeof(ulong); @@ -1873,6 +1914,25 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer on process stack) */ if (machdep->flags & IRQ_STACKS) { + if (machdep->flags & UNW_4_14) { + if ((bt->flags & BT_IRQSTACK) && + !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { + if (arm64_on_process_stack(bt, frame->fp)) { + arm64_set_process_stack(bt); + + frame->sp = frame->fp - SIZE(pt_regs) + 16; + /* for switch_stack */ + /* fp still points to irq stack */ + bt->bptr = fp; + /* for display_full_frame */ + /* sp points to process stack */ + bt->frameptr = frame->sp; + } else { + /* irq -> user */ + return FALSE; + } + } + } else { /* !UNW_4_14 */ ms = machdep->machspec; irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - 16; @@ -1896,6 +1956,7 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) return FALSE; } } + } /* UNW_4_14 */ } return TRUE; @@ -2086,10 +2147,17 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct arm64_stackframe *frame, * We are on process stack. Just add a faked frame */ - if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) - frame->sp = ext_frame.fp - - sizeof(struct arm64_pt_regs); - else { + if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) { + if (MEMBER_EXISTS("pt_regs", "stackframe")) { + frame->sp = ext_frame.fp + - sizeof(struct arm64_pt_regs) - 16; + frame->fp = ext_frame.fp; + } else { + frame->sp = ext_frame.fp + - sizeof(struct arm64_pt_regs); + frame->fp = frame->sp; + } + } else { /* * FIXME: very exceptional case * We are already back on process stack, but @@ -2109,10 +2177,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct arm64_stackframe *frame, * Really ugly */ frame->sp = frame->fp + 0x20; + frame->fp = frame->sp; fprintf(ofp, " (Next exception frame might be wrong)\n"); } - frame->fp = frame->sp; } else { /* We are on IRQ stack */ @@ -2122,9 +2190,15 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct arm64_stackframe *frame, if (ext_frame.fp != irq_stack_ptr) { /* (2) Just add a faked frame */ - frame->sp = ext_frame.fp - - sizeof(struct arm64_pt_regs); - frame->fp = frame->sp; + if (MEMBER_EXISTS("pt_regs", "stackframe")) { + frame->sp = ext_frame.fp + - sizeof(struct arm64_pt_regs); + frame->fp = ext_frame.fp; + } else { + frame->sp = ext_frame.fp + - sizeof(struct arm64_pt_regs) - 16; + frame->fp = frame->sp; + } } else { /* * (3) @@ -2304,11 +2378,19 @@ arm64_back_trace_cmd(struct bt_info *bt) if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, bt)) { if (!(bt->flags & BT_IRQSTACK) || (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) - exception_frame = stackframe.fp - SIZE(pt_regs); + { + if (MEMBER_EXISTS("pt_regs", "stackframe")) + /* v4.14 or later */ + exception_frame = stackframe.fp + - SIZE(pt_regs) + 16; + else + exception_frame = stackframe.fp + - SIZE(pt_regs); + } } if ((bt->flags & BT_IRQSTACK) && - !arm64_on_irq_stack(bt->tc->processor, stackframe.sp)) { + !arm64_on_irq_stack(bt->tc->processor, stackframe.fp)) { bt->flags &= ~BT_IRQSTACK; if (arm64_switch_stack(bt, &stackframe, ofp) == USER_MODE) break; @@ -2424,6 +2506,8 @@ user_space: * otherwise show an exception frame. * Since exception entry code doesn't have a real * stackframe, we fake a dummy frame here. + * Note: Since we have a real stack frame in pt_regs, + * We no longer need a dummy frame on v4.14 or later. */ if (!arm64_in_exp_entry(stackframe.pc)) continue; @@ -2669,7 +2753,9 @@ arm64_switch_stack(struct bt_info *bt, struct arm64_stackframe *frame, FILE *ofp if (frame->fp == 0) return USER_MODE; - arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); + if (!(machdep->flags & UNW_4_14)) + arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); + return KERNEL_MODE; } @@ -3362,6 +3448,20 @@ arm64_clear_machdep_cache(void) { return; } +static int +arm64_on_process_stack(struct bt_info *bt, ulong stkptr) +{ + ulong stackbase, stacktop; + + stackbase = GET_STACKBASE(bt->task); + stacktop = GET_STACKTOP(bt->task); + + if ((stkptr >= stackbase) && (stkptr < stacktop)) + return TRUE; + + return FALSE; +} + static int arm64_on_irq_stack(int cpu, ulong stkptr) { -- 2.14.1

Hi Takahiro, Welcome back! It's great to get you back in the fold again... I just ran a quick test of your patch on a set of sample dumpfiles, and only found one issue. It was on a 4.2 QEMU dump where all of the active tasks were running in user-space, and all of their "bt" commands fail immediately with a "zero-size" allocation message. As it turns out, that was due to this GETBUF() call in arm64_in_kdump_text_on_irq_stack(): static int arm64_in_kdump_text_on_irq_stack(struct bt_info *bt) { int cpu; ulong stackbase; char *stackbuf; ulong *ptr, *start, *base; struct machine_specific *ms; if ((machdep->flags & (IRQ_STACKS|KDUMP_ENABLED)) != (IRQ_STACKS|KDUMP_ENABLED)) return FALSE; ms = machdep->machspec; cpu = bt->tc->processor; stackbase = ms->irq_stacks[cpu]; stackbuf = GETBUF(ms->irq_stack_size); <=== ... ms->irq_stack_size is zero because that kernel version does not have IRQ stacks. As it turns out, the problem is that your reworked arm64_irq_stack_init() is setting the IRQ_STACKS flag unconditionally at the bottom of the function. Moving the flag setting up into the two if-else segments fixes it. I'll check out the patches in detail next week, but this looks good. Thanks, Dave ----- Original Message ----- > Dave, > > On Fri, Sep 22, 2017 at 03:06:00PM -0400, Dave Anderson wrote: > > > > Jan, > > > > I went back to creating a machdep->machspec->user_eframe_offset value > > to be able to account for both the 4.7 and the upcoming 4.14 pt_regs > > changes: > > > > https://github.com/crash-utility/crash/commit/c975008e61121ef8785622c3bc2... > > > > Again, though, note that "bt" does not work with 4.14. > > Even with your latest changes in 7.2.0, "bt" still has some issues: > a.register dump at exception frame doesn't have correct values > (due to added stackframe[] in pt_regs) > b. tracing irq stack to process stack fails > (due to irq-stack implementation changes and VMAP_STACK) > c."bt -o" seems to have been broken for a while > > Attached is my tentative patch, which hopefully addresses (a) and (b). > While it is still far from perfect, it may help give you a heads-up. > > Thanks, > -Takahiro AKASHI > > ===8<=== > >From 156ec115b2a436a0738908153d676f8eeed84cb1 Mon Sep 17 00:00:00 2001 > From: AKASHI Takahiro <takahiro.akashi(a)linaro.org&gt; > Date: Thu, 12 Oct 2017 10:46:34 +0900 > Subject: [PATCH] arm64: backtrace for v4.14 > > --- > arm64.c | 172 > ++++++++++++++++++++++++++++++++++++++++++++++++++-------------- > 1 file changed, 136 insertions(+), 36 deletions(-) > > diff --git a/arm64.c b/arm64.c > index 20c5d34..22c8556 100644 > --- a/arm64.c > +++ b/arm64.c > @@ -72,6 +72,7 @@ static void arm64_cmd_mach(void); > static void arm64_display_machine_stats(void); > static int arm64_get_smp_cpus(void); > static void arm64_clear_machdep_cache(void); > +static int arm64_on_process_stack(struct bt_info *, ulong); > static int arm64_in_alternate_stack(int, ulong); > static int arm64_on_irq_stack(int, ulong); > static void arm64_set_irq_stack(struct bt_info *); > @@ -1336,29 +1337,60 @@ arm64_irq_stack_init(void) > req = &request; > struct machine_specific *ms = machdep->machspec; > > - if (!symbol_exists("irq_stack") || > - !(sp = per_cpu_symbol_search("irq_stack")) || > - !get_symbol_type("irq_stack", NULL, req) || > - (req->typecode != TYPE_CODE_ARRAY) || > - (req->target_typecode != TYPE_CODE_INT)) > - return; > + if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus > + * sizeof(ulong))))) > + error(FATAL, "cannot malloc irq_stack addresses\n"); > > - if (CRASHDEBUG(1)) { > - fprintf(fp, "irq_stack: \n"); > - fprintf(fp, " type: %s\n", > - (req->typecode == TYPE_CODE_ARRAY) ? "TYPE_CODE_ARRAY" : "other"); > - fprintf(fp, " target_typecode: %s\n", > - req->target_typecode == TYPE_CODE_INT ? "TYPE_CODE_INT" : "other"); > - fprintf(fp, " target_length: %ld\n", req->target_length); > - fprintf(fp, " length: %ld\n", req->length); > - } > + if (symbol_exists("irq_stack") && > + (sp = per_cpu_symbol_search("irq_stack")) && > + get_symbol_type("irq_stack", NULL, req)) { > + /* before v4.14 or CONFIG_VMAP_STACK disabled */ > + if (CRASHDEBUG(1)) { > + fprintf(fp, "irq_stack: \n"); > + fprintf(fp, " type: %s\n", > + (req->typecode == TYPE_CODE_ARRAY) ? > + "TYPE_CODE_ARRAY" : "other"); > + fprintf(fp, " target_typecode: %s\n", > + req->target_typecode == TYPE_CODE_INT ? > + "TYPE_CODE_INT" : "other"); > + fprintf(fp, " target_length: %ld\n", > + req->target_length); > + fprintf(fp, " length: %ld\n", req->length); > + } > > - ms->irq_stack_size = req->length; > - if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus * > sizeof(ulong))))) > - error(FATAL, "cannot malloc irq_stack addresses\n"); > + ms->irq_stack_size = req->length; > + > + for (i = 0; i < kt->cpus; i++) > + ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; > + } else if (symbol_exists("irq_stack_ptr") && > + (sp = per_cpu_symbol_search("irq_stack_ptr")) && > + get_symbol_type("irq_stack_ptr", NULL, req)) { > + /* v4.14 and later with CONFIG_VMAP_STACK enabled */ > + if (CRASHDEBUG(1)) { > + fprintf(fp, "irq_stack_ptr: \n"); > + fprintf(fp, " type: %x, %s\n", > + (int)req->typecode, > + (req->typecode == TYPE_CODE_PTR) ? > + "TYPE_CODE_PTR" : "other"); > + fprintf(fp, " target_typecode: %x, %s\n", > + (int)req->target_typecode, > + req->target_typecode == TYPE_CODE_INT ? > + "TYPE_CODE_INT" : "other"); > + fprintf(fp, " target_length: %ld\n", > + req->target_length); > + fprintf(fp, " length: %ld\n", req->length); > + } > + > + ms->irq_stack_size = 16384; > + > + for (i = 0; i < kt->cpus; i++) { > + ulong p; > > - for (i = 0; i < kt->cpus; i++) > - ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; > + p = kt->__per_cpu_offset[i] + sp->value; > + readmem(p, KVADDR, &(ms->irq_stacks[i]), sizeof(ulong), > + "IRQ stack pointer", RETURN_ON_ERROR); > + } > + } > > machdep->flags |= IRQ_STACKS; > } > @@ -1750,11 +1782,20 @@ arm64_display_full_frame(struct bt_info *bt, ulong > sp) > if (bt->frameptr == sp) > return; > > - if (!INSTACK(sp, bt) || !INSTACK(bt->frameptr, bt)) { > - if (sp == 0) > - sp = bt->stacktop - USER_EFRAME_OFFSET; > - else > - return; > + if (INSTACK(bt->frameptr, bt)) { > + if (INSTACK(sp, bt)) { > + /* normal case */; > + } else { > + if (sp == 0) > + /* interrupt in user mode */ > + sp = bt->stacktop - USER_EFRAME_OFFSET; > + else > + /* interrupt in kernel mode */ > + sp = bt->stacktop; > + } > + } else { > + error(WARNING, "full display ?\n"); > + return; > } > > words = (sp - bt->frameptr) / sizeof(ulong); > @@ -1873,6 +1914,25 @@ arm64_unwind_frame(struct bt_info *bt, struct > arm64_stackframe *frame) > * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer > on > process stack) > */ > if (machdep->flags & IRQ_STACKS) { > + if (machdep->flags & UNW_4_14) { > + if ((bt->flags & BT_IRQSTACK) && > + !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { > + if (arm64_on_process_stack(bt, frame->fp)) { > + arm64_set_process_stack(bt); > + > + frame->sp = frame->fp - SIZE(pt_regs) + 16; > + /* for switch_stack */ > + /* fp still points to irq stack */ > + bt->bptr = fp; > + /* for display_full_frame */ > + /* sp points to process stack */ > + bt->frameptr = frame->sp; > + } else { > + /* irq -> user */ > + return FALSE; > + } > + } > + } else { /* !UNW_4_14 */ > ms = machdep->machspec; > irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - > 16; > > @@ -1896,6 +1956,7 @@ arm64_unwind_frame(struct bt_info *bt, struct > arm64_stackframe *frame) > return FALSE; > } > } > + } /* UNW_4_14 */ > } > > return TRUE; > @@ -2086,10 +2147,17 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct > arm64_stackframe *frame, > * We are on process stack. Just add a faked frame > */ > > - if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) > - frame->sp = ext_frame.fp > - - sizeof(struct arm64_pt_regs); > - else { > + if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) { > + if (MEMBER_EXISTS("pt_regs", "stackframe")) { > + frame->sp = ext_frame.fp > + - sizeof(struct arm64_pt_regs) - 16; > + frame->fp = ext_frame.fp; > + } else { > + frame->sp = ext_frame.fp > + - sizeof(struct arm64_pt_regs); > + frame->fp = frame->sp; > + } > + } else { > /* > * FIXME: very exceptional case > * We are already back on process stack, but > @@ -2109,10 +2177,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct > arm64_stackframe *frame, > * Really ugly > */ > frame->sp = frame->fp + 0x20; > + frame->fp = frame->sp; > fprintf(ofp, " (Next exception frame might be wrong)\n"); > } > > - frame->fp = frame->sp; > } else { > /* We are on IRQ stack */ > > @@ -2122,9 +2190,15 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct > arm64_stackframe *frame, > if (ext_frame.fp != irq_stack_ptr) { > /* (2) Just add a faked frame */ > > - frame->sp = ext_frame.fp > - - sizeof(struct arm64_pt_regs); > - frame->fp = frame->sp; > + if (MEMBER_EXISTS("pt_regs", "stackframe")) { > + frame->sp = ext_frame.fp > + - sizeof(struct arm64_pt_regs); > + frame->fp = ext_frame.fp; > + } else { > + frame->sp = ext_frame.fp > + - sizeof(struct arm64_pt_regs) - 16; > + frame->fp = frame->sp; > + } > } else { > /* > * (3) > @@ -2304,11 +2378,19 @@ arm64_back_trace_cmd(struct bt_info *bt) > if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, bt)) > { > if (!(bt->flags & BT_IRQSTACK) || > (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) > - exception_frame = stackframe.fp - SIZE(pt_regs); > + { > + if (MEMBER_EXISTS("pt_regs", "stackframe")) > + /* v4.14 or later */ > + exception_frame = stackframe.fp > + - SIZE(pt_regs) + 16; > + else > + exception_frame = stackframe.fp > + - SIZE(pt_regs); > + } > } > > if ((bt->flags & BT_IRQSTACK) && > - !arm64_on_irq_stack(bt->tc->processor, stackframe.sp)) { > + !arm64_on_irq_stack(bt->tc->processor, stackframe.fp)) { > bt->flags &= ~BT_IRQSTACK; > if (arm64_switch_stack(bt, &stackframe, ofp) == USER_MODE) > break; > @@ -2424,6 +2506,8 @@ user_space: > * otherwise show an exception frame. > * Since exception entry code doesn't have a real > * stackframe, we fake a dummy frame here. > + * Note: Since we have a real stack frame in pt_regs, > + * We no longer need a dummy frame on v4.14 or later. > */ > if (!arm64_in_exp_entry(stackframe.pc)) > continue; > @@ -2669,7 +2753,9 @@ arm64_switch_stack(struct bt_info *bt, struct > arm64_stackframe *frame, FILE *ofp > if (frame->fp == 0) > return USER_MODE; > > - arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); > + if (!(machdep->flags & UNW_4_14)) > + arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); > + > return KERNEL_MODE; > } > > @@ -3362,6 +3448,20 @@ arm64_clear_machdep_cache(void) { > return; > } > > +static int > +arm64_on_process_stack(struct bt_info *bt, ulong stkptr) > +{ > + ulong stackbase, stacktop; > + > + stackbase = GET_STACKBASE(bt->task); > + stacktop = GET_STACKTOP(bt->task); > + > + if ((stkptr >= stackbase) && (stkptr < stacktop)) > + return TRUE; > + > + return FALSE; > +} > + > static int > arm64_on_irq_stack(int cpu, ulong stkptr) > { > -- > 2.14.1 > > -- > Crash-utility mailing list > Crash-utility(a)redhat.com > https://www.redhat.com/mailman/listinfo/crash-utility >

On Mon, Oct 16, 2017 at 03:33:45PM -0400, Dave Anderson wrote: > > Hi Takahiro, > > One question about a segment of your patch that I can't test because > I don't have a 4.14 dumpfile. Here in arm64_switch_stack(), you have > conditionalized the display of the exception frame: > > @@ -2669,7 +2753,9 @@ arm64_switch_stack(struct bt_info *bt, struct > arm64_stackframe *frame, FILE *ofp > if (frame->fp == 0) > return USER_MODE; > > - arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); > + if (!(machdep->flags & UNW_4_14)) > + arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, > ofp); > + > return KERNEL_MODE; > } > > I don't understand -- what happens with a UNW_4_14 dumpfile? One of changes made in v4.14 around entry.S is to add a "real stackframe" to exception entry code. So arm64_print_exception_frame() in main loop of arm64_back_trace_cmd() should work alike for irq and other exceptions. So I would say "redundant." === for your reference, when irq takes place, === before calling irq handler(gic_handle_irq), the process stack looks like: sp +--------+ | saved | | regs | | ... | fp +- - - - + |prev fp | |prev lr | +--------+ <--- interrupted stackframe | | | | and after entering irq handler, the irq stack looks like: sp | | fp +--------+ |prev fp | |prev lr | | ... | +--------+ <--- top of irq stack =========================== A bonus from v4.14 changes is that we are now able to observe a "hidden" stackframe under exception frame, which can only appear with "bt -o" if it works :) === before v4.14, no frame for sys_handle_crash === crash-arm64> bt PID: 1189 TASK: ffff80000d1bc100 CPU: 1 COMMAND: "sh" #0 [ffff80000cd07a30] crash_kexec at ffff0000081423a4 #1 [ffff80000cd07a60] die at ffff000008088850 #2 [ffff80000cd07aa0] __do_kernel_fault at ffff000008099900 #3 [ffff80000cd07ad0] do_page_fault at ffff0000089238e0 #4 [ffff80000cd07b40] do_translation_fault at ffff000008923920 #5 [ffff80000cd07b50] do_mem_abort at ffff000008081354 #6 [ffff80000cd07d30] el1_ia at ffff000008082600 PC: ffff000008514060 [sysrq_handle_crash+32] LR: ffff00000851404c [sysrq_handle_crash+12] SP: ffff80000cd07d30 PSTATE: 60000145 X29: ffff80000cd07d30 X28: ffff80000d1bc100 X27: ffff000008932000 X26: 0000000000000040 X25: 0000000000000123 X24: 0000000000000000 X23: 0000000000000009 X22: ffff000008ede000 X21: ffff000008ede870 X20: 0000000000000063 X19: ffff000008e51000 X18: 0000000000000010 X17: 0000ffff98268e90 X16: ffff000008200000 X15: ffffffffffffffff X14: ffff000088f2cf77 X13: ffff000008f2cf85 X12: ffff000008e39e08 X11: ffff000008536220 X10: ffff80000cd07a30 X9: 0000000000000016 X8: 6120726567676972 X7: 54203a2071527379 X6: 000000000000011a X5: 0000000000000000 X4: 0000000000000000 X3: 0000000000000000 X2: ffff80001ff60960 X1: 0000000000000000 X0: 0000000000000001 #7 [ffff80000cd07d40] __handle_sysrq at ffff00000851467c #8 [ffff80000cd07d80] write_sysrq_trigger at ffff000008514c04 #9 [ffff80000cd07da0] proc_reg_write at ffff000008266910 #10 [ffff80000cd07dc0] __vfs_write at ffff0000081fd6c4 #11 [ffff80000cd07e40] vfs_write at ffff0000081feab0 #12 [ffff80000cd07e80] sys_write at ffff000008200044 #13 [ffff80000cd07ec0] el0_svc_naked at ffff000008082f2c PC: 0000ffff98268e78 LR: 000000000040a074 SP: 0000ffffff8ad7f0 X29: 0000ffffff8ae1d0 X28: 000000000047d2c0 X27: 0000000000000000 X26: 0000000005ac2440 X25: 0000000000000000 X24: 0000000000000020 X23: 0000000005ac55e0 X22: 0000000000000002 X21: 0000000005ac55e0 X20: 0000000000000001 X19: 00000000004ae000 X18: 0000ffffff8ac758 X17: 0000ffff98268e90 X16: 0000000000000000 X15: 0000000000000008 X14: 0000ffff98218a24 X13: 0000ffffff8ad8a0 X12: 0101010101010101 X11: 0101010101010101 X10: 0101010101010101 X9: fffffffffffffff0 X8: 0000000000000040 X7: 0000000000000000 X6: 0080000080808080 X5: 0000000000000000 X4: 0000000005ac0063 X3: 0000000005ac55e1 X2: 0000000000000002 X1: 0000000005ac55e0 X0: 0000000000000001 ORIG_X0: 0000000000000001 SYSCALLNO: 40 PSTATE: 80000000 ==== v4.14 or later, see #7 === crash-arm64> bt PID: 1326 TASK: ffff80000d260e00 CPU: 1 COMMAND: "sh" #0 [ffff00000b413a20] crash_kexec at ffff00000814c010 #1 [ffff00000b413a50] die at ffff000008089088 #2 [ffff00000b413a90] __do_kernel_fault at ffff000008097ac0 #3 [ffff00000b413ac0] do_page_fault at ffff000008097bdc #4 [ffff00000b413b30] do_translation_fault at ffff000008097f60 #5 [ffff00000b413b40] do_mem_abort at ffff0000080812ac #6 [ffff00000b413d20] el1_ia at ffff000008082f10 PC: ffff000008544330 [sysrq_handle_crash+32] LR: ffff00000854431c [sysrq_handle_crash+12] SP: ffff00000b413d30 PSTATE: 60000145 X29: ffff00000b413d30 X28: ffff80000d260e00 X27: ffff0000089c1000 X26: 0000000000000040 X25: 0000000000000124 X24: 0000000000000000 X23: 0000000000000009 X22: ffff000008fda000 X21: ffff000008fdaa48 X20: 0000000000000063 X19: ffff000008f33000 X18: 0000000000000010 X17: 0000ffffa1c93e90 X16: ffff00000820b370 X15: ffffffffffffffff X14: ffff00008903c37f X13: ffff00000903c38d X12: ffff000008f19df0 X11: ffff000008566d30 X10: ffff00000b413a50 X9: 0000000000000015 X8: 54203a2071527379 X7: 53203a7172737973 X6: 000000000000010e X5: 0000000000000000 X4: 0000000000000000 X3: 0000000000000000 X2: ffff80000ef627f0 X1: 0000000000000000 X0: 0000000000000001 #7 [ffff00000b413d30] sysrq_handle_crash at ffff00000854432c #8 [ffff00000b413d40] __handle_sysrq at ffff00000854494c #9 [ffff00000b413d80] write_sysrq_trigger at ffff000008544ed4 #10 [ffff00000b413da0] proc_reg_write at ffff00000827273c #11 [ffff00000b413dc0] __vfs_write at ffff00000820ae34 #12 [ffff00000b413e40] vfs_write at ffff00000820b108 #13 [ffff00000b413e80] sys_write at ffff00000820b3b4 #14 [ffff00000b413ff0] el0_svc_naked at ffff0000080837ac PC: 0000ffffa1c93e78 LR: 000000000040a074 SP: 0000ffffd2703e60 X29: 0000ffffd2704840 X28: 000000000047d2c0 X27: 0000000000000000 X26: 000000003c71a440 X25: 0000000000000000 X24: 0000000000000020 X23: 000000003c71cf90 X22: 0000000000000002 X21: 000000003c71cf90 X20: 0000000000000001 X19: 00000000004ae000 X18: 0000ffffd2702dc8 X17: 0000ffffa1c93e90 X16: 0000000000000000 X15: 0000000000000008 X14: 0000ffffa1c43a24 X13: 0000ffffd2703f10 X12: 0101010101010101 X11: 0101010101010101 X10: 0101010101010101 X9: fffffffffffffff0 X8: 0000000000000040 X7: 0000000000000000 X6: 0080808080808080 X5: 0000000000000000 X4: 0000000000000063 X3: 000000003c71cf91 X2: 0000000000000002 X1: 000000003c71cf90 X0: 0000000000000001 ORIG_X0: 0000000000000001 SYSCALLNO: 40 PSTATE: 80000000 =========================== So I'm thinking of disabling "bt -o" for v4.14 or later since "bt -o" may partly lose its "reason d'etre." -Takahiro AKASHI > Thanks, > Dave > > > > > ----- Original Message ----- > > > > Hi Takahiro, > > > > Welcome back! It's great to get you back in the fold again... > > > > I just ran a quick test of your patch on a set of sample dumpfiles, > > and only found one issue. It was on a 4.2 QEMU dump where all of the > > active tasks were running in user-space, and all of their "bt" commands > > fail immediately with a "zero-size" allocation message. As it turns out, > > that was due to this GETBUF() call in arm64_in_kdump_text_on_irq_stack(): > > > > static int > > arm64_in_kdump_text_on_irq_stack(struct bt_info *bt) > > { > > int cpu; > > ulong stackbase; > > char *stackbuf; > > ulong *ptr, *start, *base; > > struct machine_specific *ms; > > > > if ((machdep->flags & (IRQ_STACKS|KDUMP_ENABLED)) != > > (IRQ_STACKS|KDUMP_ENABLED)) > > return FALSE; > > > > ms = machdep->machspec; > > cpu = bt->tc->processor; > > stackbase = ms->irq_stacks[cpu]; > > stackbuf = GETBUF(ms->irq_stack_size); <=== > > ... > > > > ms->irq_stack_size is zero because that kernel version does not have IRQ > > stacks. > > As it turns out, the problem is that your reworked arm64_irq_stack_init() > > is > > setting > > the IRQ_STACKS flag unconditionally at the bottom of the function. > > Moving > > the > > flag setting up into the two if-else segments fixes it. > > > > I'll check out the patches in detail next week, but this looks good. > > > > Thanks, > > Dave > > > > > > > > > > > > > > > > > > > > ----- Original Message ----- > > > Dave, > > > > > > On Fri, Sep 22, 2017 at 03:06:00PM -0400, Dave Anderson wrote: > > > > > > > > Jan, > > > > > > > > I went back to creating a machdep->machspec->user_eframe_offset value > > > > to be able to account for both the 4.7 and the upcoming 4.14 pt_regs > > > > changes: > > > > > > > > https://github.com/crash-utility/crash/commit/c975008e61121ef8785622c3bc2... > > > > > > > > Again, though, note that "bt" does not work with 4.14. > > > > > > Even with your latest changes in 7.2.0, "bt" still has some issues: > > > a.register dump at exception frame doesn't have correct values > > > (due to added stackframe[] in pt_regs) > > > b. tracing irq stack to process stack fails > > > (due to irq-stack implementation changes and VMAP_STACK) > > > c."bt -o" seems to have been broken for a while > > > > > > Attached is my tentative patch, which hopefully addresses (a) and (b). > > > While it is still far from perfect, it may help give you a heads-up. > > > > > > Thanks, > > > -Takahiro AKASHI > > > > > > ===8<=== > > > >From 156ec115b2a436a0738908153d676f8eeed84cb1 Mon Sep 17 00:00:00 2001 > > > From: AKASHI Takahiro <takahiro.akashi(a)linaro.org&gt; > > > Date: Thu, 12 Oct 2017 10:46:34 +0900 > > > Subject: [PATCH] arm64: backtrace for v4.14 > > > > > > --- > > > arm64.c | 172 > > > ++++++++++++++++++++++++++++++++++++++++++++++++++-------------- > > > 1 file changed, 136 insertions(+), 36 deletions(-) > > > > > > diff --git a/arm64.c b/arm64.c > > > index 20c5d34..22c8556 100644 > > > --- a/arm64.c > > > +++ b/arm64.c > > > @@ -72,6 +72,7 @@ static void arm64_cmd_mach(void); > > > static void arm64_display_machine_stats(void); > > > static int arm64_get_smp_cpus(void); > > > static void arm64_clear_machdep_cache(void); > > > +static int arm64_on_process_stack(struct bt_info *, ulong); > > > static int arm64_in_alternate_stack(int, ulong); > > > static int arm64_on_irq_stack(int, ulong); > > > static void arm64_set_irq_stack(struct bt_info *); > > > @@ -1336,29 +1337,60 @@ arm64_irq_stack_init(void) > > > req = &request; > > > struct machine_specific *ms = machdep->machspec; > > > > > > - if (!symbol_exists("irq_stack") || > > > - !(sp = per_cpu_symbol_search("irq_stack")) || > > > - !get_symbol_type("irq_stack", NULL, req) || > > > - (req->typecode != TYPE_CODE_ARRAY) || > > > - (req->target_typecode != TYPE_CODE_INT)) > > > - return; > > > + if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus > > > + * sizeof(ulong))))) > > > + error(FATAL, "cannot malloc irq_stack addresses\n"); > > > > > > - if (CRASHDEBUG(1)) { > > > - fprintf(fp, "irq_stack: \n"); > > > - fprintf(fp, " type: %s\n", > > > - (req->typecode == TYPE_CODE_ARRAY) ? "TYPE_CODE_ARRAY" : "other"); > > > - fprintf(fp, " target_typecode: %s\n", > > > - req->target_typecode == TYPE_CODE_INT ? "TYPE_CODE_INT" : "other"); > > > - fprintf(fp, " target_length: %ld\n", req->target_length); > > > - fprintf(fp, " length: %ld\n", req->length); > > > - } > > > + if (symbol_exists("irq_stack") && > > > + (sp = per_cpu_symbol_search("irq_stack")) && > > > + get_symbol_type("irq_stack", NULL, req)) { > > > + /* before v4.14 or CONFIG_VMAP_STACK disabled */ > > > + if (CRASHDEBUG(1)) { > > > + fprintf(fp, "irq_stack: \n"); > > > + fprintf(fp, " type: %s\n", > > > + (req->typecode == TYPE_CODE_ARRAY) ? > > > + "TYPE_CODE_ARRAY" : "other"); > > > + fprintf(fp, " target_typecode: %s\n", > > > + req->target_typecode == TYPE_CODE_INT ? > > > + "TYPE_CODE_INT" : "other"); > > > + fprintf(fp, " target_length: %ld\n", > > > + req->target_length); > > > + fprintf(fp, " length: %ld\n", req->length); > > > + } > > > > > > - ms->irq_stack_size = req->length; > > > - if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus * > > > sizeof(ulong))))) > > > - error(FATAL, "cannot malloc irq_stack addresses\n"); > > > + ms->irq_stack_size = req->length; > > > + > > > + for (i = 0; i < kt->cpus; i++) > > > + ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; > > > + } else if (symbol_exists("irq_stack_ptr") && > > > + (sp = per_cpu_symbol_search("irq_stack_ptr")) && > > > + get_symbol_type("irq_stack_ptr", NULL, req)) { > > > + /* v4.14 and later with CONFIG_VMAP_STACK enabled */ > > > + if (CRASHDEBUG(1)) { > > > + fprintf(fp, "irq_stack_ptr: \n"); > > > + fprintf(fp, " type: %x, %s\n", > > > + (int)req->typecode, > > > + (req->typecode == TYPE_CODE_PTR) ? > > > + "TYPE_CODE_PTR" : "other"); > > > + fprintf(fp, " target_typecode: %x, %s\n", > > > + (int)req->target_typecode, > > > + req->target_typecode == TYPE_CODE_INT ? > > > + "TYPE_CODE_INT" : "other"); > > > + fprintf(fp, " target_length: %ld\n", > > > + req->target_length); > > > + fprintf(fp, " length: %ld\n", req->length); > > > + } > > > + > > > + ms->irq_stack_size = 16384; > > > + > > > + for (i = 0; i < kt->cpus; i++) { > > > + ulong p; > > > > > > - for (i = 0; i < kt->cpus; i++) > > > - ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; > > > + p = kt->__per_cpu_offset[i] + sp->value; > > > + readmem(p, KVADDR, &(ms->irq_stacks[i]), sizeof(ulong), > > > + "IRQ stack pointer", RETURN_ON_ERROR); > > > + } > > > + } > > > > > > machdep->flags |= IRQ_STACKS; > > > } > > > @@ -1750,11 +1782,20 @@ arm64_display_full_frame(struct bt_info *bt, > > > ulong > > > sp) > > > if (bt->frameptr == sp) > > > return; > > > > > > - if (!INSTACK(sp, bt) || !INSTACK(bt->frameptr, bt)) { > > > - if (sp == 0) > > > - sp = bt->stacktop - USER_EFRAME_OFFSET; > > > - else > > > - return; > > > + if (INSTACK(bt->frameptr, bt)) { > > > + if (INSTACK(sp, bt)) { > > > + /* normal case */; > > > + } else { > > > + if (sp == 0) > > > + /* interrupt in user mode */ > > > + sp = bt->stacktop - USER_EFRAME_OFFSET; > > > + else > > > + /* interrupt in kernel mode */ > > > + sp = bt->stacktop; > > > + } > > > + } else { > > > + error(WARNING, "full display ?\n"); > > > + return; > > > } > > > > > > words = (sp - bt->frameptr) / sizeof(ulong); > > > @@ -1873,6 +1914,25 @@ arm64_unwind_frame(struct bt_info *bt, struct > > > arm64_stackframe *frame) > > > * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs > > > pointer > > > on > > > process stack) > > > */ > > > if (machdep->flags & IRQ_STACKS) { > > > + if (machdep->flags & UNW_4_14) { > > > + if ((bt->flags & BT_IRQSTACK) && > > > + !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { > > > + if (arm64_on_process_stack(bt, frame->fp)) { > > > + arm64_set_process_stack(bt); > > > + > > > + frame->sp = frame->fp - SIZE(pt_regs) + 16; > > > + /* for switch_stack */ > > > + /* fp still points to irq stack */ > > > + bt->bptr = fp; > > > + /* for display_full_frame */ > > > + /* sp points to process stack */ > > > + bt->frameptr = frame->sp; > > > + } else { > > > + /* irq -> user */ > > > + return FALSE; > > > + } > > > + } > > > + } else { /* !UNW_4_14 */ > > > ms = machdep->machspec; > > > irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + > > > ms->irq_stack_size - > > > 16; > > > > > > @@ -1896,6 +1956,7 @@ arm64_unwind_frame(struct bt_info *bt, struct > > > arm64_stackframe *frame) > > > return FALSE; > > > } > > > } > > > + } /* UNW_4_14 */ > > > } > > > > > > return TRUE; > > > @@ -2086,10 +2147,17 @@ arm64_unwind_frame_v2(struct bt_info *bt, > > > struct > > > arm64_stackframe *frame, > > > * We are on process stack. Just add a faked frame > > > */ > > > > > > - if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) > > > - frame->sp = ext_frame.fp > > > - - sizeof(struct arm64_pt_regs); > > > - else { > > > + if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) { > > > + if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > > + frame->sp = ext_frame.fp > > > + - sizeof(struct arm64_pt_regs) - 16; > > > + frame->fp = ext_frame.fp; > > > + } else { > > > + frame->sp = ext_frame.fp > > > + - sizeof(struct arm64_pt_regs); > > > + frame->fp = frame->sp; > > > + } > > > + } else { > > > /* > > > * FIXME: very exceptional case > > > * We are already back on process stack, but > > > @@ -2109,10 +2177,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, > > > struct > > > arm64_stackframe *frame, > > > * Really ugly > > > */ > > > frame->sp = frame->fp + 0x20; > > > + frame->fp = frame->sp; > > > fprintf(ofp, " (Next exception frame might be wrong)\n"); > > > } > > > > > > - frame->fp = frame->sp; > > > } else { > > > /* We are on IRQ stack */ > > > > > > @@ -2122,9 +2190,15 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct > > > arm64_stackframe *frame, > > > if (ext_frame.fp != irq_stack_ptr) { > > > /* (2) Just add a faked frame */ > > > > > > - frame->sp = ext_frame.fp > > > - - sizeof(struct arm64_pt_regs); > > > - frame->fp = frame->sp; > > > + if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > > + frame->sp = ext_frame.fp > > > + - sizeof(struct arm64_pt_regs); > > > + frame->fp = ext_frame.fp; > > > + } else { > > > + frame->sp = ext_frame.fp > > > + - sizeof(struct arm64_pt_regs) - 16; > > > + frame->fp = frame->sp; > > > + } > > > } else { > > > /* > > > * (3) > > > @@ -2304,11 +2378,19 @@ arm64_back_trace_cmd(struct bt_info *bt) > > > if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, > > > bt)) > > > { > > > if (!(bt->flags & BT_IRQSTACK) || > > > (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) > > > - exception_frame = stackframe.fp - SIZE(pt_regs); > > > + { > > > + if (MEMBER_EXISTS("pt_regs", "stackframe")) > > > + /* v4.14 or later */ > > > + exception_frame = stackframe.fp > > > + - SIZE(pt_regs) + 16; > > > + else > > > + exception_frame = stackframe.fp > > > + - SIZE(pt_regs); > > > + } > > > } > > > > > > if ((bt->flags & BT_IRQSTACK) && > > > - !arm64_on_irq_stack(bt->tc->processor, stackframe.sp)) { > > > + !arm64_on_irq_stack(bt->tc->processor, stackframe.fp)) { > > > bt->flags &= ~BT_IRQSTACK; > > > if (arm64_switch_stack(bt, &stackframe, ofp) == USER_MODE) > > > break; > > > @@ -2424,6 +2506,8 @@ user_space: > > > * otherwise show an exception frame. > > > * Since exception entry code doesn't have a real > > > * stackframe, we fake a dummy frame here. > > > + * Note: Since we have a real stack frame in pt_regs, > > > + * We no longer need a dummy frame on v4.14 or later. > > > */ > > > if (!arm64_in_exp_entry(stackframe.pc)) > > > continue; > > > @@ -2669,7 +2753,9 @@ arm64_switch_stack(struct bt_info *bt, struct > > > arm64_stackframe *frame, FILE *ofp > > > if (frame->fp == 0) > > > return USER_MODE; > > > > > > - arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); > > > + if (!(machdep->flags & UNW_4_14)) > > > + arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); > > > + > > > return KERNEL_MODE; > > > } > > > > > > @@ -3362,6 +3448,20 @@ arm64_clear_machdep_cache(void) { > > > return; > > > } > > > > > > +static int > > > +arm64_on_process_stack(struct bt_info *bt, ulong stkptr) > > > +{ > > > + ulong stackbase, stacktop; > > > + > > > + stackbase = GET_STACKBASE(bt->task); > > > + stacktop = GET_STACKTOP(bt->task); > > > + > > > + if ((stkptr >= stackbase) && (stkptr < stacktop)) > > > + return TRUE; > > > + > > > + return FALSE; > > > +} > > > + > > > static int > > > arm64_on_irq_stack(int cpu, ulong stkptr) > > > { > > > -- > > > 2.14.1 > > > > > > -- > > > Crash-utility mailing list > > > Crash-utility(a)redhat.com > > > https://www.redhat.com/mailman/listinfo/crash-utility > > > > > > > -- > Crash-utility mailing list > Crash-utility(a)redhat.com > https://www.redhat.com/mailman/listinfo/crash-utility -- Crash-utility mailing list Crash-utility(a)redhat.com https://www.redhat.com/mailman/listinfo/crash-utility

On Tue, Oct 17, 2017 at 03:44:36PM -0400, Dave Anderson wrote: > > Thanks Takahiro, much appreciated. Queued for crash-7.2.1: > > https://github.com/crash-utility/crash/commit/2b93c036edf2a5cc21a06a14f37... Oops, I've made small changes, nothing essential but some sort of clean-ups/readability improvements with deleting incomplete fixes against "bt -o."

Thanks, -Takahiro AKASHI ===8<=== >From 826147807e2f2e00155b41b8ab97d3083bb0e607 Mon Sep 17 00:00:00 2001 From: AKASHI Takahiro <takahiro.akashi(a)linaro.org&gt; Date: Thu, 12 Oct 2017 10:46:34 +0900 Subject: [PATCH v2] arm64: backtrace for v4.14 --- arm64.c | 212 +++++++++++++++++++++++++++++++++++++++++++++++----------------- defs.h | 3 + task.c | 2 + 3 files changed, 161 insertions(+), 56 deletions(-) diff --git a/arm64.c b/arm64.c index 20c5d34..80cb476 100644 --- a/arm64.c +++ b/arm64.c @@ -72,6 +72,7 @@ static void arm64_cmd_mach(void); static void arm64_display_machine_stats(void); static int arm64_get_smp_cpus(void); static void arm64_clear_machdep_cache(void); +static int arm64_on_process_stack(struct bt_info *, ulong); static int arm64_in_alternate_stack(int, ulong); static int arm64_on_irq_stack(int, ulong); static void arm64_set_irq_stack(struct bt_info *); @@ -611,6 +612,7 @@ arm64_dump_machdep_table(ulong arg) fprintf(fp, " exp_entry2_end: %lx\n", ms->exp_entry2_end); fprintf(fp, " panic_task_regs: %lx\n", (ulong)ms->panic_task_regs); fprintf(fp, " user_eframe_offset: %ld\n", ms->user_eframe_offset); + fprintf(fp, " kern_eframe_offset: %ld\n", ms->kern_eframe_offset); fprintf(fp, " PTE_PROT_NONE: %lx\n", ms->PTE_PROT_NONE); fprintf(fp, " PTE_FILE: "); if (ms->PTE_FILE) @@ -1336,31 +1338,64 @@ arm64_irq_stack_init(void) req = &request; struct machine_specific *ms = machdep->machspec; - if (!symbol_exists("irq_stack") || - !(sp = per_cpu_symbol_search("irq_stack")) || - !get_symbol_type("irq_stack", NULL, req) || - (req->typecode != TYPE_CODE_ARRAY) || - (req->target_typecode != TYPE_CODE_INT)) - return; + if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus + * sizeof(ulong))))) + error(FATAL, "cannot malloc irq_stack addresses\n"); - if (CRASHDEBUG(1)) { - fprintf(fp, "irq_stack: \n"); - fprintf(fp, " type: %s\n", - (req->typecode == TYPE_CODE_ARRAY) ? "TYPE_CODE_ARRAY" : "other"); - fprintf(fp, " target_typecode: %s\n", - req->target_typecode == TYPE_CODE_INT ? "TYPE_CODE_INT" : "other"); - fprintf(fp, " target_length: %ld\n", req->target_length); - fprintf(fp, " length: %ld\n", req->length); - } + if (symbol_exists("irq_stack") && + (sp = per_cpu_symbol_search("irq_stack")) && + get_symbol_type("irq_stack", NULL, req)) { + /* before v4.14 or CONFIG_VMAP_STACK disabled */ + if (CRASHDEBUG(1)) { + fprintf(fp, "irq_stack: \n"); + fprintf(fp, " type: %s\n", + (req->typecode == TYPE_CODE_ARRAY) ? + "TYPE_CODE_ARRAY" : "other"); + fprintf(fp, " target_typecode: %s\n", + req->target_typecode == TYPE_CODE_INT ? + "TYPE_CODE_INT" : "other"); + fprintf(fp, " target_length: %ld\n", + req->target_length); + fprintf(fp, " length: %ld\n", req->length); + } - ms->irq_stack_size = req->length; - if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus * sizeof(ulong))))) - error(FATAL, "cannot malloc irq_stack addresses\n"); + ms->irq_stack_size = req->length; + + for (i = 0; i < kt->cpus; i++) + ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; + + machdep->flags |= IRQ_STACKS; + } else if (symbol_exists("irq_stack_ptr") && + (sp = per_cpu_symbol_search("irq_stack_ptr")) && + get_symbol_type("irq_stack_ptr", NULL, req)) { + /* v4.14 and later with CONFIG_VMAP_STACK enabled */ + if (CRASHDEBUG(1)) { + fprintf(fp, "irq_stack_ptr: \n"); + fprintf(fp, " type: %x, %s\n", + (int)req->typecode, + (req->typecode == TYPE_CODE_PTR) ? + "TYPE_CODE_PTR" : "other"); + fprintf(fp, " target_typecode: %x, %s\n", + (int)req->target_typecode, + req->target_typecode == TYPE_CODE_INT ? + "TYPE_CODE_INT" : "other"); + fprintf(fp, " target_length: %ld\n", + req->target_length); + fprintf(fp, " length: %ld\n", req->length); + } + + ms->irq_stack_size = ARM64_IRQ_STACK_SIZE; - for (i = 0; i < kt->cpus; i++) - ms->irq_stacks[i] = kt->__per_cpu_offset[i] + sp->value; + for (i = 0; i < kt->cpus; i++) { + ulong p; - machdep->flags |= IRQ_STACKS; + p = kt->__per_cpu_offset[i] + sp->value; + readmem(p, KVADDR, &(ms->irq_stacks[i]), sizeof(ulong), + "IRQ stack pointer", RETURN_ON_ERROR); + } + + machdep->flags |= IRQ_STACKS; + } } /* @@ -1379,10 +1414,13 @@ arm64_stackframe_init(void) MEMBER_OFFSET_INIT(elf_prstatus_pr_pid, "elf_prstatus", "pr_pid"); MEMBER_OFFSET_INIT(elf_prstatus_pr_reg, "elf_prstatus", "pr_reg"); - if (MEMBER_EXISTS("pt_regs", "stackframe")) + if (MEMBER_EXISTS("pt_regs", "stackframe")) { machdep->machspec->user_eframe_offset = SIZE(pt_regs); - else + machdep->machspec->kern_eframe_offset = SIZE(pt_regs) - 16; + } else { machdep->machspec->user_eframe_offset = SIZE(pt_regs) + 16; + machdep->machspec->kern_eframe_offset = SIZE(pt_regs); + } machdep->machspec->__exception_text_start = symbol_value("__exception_text_start"); @@ -1472,6 +1510,7 @@ arm64_stackframe_init(void) #define USER_MODE (2) #define USER_EFRAME_OFFSET (machdep->machspec->user_eframe_offset) +#define KERN_EFRAME_OFFSET (machdep->machspec->kern_eframe_offset) /* * PSR bits @@ -1747,14 +1786,23 @@ arm64_display_full_frame(struct bt_info *bt, ulong sp) ulong words, addr; char buf[BUFSIZE]; - if (bt->frameptr == sp) + if (bt->frameptr >= sp) return; - if (!INSTACK(sp, bt) || !INSTACK(bt->frameptr, bt)) { - if (sp == 0) - sp = bt->stacktop - USER_EFRAME_OFFSET; - else - return; + if (INSTACK(bt->frameptr, bt)) { + if (INSTACK(sp, bt)) { + /* normal case */; + } else { + if (sp == 0) + /* interrupt in user mode */ + sp = bt->stacktop - USER_EFRAME_OFFSET; + else + /* interrupt in kernel mode */ + sp = bt->stacktop; + } + } else { + /* This is a transition case from irq to process stack. */ + return; } words = (sp - bt->frameptr) / sizeof(ulong); @@ -1860,6 +1908,38 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) if ((frame->fp == 0) && (frame->pc == 0)) return FALSE; + if (!(machdep->flags & IRQ_STACKS)) + return TRUE; + + if (machdep->flags & UNW_4_14) { + if ((bt->flags & BT_IRQSTACK) && + !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { + if (arm64_on_process_stack(bt, frame->fp)) { + arm64_set_process_stack(bt); + + frame->sp = frame->fp - KERN_EFRAME_OFFSET; + /* + * for switch_stack + * fp still points to irq stack + */ + bt->bptr = fp; + /* + * for display_full_frame + * sp points to process stack + * + * If we want to see pt_regs, + * comment out the below. + * bt->frameptr = frame->sp; + */ + } else { + /* irq -> user */ + return FALSE; + } + } + + return TRUE; + } + /* * The kernel's manner of determining the end of the IRQ stack: * @@ -1872,29 +1952,27 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) * irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id()); * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer on process stack) */ - if (machdep->flags & IRQ_STACKS) { - ms = machdep->machspec; - irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - 16; - - if (frame->sp == irq_stack_ptr) { - orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); - arm64_set_process_stack(bt); - if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp == 0))) { - ptregs = (struct arm64_pt_regs *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; - frame->sp = orig_sp; - frame->pc = ptregs->pc; - bt->bptr = fp; - if (CRASHDEBUG(1)) - error(INFO, - "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: %lx\n", - frame->fp, frame->sp, frame->pc); - } else { - error(WARNING, - "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: %lx%s\n", - orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", - frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); - return FALSE; - } + ms = machdep->machspec; + irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - 16; + + if (frame->sp == irq_stack_ptr) { + orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); + arm64_set_process_stack(bt); + if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp == 0))) { + ptregs = (struct arm64_pt_regs *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; + frame->sp = orig_sp; + frame->pc = ptregs->pc; + bt->bptr = fp; + if (CRASHDEBUG(1)) + error(INFO, + "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: %lx\n", + frame->fp, frame->sp, frame->pc); + } else { + error(WARNING, + "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: %lx%s\n", + orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", + frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); + return FALSE; } } @@ -2211,6 +2289,11 @@ arm64_back_trace_cmd(struct bt_info *bt) FILE *ofp; if (bt->flags & BT_OPT_BACK_TRACE) { + if (machdep->flags & UNW_4_14) { + error(WARNING, "\"-o\" is no longer supported for this version of kernel. Please use bt\n"); + return; + } + arm64_back_trace_cmd_v2(bt); return; } @@ -2272,7 +2355,7 @@ arm64_back_trace_cmd(struct bt_info *bt) goto complete_user; if (DUMPFILE() && is_task_active(bt->task)) { - exception_frame = stackframe.fp - SIZE(pt_regs); + exception_frame = stackframe.fp - KERN_EFRAME_OFFSET; if (arm64_is_kernel_exception_frame(bt, exception_frame)) arm64_print_exception_frame(bt, exception_frame, KERNEL_MODE, ofp); @@ -2304,11 +2387,12 @@ arm64_back_trace_cmd(struct bt_info *bt) if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, bt)) { if (!(bt->flags & BT_IRQSTACK) || (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) - exception_frame = stackframe.fp - SIZE(pt_regs); + exception_frame = stackframe.fp + - KERN_EFRAME_OFFSET; } if ((bt->flags & BT_IRQSTACK) && - !arm64_on_irq_stack(bt->tc->processor, stackframe.sp)) { + !arm64_on_irq_stack(bt->tc->processor, stackframe.fp)) { bt->flags &= ~BT_IRQSTACK; if (arm64_switch_stack(bt, &stackframe, ofp) == USER_MODE) break; @@ -2669,7 +2753,9 @@ arm64_switch_stack(struct bt_info *bt, struct arm64_stackframe *frame, FILE *ofp if (frame->fp == 0) return USER_MODE; - arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); + if (!(machdep->flags & UNW_4_14)) + arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); + return KERNEL_MODE; } @@ -3362,6 +3448,20 @@ arm64_clear_machdep_cache(void) { return; } +static int +arm64_on_process_stack(struct bt_info *bt, ulong stkptr) +{ + ulong stackbase, stacktop; + + stackbase = GET_STACKBASE(bt->task); + stacktop = GET_STACKTOP(bt->task); + + if ((stkptr >= stackbase) && (stkptr < stacktop)) + return TRUE; + + return FALSE; +} + static int arm64_on_irq_stack(int cpu, ulong stkptr) { diff --git a/defs.h b/defs.h index 7768895..a694a66 100644 --- a/defs.h +++ b/defs.h @@ -3038,6 +3038,7 @@ typedef signed int s32; #define ARM64_VMEMMAP_END (ARM64_VMEMMAP_VADDR + GIGABYTES(8UL) - 1) #define ARM64_STACK_SIZE (16384) +#define ARM64_IRQ_STACK_SIZE ARM64_STACK_SIZE #define _SECTION_SIZE_BITS 30 #define _MAX_PHYSMEM_BITS 40 @@ -3117,6 +3118,8 @@ struct machine_specific { ulong kimage_text; ulong kimage_end; ulong user_eframe_offset; + /* for v4.14 or later */ + ulong kern_eframe_offset; }; struct arm64_stackframe { diff --git a/task.c b/task.c index 2b12af0..23c2b7b 100644 --- a/task.c +++ b/task.c @@ -6750,6 +6750,8 @@ panic_search(void) fd->keyword_array[0] = FOREACH_BT; if (machine_type("S390X")) fd->flags |= FOREACH_o_FLAG; + else if (machine_type("ARM64") && (machdep->flags & UNW_4_14)) + fd->flags |= FOREACH_t_FLAG; else fd->flags |= (FOREACH_t_FLAG|FOREACH_o_FLAG); -- 2.14.1 -- Crash-utility mailing list Crash-utility(a)redhat.com https://www.redhat.com/mailman/listinfo/crash-utility

Dave, On Wed, Oct 18, 2017 at 02:12:17PM -0400, Dave Anderson wrote: > > > ----- Original Message ----- > > On Tue, Oct 17, 2017 at 03:44:36PM -0400, Dave Anderson wrote: > > > > > > Thanks Takahiro, much appreciated. Queued for crash-7.2.1: > > > > > > https://github.com/crash-utility/crash/commit/2b93c036edf2a5cc21a06a14f37... > > > > Oops, I've made small changes, nothing essential but some sort of > > clean-ups/readability improvements with deleting incomplete fixes > > against "bt -o." > > Hmmm, except it's kind of difficult to pick through the patch below > for the changes, given that it's a combination of your original patch > plus the new changes. So I can't apply it to get a clean view of > the new changes. I do see that it's mostly the stacksize and stackframe > related updates, but would it be possible for you to make a patch > that can be applied to the github sources? Here is what you requested. Pls check. Thanks, -Takahiro AKASHI ===8<=== >From 7b99a1c2e688ba81e18541c21a7d0fa70504e5bc Mon Sep 17 00:00:00 2001 From: AKASHI Takahiro <takahiro.akashi(a)linaro.org&gt; Date: Thu, 19 Oct 2017 10:18:22 +0900 Subject: [PATCH] arm64: bt: cleanup stuff --- arm64.c | 159 +++++++++++++++++++++++++++++++++------------------------------- defs.h | 3 ++ task.c | 2 + 3 files changed, 86 insertions(+), 78 deletions(-) diff --git a/arm64.c b/arm64.c index c75669b..1f742d4 100644 --- a/arm64.c +++ b/arm64.c @@ -612,6 +612,7 @@ arm64_dump_machdep_table(ulong arg) fprintf(fp, " exp_entry2_end: %lx\n", ms->exp_entry2_end); fprintf(fp, " panic_task_regs: %lx\n", (ulong)ms->panic_task_regs); fprintf(fp, " user_eframe_offset: %ld\n", ms->user_eframe_offset); + fprintf(fp, " kern_eframe_offset: %ld\n", ms->kern_eframe_offset); fprintf(fp, " PTE_PROT_NONE: %lx\n", ms->PTE_PROT_NONE); fprintf(fp, " PTE_FILE: "); if (ms->PTE_FILE) @@ -1383,7 +1384,7 @@ arm64_irq_stack_init(void) if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus * sizeof(ulong))))) error(FATAL, "cannot malloc irq_stack addresses\n"); - ms->irq_stack_size = 16384; + ms->irq_stack_size = ARM64_IRQ_STACK_SIZE; machdep->flags |= IRQ_STACKS; for (i = 0; i < kt->cpus; i++) { @@ -1410,10 +1411,13 @@ arm64_stackframe_init(void) MEMBER_OFFSET_INIT(elf_prstatus_pr_pid, "elf_prstatus", "pr_pid"); MEMBER_OFFSET_INIT(elf_prstatus_pr_reg, "elf_prstatus", "pr_reg"); - if (MEMBER_EXISTS("pt_regs", "stackframe")) + if (MEMBER_EXISTS("pt_regs", "stackframe")) { machdep->machspec->user_eframe_offset = SIZE(pt_regs); - else + machdep->machspec->kern_eframe_offset = SIZE(pt_regs) - 16; + } else { machdep->machspec->user_eframe_offset = SIZE(pt_regs) + 16; + machdep->machspec->kern_eframe_offset = SIZE(pt_regs); + } machdep->machspec->__exception_text_start = symbol_value("__exception_text_start"); @@ -1503,6 +1507,7 @@ arm64_stackframe_init(void) #define USER_MODE (2) #define USER_EFRAME_OFFSET (machdep->machspec->user_eframe_offset) +#define KERN_EFRAME_OFFSET (machdep->machspec->kern_eframe_offset) /* * PSR bits @@ -1778,7 +1783,7 @@ arm64_display_full_frame(struct bt_info *bt, ulong sp) ulong words, addr; char buf[BUFSIZE]; - if (bt->frameptr == sp) + if (bt->frameptr >= sp) return; if (INSTACK(bt->frameptr, bt)) { @@ -1793,7 +1798,7 @@ arm64_display_full_frame(struct bt_info *bt, ulong sp) sp = bt->stacktop; } } else { - /* IRQ exception frame */ + /* This is a transition case from irq to process stack. */ return; } @@ -1903,61 +1908,73 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) if (!(machdep->flags & IRQ_STACKS)) return TRUE; - /* - * The kernel's manner of determining the end of the IRQ stack: - * - * #define THREAD_SIZE 16384 - * #define THREAD_START_SP (THREAD_SIZE - 16) - * #define IRQ_STACK_START_SP THREAD_START_SP - * #define IRQ_STACK_PTR(cpu) ((unsigned long)per_cpu(irq_stack, cpu) + IRQ_STACK_START_SP) - * #define IRQ_STACK_TO_TASK_STACK(ptr) (*((unsigned long *)((ptr) - 0x08))) - * - * irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id()); - * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer on process stack) - */ + if (!(machdep->flags & IRQ_STACKS)) + return TRUE; + if (machdep->flags & UNW_4_14) { if ((bt->flags & BT_IRQSTACK) && !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { if (arm64_on_process_stack(bt, frame->fp)) { arm64_set_process_stack(bt); - frame->sp = frame->fp - SIZE(pt_regs) + 16; - /* for switch_stack */ - /* fp still points to irq stack */ + frame->sp = frame->fp - KERN_EFRAME_OFFSET; + /* + * for switch_stack + * fp still points to irq stack + */ bt->bptr = fp; - /* for display_full_frame */ - /* sp points to process stack */ - bt->frameptr = frame->sp; + /* + * for display_full_frame + * sp points to process stack + * + * If we want to see pt_regs, + * comment out the below. + * bt->frameptr = frame->sp; + */ } else { /* irq -> user */ return FALSE; } } - } else { /* !UNW_4_14 */ - ms = machdep->machspec; - irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - 16; - - if (frame->sp == irq_stack_ptr) { - orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); - arm64_set_process_stack(bt); - if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp == 0))) { - ptregs = (struct arm64_pt_regs *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; - frame->sp = orig_sp; - frame->pc = ptregs->pc; - bt->bptr = fp; - if (CRASHDEBUG(1)) - error(INFO, - "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: %lx\n", - frame->fp, frame->sp, frame->pc); - } else { - error(WARNING, - "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: %lx%s\n", - orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", - frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); - return FALSE; - } + + return TRUE; + } + + /* + * The kernel's manner of determining the end of the IRQ stack: + * + * #define THREAD_SIZE 16384 + * #define THREAD_START_SP (THREAD_SIZE - 16) + * #define IRQ_STACK_START_SP THREAD_START_SP + * #define IRQ_STACK_PTR(cpu) ((unsigned long)per_cpu(irq_stack, cpu) + IRQ_STACK_START_SP) + * #define IRQ_STACK_TO_TASK_STACK(ptr) (*((unsigned long *)((ptr) - 0x08))) + * + * irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id()); + * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer on process stack) + */ + ms = machdep->machspec; + irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - 16; + + if (frame->sp == irq_stack_ptr) { + orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); + arm64_set_process_stack(bt); + if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp == 0))) { + ptregs = (struct arm64_pt_regs *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; + frame->sp = orig_sp; + frame->pc = ptregs->pc; + bt->bptr = fp; + if (CRASHDEBUG(1)) + error(INFO, + "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: %lx\n", + frame->fp, frame->sp, frame->pc); + } else { + error(WARNING, + "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: %lx%s\n", + orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", + frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); + return FALSE; } - } /* UNW_4_14 */ + } return TRUE; } @@ -2147,17 +2164,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct arm64_stackframe *frame, * We are on process stack. Just add a faked frame */ - if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) { - if (MEMBER_EXISTS("pt_regs", "stackframe")) { - frame->sp = ext_frame.fp - - sizeof(struct arm64_pt_regs) - 16; - frame->fp = ext_frame.fp; - } else { - frame->sp = ext_frame.fp - - sizeof(struct arm64_pt_regs); - frame->fp = frame->sp; - } - } else { + if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) + frame->sp = ext_frame.fp + - sizeof(struct arm64_pt_regs); + else { /* * FIXME: very exceptional case * We are already back on process stack, but @@ -2177,10 +2187,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct arm64_stackframe *frame, * Really ugly */ frame->sp = frame->fp + 0x20; - frame->fp = frame->sp; fprintf(ofp, " (Next exception frame might be wrong)\n"); } + frame->fp = frame->sp; } else { /* We are on IRQ stack */ @@ -2190,15 +2200,9 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct arm64_stackframe *frame, if (ext_frame.fp != irq_stack_ptr) { /* (2) Just add a faked frame */ - if (MEMBER_EXISTS("pt_regs", "stackframe")) { - frame->sp = ext_frame.fp - - sizeof(struct arm64_pt_regs); - frame->fp = ext_frame.fp; - } else { - frame->sp = ext_frame.fp - - sizeof(struct arm64_pt_regs) - 16; - frame->fp = frame->sp; - } + frame->sp = ext_frame.fp + - sizeof(struct arm64_pt_regs); + frame->fp = frame->sp; } else { /* * (3) @@ -2285,6 +2289,11 @@ arm64_back_trace_cmd(struct bt_info *bt) FILE *ofp; if (bt->flags & BT_OPT_BACK_TRACE) { + if (machdep->flags & UNW_4_14) { + error(WARNING, "\"-o\" is no longer supported for this version of kernel. Please use bt\n"); + return; + } + arm64_back_trace_cmd_v2(bt); return; } @@ -2346,7 +2355,7 @@ arm64_back_trace_cmd(struct bt_info *bt) goto complete_user; if (DUMPFILE() && is_task_active(bt->task)) { - exception_frame = stackframe.fp - SIZE(pt_regs); + exception_frame = stackframe.fp - KERN_EFRAME_OFFSET; if (arm64_is_kernel_exception_frame(bt, exception_frame)) arm64_print_exception_frame(bt, exception_frame, KERNEL_MODE, ofp); @@ -2377,13 +2386,9 @@ arm64_back_trace_cmd(struct bt_info *bt) if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, bt)) { if (!(bt->flags & BT_IRQSTACK) || - (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) { - if (MEMBER_EXISTS("pt_regs", "stackframe")) - /* v4.14 or later */ - exception_frame = stackframe.fp - SIZE(pt_regs) + 16; - else - exception_frame = stackframe.fp - SIZE(pt_regs); - } + (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) + exception_frame = stackframe.fp + - KERN_EFRAME_OFFSET; } if ((bt->flags & BT_IRQSTACK) && @@ -2503,8 +2508,6 @@ user_space: * otherwise show an exception frame. * Since exception entry code doesn't have a real * stackframe, we fake a dummy frame here. - * Note: Since we have a real stack frame in pt_regs, - * We no longer need a dummy frame on v4.14 or later. */ if (!arm64_in_exp_entry(stackframe.pc)) continue; diff --git a/defs.h b/defs.h index 7768895..a694a66 100644 --- a/defs.h +++ b/defs.h @@ -3038,6 +3038,7 @@ typedef signed int s32; #define ARM64_VMEMMAP_END (ARM64_VMEMMAP_VADDR + GIGABYTES(8UL) - 1) #define ARM64_STACK_SIZE (16384) +#define ARM64_IRQ_STACK_SIZE ARM64_STACK_SIZE #define _SECTION_SIZE_BITS 30 #define _MAX_PHYSMEM_BITS 40 @@ -3117,6 +3118,8 @@ struct machine_specific { ulong kimage_text; ulong kimage_end; ulong user_eframe_offset; + /* for v4.14 or later */ + ulong kern_eframe_offset; }; struct arm64_stackframe { diff --git a/task.c b/task.c index 2b12af0..23c2b7b 100644 --- a/task.c +++ b/task.c @@ -6750,6 +6750,8 @@ panic_search(void) fd->keyword_array[0] = FOREACH_BT; if (machine_type("S390X")) fd->flags |= FOREACH_o_FLAG; + else if (machine_type("ARM64") && (machdep->flags & UNW_4_14)) + fd->flags |= FOREACH_t_FLAG; else fd->flags |= (FOREACH_t_FLAG|FOREACH_o_FLAG); -- 2.14.1 -- Crash-utility mailing list Crash-utility(a)redhat.com https://www.redhat.com/mailman/listinfo/crash-utility

----- Original Message ----- > > Hi Takahiro, > > I haven't had a chance to investigate why it fails, but with this latest > patch applied, the "bt -[fF]" option fails to show the topmost frame dump > for *all* user-space tasks. By *all* user-space tasks, I mean in pre-4.14 dumpfiles. I don't have a 4.14 dumpfile, but on a live 4.14 system, it does dump the frame. Anyway, it's caused by this diff segment: @@ -1778,7 +1783,7 @@ arm64_display_full_frame(struct bt_info *bt, ulong sp) ulong words, addr; char buf[BUFSIZE]; - if (bt->frameptr == sp) + if (bt->frameptr >= sp) return; if (INSTACK(bt->frameptr, bt)) { If I set it back to "==", it works as expected. In fact, if I set it back to "==" and run it on my live 4.14 system, it still works. So I'm not sure why it's been changed?

Dave > For example, here frame #6 is missing its dump: > > crash> bt -f 1 > PID: 1 TASK: ffffffc3e8890000 CPU: 5 COMMAND: "systemd" > #0 [ffffffc3e889bb10] __switch_to at ffffffc000084960 > ffffffc3e889bb10: ffffffc3e889bb40 ffffffc00062f99c > ffffffc3e889bb20: ffffffc3e88e1400 ffffffc3e8898000 > ffffffc3e889bb30: ffffffc00090d400 ffffffc3e88e1400 > #1 [ffffffc3e889bb40] __schedule at ffffffc00062f998 > ffffffc3e889bb40: ffffffc3e889bd00 ffffffc00062fe30 > ffffffc3e889bb50: 0000000000000000 0000000000000000 > ffffffc3e889bb60: 0000000000000000 ffffffc3e8898000 > ffffffc3e889bb70: 0000007fea93aa40 0000000000000000 > ffffffc3e889bb80: 0000000000000000 0000000000000000 > ffffffc3e889bb90: ffffffc3e3551f60 ffffffc3e3551f00 > ffffffc3e889bba0: 0000000000000000 0000000000000000 > ffffffc3e889bbb0: 0000000000000000 00000000ffffffff > ffffffc3e889bbc0: ffffffc00062fe30 ffffffc0007f3af8 > ffffffc3e889bbd0: ffffffc00098c00c ffffffc00090d400 > ffffffc3e889bbe0: ffffffc3e889bce0 ffffffc000501290 > ffffffc3e889bbf0: ffffffc3e889be88 0000000000000800 > ffffffc3e889bc00: 0000000040000040 ffffffc3e889bd50 > ffffffc3e889bc10: 0000000000000000 0000000000000000 > ffffffc3e889bc20: 0000000000000000 ffffffc3e889bc68 > ffffffc3e889bc30: ffffffc3e8890000 0000000000000000 > ffffffc3e889bc40: 0000000000000000 0000000000000000 > ffffffc3e889bc50: 0000000000000000 0000000000000000 > ffffffc3e889bc60: 0000000000000000 ffffffc000146984 > ffffffc3e889bc70: 0000000000000000 0000080040000040 > ffffffc3e889bc80: ffffffc3e3047700 4000000000000000 > ffffffc3e889bc90: ffffffc3e889bcb0 ffffffc0004ffabc > ffffffc3e889bca0: ffffffc3e3047700 ffffffc3e889be88 > ffffffc3e889bcb0: ffffffc3e889bd00 ffffffc0001e033c > ffffffc3e889bcc0: ffffffc3f9a19c18 0000000000000000 > ffffffc3e889bcd0: ffffffc3e889bdb0 0000007fea93aa40 > ffffffc3e889bce0: ffffffc3e889be38 ffffffc000502270 > ffffffc3e889bcf0: ffffffc3e889bd00 ffffffc0001e0318 > #2 [ffffffc3e889bd00] schedule at ffffffc00062fe2c > ffffffc3e889bd00: ffffffc3e889bd10 ffffffc00062f5e8 > #3 [ffffffc3e889bd10] schedule_hrtimeout_range_clock at ffffffc00062f5e4 > ffffffc3e889bd10: ffffffc3e889bdb0 ffffffc00062f610 > ffffffc3e889bd20: 0000000000000001 0000000000000001 > ffffffc3e889bd30: ffffffc3e34c8300 0000000000000000 > ffffffc3e889bd40: 0000000000000000 ffffffc3e3551f60 > ffffffc3e889bd50: ffffffc3e889bd60 ffffffc0001e0b30 > ffffffc3e889bd60: ffffffc3e889bdc0 ffffffc0001e1a28 > ffffffc3e889bd70: ffffffffffffffea 0000000000000001 > ffffffc3e889bd80: ffffffc3e34c8300 ffffffc3e8898000 > ffffffc3e889bd90: ffffffc3e889bdc0 ffffffc0001e1ae0 > ffffffc3e889bda0: 0000000000000000 0000000000000001 > #4 [ffffffc3e889bdb0] schedule_hrtimeout_range at ffffffc00062f60c > ffffffc3e889bdb0: ffffffc3e889bdc0 ffffffc0001e1b58 > #5 [ffffffc3e889bdc0] sys_epoll_wait at ffffffc0001e1b54 > ffffffc3e889bdc0: ffffffc3e889be70 ffffffc0001e1cfc > ffffffc3e889bdd0: 0000000000000004 0000000000000000 > ffffffc3e889bde0: 0000000000000001 0000000000000004 > ffffffc3e889bdf0: 0000007fea93aa40 0000000000000015 > ffffffc3e889be00: 0000000000000112 0000000000000016 > ffffffc3e889be10: ffffffc00091f000 ffffffc3e8898000 > ffffffc3e889be20: 0000000000000000 0000000000000000 > ffffffc3e889be30: ffffffc3e889be50 ffffffc000000001 > ffffffc3e889be40: 0000007fea93aa40 ffffffc300000001 > ffffffc3e889be50: ffffffc3e8890000 ffffffc0000cc8f0 > ffffffc3e889be60: ffffffc3e3551f38 ffffffc3e3551f38 > #6 [ffffffc3e889be70] sys_epoll_pwait at ffffffc0001e1cf8 > #7 [ffffffc3e889bed0] cpu_switch_to at ffffffc0000837e8 > PC: 0000007f8fb55a6c LR: 000000557a5fb704 SP: 0000007fea93a8d0 > X29: 0000007fea93a8d0 X28: 0000000000000001 X27: 000000557a712000 > X26: 000000557a683998 X25: 000000557a682ef0 X24: 000000557a681cc0 > X23: 000000558b51f920 X22: 0000000000000000 X21: 0000007fea93aa40 > X20: 0000000000000000 X19: 0000000000000004 X18: 0000000000000800 > X17: 0000007f8fb557e8 X16: 000000557a7125a0 X15: 003b9aca00000000 > X14: 000a16e0ae000000 X13: ffffffffacbd0ac2 X12: 0000000000000018 > X11: 000000003a2be47d X10: 0000000000000035 X9: 00000000000013a4 > X8: 0000000000000016 X7: 0000000000000000 X6: 0000007f8fe3f000 > X5: 0000000000000008 X4: 0000000000000000 X3: ffffffffffffffff > X2: 0000000000000001 X1: 0000007fea93aa40 X0: 0000000000000004 > ORIG_X0: 0000000000000004 SYSCALLNO: 16 PSTATE: 60000000 > > Without the patch, the dump for frame #6 is there: > > crash> bt -f 1 > PID: 1 TASK: ffffffc3e8890000 CPU: 5 COMMAND: "systemd" > #0 [ffffffc3e889bb10] __switch_to at ffffffc000084960 > ffffffc3e889bb10: ffffffc3e889bb40 ffffffc00062f99c > ffffffc3e889bb20: ffffffc3e88e1400 ffffffc3e8898000 > ffffffc3e889bb30: ffffffc00090d400 ffffffc3e88e1400 > #1 [ffffffc3e889bb40] __schedule at ffffffc00062f998 > ffffffc3e889bb40: ffffffc3e889bd00 ffffffc00062fe30 > ffffffc3e889bb50: 0000000000000000 0000000000000000 > ffffffc3e889bb60: 0000000000000000 ffffffc3e8898000 > ffffffc3e889bb70: 0000007fea93aa40 0000000000000000 > ffffffc3e889bb80: 0000000000000000 0000000000000000 > ffffffc3e889bb90: ffffffc3e3551f60 ffffffc3e3551f00 > ffffffc3e889bba0: 0000000000000000 0000000000000000 > ffffffc3e889bbb0: 0000000000000000 00000000ffffffff > ffffffc3e889bbc0: ffffffc00062fe30 ffffffc0007f3af8 > ffffffc3e889bbd0: ffffffc00098c00c ffffffc00090d400 > ffffffc3e889bbe0: ffffffc3e889bce0 ffffffc000501290 > ffffffc3e889bbf0: ffffffc3e889be88 0000000000000800 > ffffffc3e889bc00: 0000000040000040 ffffffc3e889bd50 > ffffffc3e889bc10: 0000000000000000 0000000000000000 > ffffffc3e889bc20: 0000000000000000 ffffffc3e889bc68 > ffffffc3e889bc30: ffffffc3e8890000 0000000000000000 > ffffffc3e889bc40: 0000000000000000 0000000000000000 > ffffffc3e889bc50: 0000000000000000 0000000000000000 > ffffffc3e889bc60: 0000000000000000 ffffffc000146984 > ffffffc3e889bc70: 0000000000000000 0000080040000040 > ffffffc3e889bc80: ffffffc3e3047700 4000000000000000 > ffffffc3e889bc90: ffffffc3e889bcb0 ffffffc0004ffabc > ffffffc3e889bca0: ffffffc3e3047700 ffffffc3e889be88 > ffffffc3e889bcb0: ffffffc3e889bd00 ffffffc0001e033c > ffffffc3e889bcc0: ffffffc3f9a19c18 0000000000000000 > ffffffc3e889bcd0: ffffffc3e889bdb0 0000007fea93aa40 > ffffffc3e889bce0: ffffffc3e889be38 ffffffc000502270 > ffffffc3e889bcf0: ffffffc3e889bd00 ffffffc0001e0318 > #2 [ffffffc3e889bd00] schedule at ffffffc00062fe2c > ffffffc3e889bd00: ffffffc3e889bd10 ffffffc00062f5e8 > #3 [ffffffc3e889bd10] schedule_hrtimeout_range_clock at ffffffc00062f5e4 > ffffffc3e889bd10: ffffffc3e889bdb0 ffffffc00062f610 > ffffffc3e889bd20: 0000000000000001 0000000000000001 > ffffffc3e889bd30: ffffffc3e34c8300 0000000000000000 > ffffffc3e889bd40: 0000000000000000 ffffffc3e3551f60 > ffffffc3e889bd50: ffffffc3e889bd60 ffffffc0001e0b30 > ffffffc3e889bd60: ffffffc3e889bdc0 ffffffc0001e1a28 > ffffffc3e889bd70: ffffffffffffffea 0000000000000001 > ffffffc3e889bd80: ffffffc3e34c8300 ffffffc3e8898000 > ffffffc3e889bd90: ffffffc3e889bdc0 ffffffc0001e1ae0 > ffffffc3e889bda0: 0000000000000000 0000000000000001 > #4 [ffffffc3e889bdb0] schedule_hrtimeout_range at ffffffc00062f60c > ffffffc3e889bdb0: ffffffc3e889bdc0 ffffffc0001e1b58 > #5 [ffffffc3e889bdc0] sys_epoll_wait at ffffffc0001e1b54 > ffffffc3e889bdc0: ffffffc3e889be70 ffffffc0001e1cfc > ffffffc3e889bdd0: 0000000000000004 0000000000000000 > ffffffc3e889bde0: 0000000000000001 0000000000000004 > ffffffc3e889bdf0: 0000007fea93aa40 0000000000000015 > ffffffc3e889be00: 0000000000000112 0000000000000016 > ffffffc3e889be10: ffffffc00091f000 ffffffc3e8898000 > ffffffc3e889be20: 0000000000000000 0000000000000000 > ffffffc3e889be30: ffffffc3e889be50 ffffffc000000001 > ffffffc3e889be40: 0000007fea93aa40 ffffffc300000001 > ffffffc3e889be50: ffffffc3e8890000 ffffffc0000cc8f0 > ffffffc3e889be60: ffffffc3e3551f38 ffffffc3e3551f38 > #6 [ffffffc3e889be70] sys_epoll_pwait at ffffffc0001e1cf8 > ffffffc3e889be70: 0000007fea93a8d0 ffffffc0000837ec > ffffffc3e889be80: 0000000000000004 0000000000000000 > ffffffc3e889be90: ffffffffffffffff 0000007f8fb55a6c > ffffffc3e889bea0: 0000000060000000 0000007fea9396e0 > ffffffc3e889beb0: 0000000000001010 0000000040000000 > ffffffc3e889bec0: 0000007fea93a700 ffffffc0000837ec > #7 [ffffffc3e889bed0] cpu_switch_to at ffffffc0000837e8 > PC: 0000007f8fb55a6c LR: 000000557a5fb704 SP: 0000007fea93a8d0 > X29: 0000007fea93a8d0 X28: 0000000000000001 X27: 000000557a712000 > X26: 000000557a683998 X25: 000000557a682ef0 X24: 000000557a681cc0 > X23: 000000558b51f920 X22: 0000000000000000 X21: 0000007fea93aa40 > X20: 0000000000000000 X19: 0000000000000004 X18: 0000000000000800 > X17: 0000007f8fb557e8 X16: 000000557a7125a0 X15: 003b9aca00000000 > X14: 000a16e0ae000000 X13: ffffffffacbd0ac2 X12: 0000000000000018 > X11: 000000003a2be47d X10: 0000000000000035 X9: 00000000000013a4 > X8: 0000000000000016 X7: 0000000000000000 X6: 0000007f8fe3f000 > X5: 0000000000000008 X4: 0000000000000000 X3: ffffffffffffffff > X2: 0000000000000001 X1: 0000007fea93aa40 X0: 0000000000000004 > ORIG_X0: 0000000000000004 SYSCALLNO: 16 PSTATE: 60000000 > > Dave > > > > ----- Original Message ----- > > Dave, > > > > On Wed, Oct 18, 2017 at 02:12:17PM -0400, Dave Anderson wrote: > > > > > > > > > ----- Original Message ----- > > > > On Tue, Oct 17, 2017 at 03:44:36PM -0400, Dave Anderson wrote: > > > > > > > > > > Thanks Takahiro, much appreciated. Queued for crash-7.2.1: > > > > > > > > > > https://github.com/crash-utility/crash/commit/2b93c036edf2a5cc21a06a14f37... > > > > > > > > Oops, I've made small changes, nothing essential but some sort of > > > > clean-ups/readability improvements with deleting incomplete fixes > > > > against "bt -o." > > > > > > Hmmm, except it's kind of difficult to pick through the patch below > > > for the changes, given that it's a combination of your original patch > > > plus the new changes. So I can't apply it to get a clean view of > > > the new changes. I do see that it's mostly the stacksize and stackframe > > > related updates, but would it be possible for you to make a patch > > > that can be applied to the github sources? > > > > Here is what you requested. Pls check. > > > > Thanks, > > -Takahiro AKASHI > > > > ===8<=== > > >From 7b99a1c2e688ba81e18541c21a7d0fa70504e5bc Mon Sep 17 00:00:00 2001 > > From: AKASHI Takahiro <takahiro.akashi(a)linaro.org&gt; > > Date: Thu, 19 Oct 2017 10:18:22 +0900 > > Subject: [PATCH] arm64: bt: cleanup stuff > > > > --- > > arm64.c | 159 > > +++++++++++++++++++++++++++++++++------------------------------- > > defs.h | 3 ++ > > task.c | 2 + > > 3 files changed, 86 insertions(+), 78 deletions(-) > > > > diff --git a/arm64.c b/arm64.c > > index c75669b..1f742d4 100644 > > --- a/arm64.c > > +++ b/arm64.c > > @@ -612,6 +612,7 @@ arm64_dump_machdep_table(ulong arg) > > fprintf(fp, " exp_entry2_end: %lx\n", ms->exp_entry2_end); > > fprintf(fp, " panic_task_regs: %lx\n", (ulong)ms->panic_task_regs); > > fprintf(fp, " user_eframe_offset: %ld\n", ms->user_eframe_offset); > > + fprintf(fp, " kern_eframe_offset: %ld\n", ms->kern_eframe_offset); > > fprintf(fp, " PTE_PROT_NONE: %lx\n", ms->PTE_PROT_NONE); > > fprintf(fp, " PTE_FILE: "); > > if (ms->PTE_FILE) > > @@ -1383,7 +1384,7 @@ arm64_irq_stack_init(void) > > > > if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus * > > sizeof(ulong))))) > > error(FATAL, "cannot malloc irq_stack addresses\n"); > > - ms->irq_stack_size = 16384; > > + ms->irq_stack_size = ARM64_IRQ_STACK_SIZE; > > machdep->flags |= IRQ_STACKS; > > > > for (i = 0; i < kt->cpus; i++) { > > @@ -1410,10 +1411,13 @@ arm64_stackframe_init(void) > > MEMBER_OFFSET_INIT(elf_prstatus_pr_pid, "elf_prstatus", "pr_pid"); > > MEMBER_OFFSET_INIT(elf_prstatus_pr_reg, "elf_prstatus", "pr_reg"); > > > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) > > + if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > machdep->machspec->user_eframe_offset = SIZE(pt_regs); > > - else > > + machdep->machspec->kern_eframe_offset = SIZE(pt_regs) - 16; > > + } else { > > machdep->machspec->user_eframe_offset = SIZE(pt_regs) + 16; > > + machdep->machspec->kern_eframe_offset = SIZE(pt_regs); > > + } > > > > machdep->machspec->__exception_text_start = > > symbol_value("__exception_text_start"); > > @@ -1503,6 +1507,7 @@ arm64_stackframe_init(void) > > #define USER_MODE (2) > > > > #define USER_EFRAME_OFFSET (machdep->machspec->user_eframe_offset) > > +#define KERN_EFRAME_OFFSET (machdep->machspec->kern_eframe_offset) > > > > /* > > * PSR bits > > @@ -1778,7 +1783,7 @@ arm64_display_full_frame(struct bt_info *bt, ulong > > sp) > > ulong words, addr; > > char buf[BUFSIZE]; > > > > - if (bt->frameptr == sp) > > + if (bt->frameptr >= sp) > > return; > > > > if (INSTACK(bt->frameptr, bt)) { > > @@ -1793,7 +1798,7 @@ arm64_display_full_frame(struct bt_info *bt, ulong > > sp) > > sp = bt->stacktop; > > } > > } else { > > - /* IRQ exception frame */ > > + /* This is a transition case from irq to process stack. */ > > return; > > } > > > > @@ -1903,61 +1908,73 @@ arm64_unwind_frame(struct bt_info *bt, struct > > arm64_stackframe *frame) > > if (!(machdep->flags & IRQ_STACKS)) > > return TRUE; > > > > - /* > > - * The kernel's manner of determining the end of the IRQ stack: > > - * > > - * #define THREAD_SIZE 16384 > > - * #define THREAD_START_SP (THREAD_SIZE - 16) > > - * #define IRQ_STACK_START_SP THREAD_START_SP > > - * #define IRQ_STACK_PTR(cpu) ((unsigned long)per_cpu(irq_stack, cpu) + > > IRQ_STACK_START_SP) > > - * #define IRQ_STACK_TO_TASK_STACK(ptr) (*((unsigned long *)((ptr) - > > 0x08))) > > - * > > - * irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id()); > > - * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer > > on > > process stack) > > - */ > > + if (!(machdep->flags & IRQ_STACKS)) > > + return TRUE; > > + > > if (machdep->flags & UNW_4_14) { > > if ((bt->flags & BT_IRQSTACK) && > > !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { > > if (arm64_on_process_stack(bt, frame->fp)) { > > arm64_set_process_stack(bt); > > > > - frame->sp = frame->fp - SIZE(pt_regs) + 16; > > - /* for switch_stack */ > > - /* fp still points to irq stack */ > > + frame->sp = frame->fp - KERN_EFRAME_OFFSET; > > + /* > > + * for switch_stack > > + * fp still points to irq stack > > + */ > > bt->bptr = fp; > > - /* for display_full_frame */ > > - /* sp points to process stack */ > > - bt->frameptr = frame->sp; > > + /* > > + * for display_full_frame > > + * sp points to process stack > > + * > > + * If we want to see pt_regs, > > + * comment out the below. > > + * bt->frameptr = frame->sp; > > + */ > > } else { > > /* irq -> user */ > > return FALSE; > > } > > } > > - } else { /* !UNW_4_14 */ > > - ms = machdep->machspec; > > - irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - > > 16; > > - > > - if (frame->sp == irq_stack_ptr) { > > - orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); > > - arm64_set_process_stack(bt); > > - if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp == > > 0))) > > { > > - ptregs = (struct arm64_pt_regs > > *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; > > - frame->sp = orig_sp; > > - frame->pc = ptregs->pc; > > - bt->bptr = fp; > > - if (CRASHDEBUG(1)) > > - error(INFO, > > - "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: %lx\n", > > - frame->fp, frame->sp, frame->pc); > > - } else { > > - error(WARNING, > > - "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: %lx%s\n", > > - orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", > > - frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); > > - return FALSE; > > - } > > + > > + return TRUE; > > + } > > + > > + /* > > + * The kernel's manner of determining the end of the IRQ stack: > > + * > > + * #define THREAD_SIZE 16384 > > + * #define THREAD_START_SP (THREAD_SIZE - 16) > > + * #define IRQ_STACK_START_SP THREAD_START_SP > > + * #define IRQ_STACK_PTR(cpu) ((unsigned long)per_cpu(irq_stack, cpu) + > > IRQ_STACK_START_SP) > > + * #define IRQ_STACK_TO_TASK_STACK(ptr) (*((unsigned long *)((ptr) - > > 0x08))) > > + * > > + * irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id()); > > + * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer > > on > > process stack) > > + */ > > + ms = machdep->machspec; > > + irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - > > 16; > > + > > + if (frame->sp == irq_stack_ptr) { > > + orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); > > + arm64_set_process_stack(bt); > > + if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp == > > 0))) > > { > > + ptregs = (struct arm64_pt_regs > > *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; > > + frame->sp = orig_sp; > > + frame->pc = ptregs->pc; > > + bt->bptr = fp; > > + if (CRASHDEBUG(1)) > > + error(INFO, > > + "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: %lx\n", > > + frame->fp, frame->sp, frame->pc); > > + } else { > > + error(WARNING, > > + "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: %lx%s\n", > > + orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", > > + frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); > > + return FALSE; > > } > > - } /* UNW_4_14 */ > > + } > > > > return TRUE; > > } > > @@ -2147,17 +2164,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct > > arm64_stackframe *frame, > > * We are on process stack. Just add a faked frame > > */ > > > > - if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) { > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > - frame->sp = ext_frame.fp > > - - sizeof(struct arm64_pt_regs) - 16; > > - frame->fp = ext_frame.fp; > > - } else { > > - frame->sp = ext_frame.fp > > - - sizeof(struct arm64_pt_regs); > > - frame->fp = frame->sp; > > - } > > - } else { > > + if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) > > + frame->sp = ext_frame.fp > > + - sizeof(struct arm64_pt_regs); > > + else { > > /* > > * FIXME: very exceptional case > > * We are already back on process stack, but > > @@ -2177,10 +2187,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct > > arm64_stackframe *frame, > > * Really ugly > > */ > > frame->sp = frame->fp + 0x20; > > - frame->fp = frame->sp; > > fprintf(ofp, " (Next exception frame might be wrong)\n"); > > } > > > > + frame->fp = frame->sp; > > } else { > > /* We are on IRQ stack */ > > > > @@ -2190,15 +2200,9 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct > > arm64_stackframe *frame, > > if (ext_frame.fp != irq_stack_ptr) { > > /* (2) Just add a faked frame */ > > > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > - frame->sp = ext_frame.fp > > - - sizeof(struct arm64_pt_regs); > > - frame->fp = ext_frame.fp; > > - } else { > > - frame->sp = ext_frame.fp > > - - sizeof(struct arm64_pt_regs) - 16; > > - frame->fp = frame->sp; > > - } > > + frame->sp = ext_frame.fp > > + - sizeof(struct arm64_pt_regs); > > + frame->fp = frame->sp; > > } else { > > /* > > * (3) > > @@ -2285,6 +2289,11 @@ arm64_back_trace_cmd(struct bt_info *bt) > > FILE *ofp; > > > > if (bt->flags & BT_OPT_BACK_TRACE) { > > + if (machdep->flags & UNW_4_14) { > > + error(WARNING, "\"-o\" is no longer supported for this version of > > kernel. > > Please use bt\n"); > > + return; > > + } > > + > > arm64_back_trace_cmd_v2(bt); > > return; > > } > > @@ -2346,7 +2355,7 @@ arm64_back_trace_cmd(struct bt_info *bt) > > goto complete_user; > > > > if (DUMPFILE() && is_task_active(bt->task)) { > > - exception_frame = stackframe.fp - SIZE(pt_regs); > > + exception_frame = stackframe.fp - KERN_EFRAME_OFFSET; > > if (arm64_is_kernel_exception_frame(bt, exception_frame)) > > arm64_print_exception_frame(bt, exception_frame, > > KERNEL_MODE, ofp); > > @@ -2377,13 +2386,9 @@ arm64_back_trace_cmd(struct bt_info *bt) > > > > if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, bt)) > > { > > if (!(bt->flags & BT_IRQSTACK) || > > - (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) { > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) > > - /* v4.14 or later */ > > - exception_frame = stackframe.fp - SIZE(pt_regs) + 16; > > - else > > - exception_frame = stackframe.fp - SIZE(pt_regs); > > - } > > + (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) > > + exception_frame = stackframe.fp > > + - KERN_EFRAME_OFFSET; > > } > > > > if ((bt->flags & BT_IRQSTACK) && > > @@ -2503,8 +2508,6 @@ user_space: > > * otherwise show an exception frame. > > * Since exception entry code doesn't have a real > > * stackframe, we fake a dummy frame here. > > - * Note: Since we have a real stack frame in pt_regs, > > - * We no longer need a dummy frame on v4.14 or later. > > */ > > if (!arm64_in_exp_entry(stackframe.pc)) > > continue; > > diff --git a/defs.h b/defs.h > > index 7768895..a694a66 100644 > > --- a/defs.h > > +++ b/defs.h > > @@ -3038,6 +3038,7 @@ typedef signed int s32; > > #define ARM64_VMEMMAP_END (ARM64_VMEMMAP_VADDR + GIGABYTES(8UL) - 1) > > > > #define ARM64_STACK_SIZE (16384) > > +#define ARM64_IRQ_STACK_SIZE ARM64_STACK_SIZE > > > > #define _SECTION_SIZE_BITS 30 > > #define _MAX_PHYSMEM_BITS 40 > > @@ -3117,6 +3118,8 @@ struct machine_specific { > > ulong kimage_text; > > ulong kimage_end; > > ulong user_eframe_offset; > > + /* for v4.14 or later */ > > + ulong kern_eframe_offset; > > }; > > > > struct arm64_stackframe { > > diff --git a/task.c b/task.c > > index 2b12af0..23c2b7b 100644 > > --- a/task.c > > +++ b/task.c > > @@ -6750,6 +6750,8 @@ panic_search(void) > > fd->keyword_array[0] = FOREACH_BT; > > if (machine_type("S390X")) > > fd->flags |= FOREACH_o_FLAG; > > + else if (machine_type("ARM64") && (machdep->flags & UNW_4_14)) > > + fd->flags |= FOREACH_t_FLAG; > > else > > fd->flags |= (FOREACH_t_FLAG|FOREACH_o_FLAG); > > > > -- > > 2.14.1 > > > > -- > > Crash-utility mailing list > > Crash-utility(a)redhat.com > > https://www.redhat.com/mailman/listinfo/crash-utility > > > > -- > Crash-utility mailing list > Crash-utility(a)redhat.com > https://www.redhat.com/mailman/listinfo/crash-utility > -- Crash-utility mailing list Crash-utility(a)redhat.com https://www.redhat.com/mailman/listinfo/crash-utility

----- Original Message ----- > Dave, > > Thanks for your double-check, > > On Thu, Oct 19, 2017 at 01:55:11PM -0400, Dave Anderson wrote: > > > > > > ----- Original Message ----- > > > > > > Hi Takahiro, > > > > > > I haven't had a chance to investigate why it fails, but with this > > > latest > > > patch applied, the "bt -[fF]" option fails to show the topmost frame > > > dump > > > for *all* user-space tasks. > > > > By *all* user-space tasks, I mean in pre-4.14 dumpfiles. I don't have a > > 4.14 > > dumpfile, but on a live 4.14 system, it does dump the frame. > > > > Anyway, it's caused by this diff segment: > > > > @@ -1778,7 +1783,7 @@ arm64_display_full_frame(struct bt_info *bt, ulong > > sp) > > ulong words, addr; > > char buf[BUFSIZE]; > > > > - if (bt->frameptr == sp) > > + if (bt->frameptr >= sp) > > return; > > > > if (INSTACK(bt->frameptr, bt)) { > > > > If I set it back to "==", it works as expected. In fact, if I set it > > back to "==" > > and run it on my live 4.14 system, it still works. So I'm not sure why > > it's been > > changed? > > Well, this is related to this code: > === arm64_unwind_frame() == > * If we want to see pt_regs, > * comment out the below. > * bt->frameptr = frame->sp; <---- (A) > */ > ===>8=== > > At my initial fix, I wanted to dump a full frame (on process stack) > even for interrupt case like: > ===8< (only on v4.14) == > #7 [ffff00000800bfc0] gic_handle_irq at ffff000008081718 > ffff00000800bfc0: ffff000009193f50 ffff0000080830f0 > ffff00000800bfd0: ffff000009193e20 0001000000000000 > ffff00000800bfe0: ffff000009193f60 ffff0000080854b8 > ffff00000800bff0: 0000000000000145 0000000000000000 > --- <IRQ stack> --- > ffff000009193e20: 0000000000000000 0000000000000000 <----- (pt_regs) > ffff000009193e30: 0000000000000001 0000000000000000 > ffff000009193e40: 0000000000000000 ffff000009193f60 > ffff000009193e50: 0000800006038000 0000000000000001 > ffff000009193e60: ffff80000d95a660 ffff000009193ee0 > ffff000009193e70: 0000000000000a00 000000000004dccc > ffff000009193e80: 000000075e3f3040 0000000000000000 > ffff000009193e90: 00096ae380000000 0000145b90000000 > ffff000009193ea0: ffff00000820e7c8 0000ffffb4c4ee30 > ffff000009193eb0: 0000000000000014 ffff000008f21000 > ffff000009193ec0: ffff000008f39000 ffff000008f39000 > ffff000009193ed0: ffff000008f2c620 ffff000008f39e90 > ffff000009193ee0: 0000000000000000 0000000000000000 > ffff000009193ef0: ffff80000d959c00 0000000000000000 > ffff000009193f00: 0000000000000000 ffff000009193f60 > ffff000009193f10: ffff0000080854b4 ffff000009193f60 > ffff000009193f20: ffff0000080854b8 0000000000000145 > ffff000009193f30: 0000000000000000 0000000000000000 > ffff000009193f40: ffffffffffffffff ffff00000813ce8c ------> > #8 [ffff000009193f50] el1_irq at ffff0000080830ec > PC: ffff0000080854b8 [arch_cpu_idle+16] > LR: ffff0000080854b4 [arch_cpu_idle+12] > SP: ffff000009193f60 PSTATE: 00000145 > X29: ffff000009193f60 X28: 0000000000000000 X27: 0000000000000000 > X26: ffff80000d959c00 X25: 0000000000000000 X24: 0000000000000000 > X23: ffff000008f39e90 X22: ffff000008f2c620 X21: ffff000008f39000 > X20: ffff000008f39000 X19: ffff000008f21000 X18: 0000000000000014 > X17: 0000ffffb4c4ee30 X16: ffff00000820e7c8 X15: 0000145b90000000 > X14: 00096ae380000000 X13: 0000000000000000 X12: 000000075e3f3040 > X11: 000000000004dccc X10: 0000000000000a00 X9: ffff000009193ee0 > X8: ffff80000d95a660 X7: 0000000000000001 X6: 0000800006038000 > X5: ffff000009193f60 X4: 0000000000000000 X3: 0000000000000000 > X2: 0000000000000001 X1: 0000000000000000 X0: 0000000000000000 > ==8<=== > But this code breaks on older kernels and I had to manage it. > Now that (A) is commented out, we don't need such a workaround > as you suggested. So I think you can revert that hunk (plus remove > the entire comment around (A)). Ok, for now I will revert it back to "==" and remove the comment at (A) > > In this investigation, I also found that > === arm64_display_full_frame() === > if (INSTACK(bt->frameptr, bt)) { > if (INSTACK(sp, bt)) { > ; /* normal case */ > } else { > if (sp == 0) > /* interrupt in user mode */ <--- (B) > sp = bt->stacktop - USER_EFRAME_OFFSET; > else > /* interrupt in kernel mode */ > sp = bt->stacktop; <---- (C) > } > } else { > /* This is a transition case from irq to process stack. */ > return; <---- (D) > } > > ===>8=== > * (B) are not only for interrupt case, but also for all exceptions. > * (C) and (D) are very unlikely to be hit at any cases. > (D) is supposed to already be handled in arm64_switch_stack(), > but why (C)? Actually (D) gets hit every time when switching from the IRQ stack to the process stack on older kernels. I've thought about fixing that, but given that the exception frame itself is a stack dump (albeit translated), I've left it alone for now. I don't remember about (C). Thanks, Dave > Sorry for those inaccuracies. > > Thanks, > -Takahiro AKASHI > > > Dave > > > > > > > For example, here frame #6 is missing its dump: > > > > > > crash> bt -f 1 > > > PID: 1 TASK: ffffffc3e8890000 CPU: 5 COMMAND: "systemd" > > > #0 [ffffffc3e889bb10] __switch_to at ffffffc000084960 > > > ffffffc3e889bb10: ffffffc3e889bb40 ffffffc00062f99c > > > ffffffc3e889bb20: ffffffc3e88e1400 ffffffc3e8898000 > > > ffffffc3e889bb30: ffffffc00090d400 ffffffc3e88e1400 > > > #1 [ffffffc3e889bb40] __schedule at ffffffc00062f998 > > > ffffffc3e889bb40: ffffffc3e889bd00 ffffffc00062fe30 > > > ffffffc3e889bb50: 0000000000000000 0000000000000000 > > > ffffffc3e889bb60: 0000000000000000 ffffffc3e8898000 > > > ffffffc3e889bb70: 0000007fea93aa40 0000000000000000 > > > ffffffc3e889bb80: 0000000000000000 0000000000000000 > > > ffffffc3e889bb90: ffffffc3e3551f60 ffffffc3e3551f00 > > > ffffffc3e889bba0: 0000000000000000 0000000000000000 > > > ffffffc3e889bbb0: 0000000000000000 00000000ffffffff > > > ffffffc3e889bbc0: ffffffc00062fe30 ffffffc0007f3af8 > > > ffffffc3e889bbd0: ffffffc00098c00c ffffffc00090d400 > > > ffffffc3e889bbe0: ffffffc3e889bce0 ffffffc000501290 > > > ffffffc3e889bbf0: ffffffc3e889be88 0000000000000800 > > > ffffffc3e889bc00: 0000000040000040 ffffffc3e889bd50 > > > ffffffc3e889bc10: 0000000000000000 0000000000000000 > > > ffffffc3e889bc20: 0000000000000000 ffffffc3e889bc68 > > > ffffffc3e889bc30: ffffffc3e8890000 0000000000000000 > > > ffffffc3e889bc40: 0000000000000000 0000000000000000 > > > ffffffc3e889bc50: 0000000000000000 0000000000000000 > > > ffffffc3e889bc60: 0000000000000000 ffffffc000146984 > > > ffffffc3e889bc70: 0000000000000000 0000080040000040 > > > ffffffc3e889bc80: ffffffc3e3047700 4000000000000000 > > > ffffffc3e889bc90: ffffffc3e889bcb0 ffffffc0004ffabc > > > ffffffc3e889bca0: ffffffc3e3047700 ffffffc3e889be88 > > > ffffffc3e889bcb0: ffffffc3e889bd00 ffffffc0001e033c > > > ffffffc3e889bcc0: ffffffc3f9a19c18 0000000000000000 > > > ffffffc3e889bcd0: ffffffc3e889bdb0 0000007fea93aa40 > > > ffffffc3e889bce0: ffffffc3e889be38 ffffffc000502270 > > > ffffffc3e889bcf0: ffffffc3e889bd00 ffffffc0001e0318 > > > #2 [ffffffc3e889bd00] schedule at ffffffc00062fe2c > > > ffffffc3e889bd00: ffffffc3e889bd10 ffffffc00062f5e8 > > > #3 [ffffffc3e889bd10] schedule_hrtimeout_range_clock at > > > ffffffc00062f5e4 > > > ffffffc3e889bd10: ffffffc3e889bdb0 ffffffc00062f610 > > > ffffffc3e889bd20: 0000000000000001 0000000000000001 > > > ffffffc3e889bd30: ffffffc3e34c8300 0000000000000000 > > > ffffffc3e889bd40: 0000000000000000 ffffffc3e3551f60 > > > ffffffc3e889bd50: ffffffc3e889bd60 ffffffc0001e0b30 > > > ffffffc3e889bd60: ffffffc3e889bdc0 ffffffc0001e1a28 > > > ffffffc3e889bd70: ffffffffffffffea 0000000000000001 > > > ffffffc3e889bd80: ffffffc3e34c8300 ffffffc3e8898000 > > > ffffffc3e889bd90: ffffffc3e889bdc0 ffffffc0001e1ae0 > > > ffffffc3e889bda0: 0000000000000000 0000000000000001 > > > #4 [ffffffc3e889bdb0] schedule_hrtimeout_range at ffffffc00062f60c > > > ffffffc3e889bdb0: ffffffc3e889bdc0 ffffffc0001e1b58 > > > #5 [ffffffc3e889bdc0] sys_epoll_wait at ffffffc0001e1b54 > > > ffffffc3e889bdc0: ffffffc3e889be70 ffffffc0001e1cfc > > > ffffffc3e889bdd0: 0000000000000004 0000000000000000 > > > ffffffc3e889bde0: 0000000000000001 0000000000000004 > > > ffffffc3e889bdf0: 0000007fea93aa40 0000000000000015 > > > ffffffc3e889be00: 0000000000000112 0000000000000016 > > > ffffffc3e889be10: ffffffc00091f000 ffffffc3e8898000 > > > ffffffc3e889be20: 0000000000000000 0000000000000000 > > > ffffffc3e889be30: ffffffc3e889be50 ffffffc000000001 > > > ffffffc3e889be40: 0000007fea93aa40 ffffffc300000001 > > > ffffffc3e889be50: ffffffc3e8890000 ffffffc0000cc8f0 > > > ffffffc3e889be60: ffffffc3e3551f38 ffffffc3e3551f38 > > > #6 [ffffffc3e889be70] sys_epoll_pwait at ffffffc0001e1cf8 > > > #7 [ffffffc3e889bed0] cpu_switch_to at ffffffc0000837e8 > > > PC: 0000007f8fb55a6c LR: 000000557a5fb704 SP: > > > 0000007fea93a8d0 > > > X29: 0000007fea93a8d0 X28: 0000000000000001 X27: > > > 000000557a712000 > > > X26: 000000557a683998 X25: 000000557a682ef0 X24: > > > 000000557a681cc0 > > > X23: 000000558b51f920 X22: 0000000000000000 X21: > > > 0000007fea93aa40 > > > X20: 0000000000000000 X19: 0000000000000004 X18: > > > 0000000000000800 > > > X17: 0000007f8fb557e8 X16: 000000557a7125a0 X15: > > > 003b9aca00000000 > > > X14: 000a16e0ae000000 X13: ffffffffacbd0ac2 X12: > > > 0000000000000018 > > > X11: 000000003a2be47d X10: 0000000000000035 X9: > > > 00000000000013a4 > > > X8: 0000000000000016 X7: 0000000000000000 X6: > > > 0000007f8fe3f000 > > > X5: 0000000000000008 X4: 0000000000000000 X3: > > > ffffffffffffffff > > > X2: 0000000000000001 X1: 0000007fea93aa40 X0: > > > 0000000000000004 > > > ORIG_X0: 0000000000000004 SYSCALLNO: 16 PSTATE: 60000000 > > > > > > Without the patch, the dump for frame #6 is there: > > > > > > crash> bt -f 1 > > > PID: 1 TASK: ffffffc3e8890000 CPU: 5 COMMAND: "systemd" > > > #0 [ffffffc3e889bb10] __switch_to at ffffffc000084960 > > > ffffffc3e889bb10: ffffffc3e889bb40 ffffffc00062f99c > > > ffffffc3e889bb20: ffffffc3e88e1400 ffffffc3e8898000 > > > ffffffc3e889bb30: ffffffc00090d400 ffffffc3e88e1400 > > > #1 [ffffffc3e889bb40] __schedule at ffffffc00062f998 > > > ffffffc3e889bb40: ffffffc3e889bd00 ffffffc00062fe30 > > > ffffffc3e889bb50: 0000000000000000 0000000000000000 > > > ffffffc3e889bb60: 0000000000000000 ffffffc3e8898000 > > > ffffffc3e889bb70: 0000007fea93aa40 0000000000000000 > > > ffffffc3e889bb80: 0000000000000000 0000000000000000 > > > ffffffc3e889bb90: ffffffc3e3551f60 ffffffc3e3551f00 > > > ffffffc3e889bba0: 0000000000000000 0000000000000000 > > > ffffffc3e889bbb0: 0000000000000000 00000000ffffffff > > > ffffffc3e889bbc0: ffffffc00062fe30 ffffffc0007f3af8 > > > ffffffc3e889bbd0: ffffffc00098c00c ffffffc00090d400 > > > ffffffc3e889bbe0: ffffffc3e889bce0 ffffffc000501290 > > > ffffffc3e889bbf0: ffffffc3e889be88 0000000000000800 > > > ffffffc3e889bc00: 0000000040000040 ffffffc3e889bd50 > > > ffffffc3e889bc10: 0000000000000000 0000000000000000 > > > ffffffc3e889bc20: 0000000000000000 ffffffc3e889bc68 > > > ffffffc3e889bc30: ffffffc3e8890000 0000000000000000 > > > ffffffc3e889bc40: 0000000000000000 0000000000000000 > > > ffffffc3e889bc50: 0000000000000000 0000000000000000 > > > ffffffc3e889bc60: 0000000000000000 ffffffc000146984 > > > ffffffc3e889bc70: 0000000000000000 0000080040000040 > > > ffffffc3e889bc80: ffffffc3e3047700 4000000000000000 > > > ffffffc3e889bc90: ffffffc3e889bcb0 ffffffc0004ffabc > > > ffffffc3e889bca0: ffffffc3e3047700 ffffffc3e889be88 > > > ffffffc3e889bcb0: ffffffc3e889bd00 ffffffc0001e033c > > > ffffffc3e889bcc0: ffffffc3f9a19c18 0000000000000000 > > > ffffffc3e889bcd0: ffffffc3e889bdb0 0000007fea93aa40 > > > ffffffc3e889bce0: ffffffc3e889be38 ffffffc000502270 > > > ffffffc3e889bcf0: ffffffc3e889bd00 ffffffc0001e0318 > > > #2 [ffffffc3e889bd00] schedule at ffffffc00062fe2c > > > ffffffc3e889bd00: ffffffc3e889bd10 ffffffc00062f5e8 > > > #3 [ffffffc3e889bd10] schedule_hrtimeout_range_clock at > > > ffffffc00062f5e4 > > > ffffffc3e889bd10: ffffffc3e889bdb0 ffffffc00062f610 > > > ffffffc3e889bd20: 0000000000000001 0000000000000001 > > > ffffffc3e889bd30: ffffffc3e34c8300 0000000000000000 > > > ffffffc3e889bd40: 0000000000000000 ffffffc3e3551f60 > > > ffffffc3e889bd50: ffffffc3e889bd60 ffffffc0001e0b30 > > > ffffffc3e889bd60: ffffffc3e889bdc0 ffffffc0001e1a28 > > > ffffffc3e889bd70: ffffffffffffffea 0000000000000001 > > > ffffffc3e889bd80: ffffffc3e34c8300 ffffffc3e8898000 > > > ffffffc3e889bd90: ffffffc3e889bdc0 ffffffc0001e1ae0 > > > ffffffc3e889bda0: 0000000000000000 0000000000000001 > > > #4 [ffffffc3e889bdb0] schedule_hrtimeout_range at ffffffc00062f60c > > > ffffffc3e889bdb0: ffffffc3e889bdc0 ffffffc0001e1b58 > > > #5 [ffffffc3e889bdc0] sys_epoll_wait at ffffffc0001e1b54 > > > ffffffc3e889bdc0: ffffffc3e889be70 ffffffc0001e1cfc > > > ffffffc3e889bdd0: 0000000000000004 0000000000000000 > > > ffffffc3e889bde0: 0000000000000001 0000000000000004 > > > ffffffc3e889bdf0: 0000007fea93aa40 0000000000000015 > > > ffffffc3e889be00: 0000000000000112 0000000000000016 > > > ffffffc3e889be10: ffffffc00091f000 ffffffc3e8898000 > > > ffffffc3e889be20: 0000000000000000 0000000000000000 > > > ffffffc3e889be30: ffffffc3e889be50 ffffffc000000001 > > > ffffffc3e889be40: 0000007fea93aa40 ffffffc300000001 > > > ffffffc3e889be50: ffffffc3e8890000 ffffffc0000cc8f0 > > > ffffffc3e889be60: ffffffc3e3551f38 ffffffc3e3551f38 > > > #6 [ffffffc3e889be70] sys_epoll_pwait at ffffffc0001e1cf8 > > > ffffffc3e889be70: 0000007fea93a8d0 ffffffc0000837ec > > > ffffffc3e889be80: 0000000000000004 0000000000000000 > > > ffffffc3e889be90: ffffffffffffffff 0000007f8fb55a6c > > > ffffffc3e889bea0: 0000000060000000 0000007fea9396e0 > > > ffffffc3e889beb0: 0000000000001010 0000000040000000 > > > ffffffc3e889bec0: 0000007fea93a700 ffffffc0000837ec > > > #7 [ffffffc3e889bed0] cpu_switch_to at ffffffc0000837e8 > > > PC: 0000007f8fb55a6c LR: 000000557a5fb704 SP: > > > 0000007fea93a8d0 > > > X29: 0000007fea93a8d0 X28: 0000000000000001 X27: > > > 000000557a712000 > > > X26: 000000557a683998 X25: 000000557a682ef0 X24: > > > 000000557a681cc0 > > > X23: 000000558b51f920 X22: 0000000000000000 X21: > > > 0000007fea93aa40 > > > X20: 0000000000000000 X19: 0000000000000004 X18: > > > 0000000000000800 > > > X17: 0000007f8fb557e8 X16: 000000557a7125a0 X15: > > > 003b9aca00000000 > > > X14: 000a16e0ae000000 X13: ffffffffacbd0ac2 X12: > > > 0000000000000018 > > > X11: 000000003a2be47d X10: 0000000000000035 X9: > > > 00000000000013a4 > > > X8: 0000000000000016 X7: 0000000000000000 X6: > > > 0000007f8fe3f000 > > > X5: 0000000000000008 X4: 0000000000000000 X3: > > > ffffffffffffffff > > > X2: 0000000000000001 X1: 0000007fea93aa40 X0: > > > 0000000000000004 > > > ORIG_X0: 0000000000000004 SYSCALLNO: 16 PSTATE: 60000000 > > > > > > Dave > > > > > > > > > > > > ----- Original Message ----- > > > > Dave, > > > > > > > > On Wed, Oct 18, 2017 at 02:12:17PM -0400, Dave Anderson wrote: > > > > > > > > > > > > > > > ----- Original Message ----- > > > > > > On Tue, Oct 17, 2017 at 03:44:36PM -0400, Dave Anderson wrote: > > > > > > > > > > > > > > Thanks Takahiro, much appreciated. Queued for crash-7.2.1: > > > > > > > > > > > > > > https://github.com/crash-utility/crash/commit/2b93c036edf2a5cc21a06a14f37... > > > > > > > > > > > > Oops, I've made small changes, nothing essential but some sort of > > > > > > clean-ups/readability improvements with deleting incomplete fixes > > > > > > against "bt -o." > > > > > > > > > > Hmmm, except it's kind of difficult to pick through the patch below > > > > > for the changes, given that it's a combination of your original > > > > > patch > > > > > plus the new changes. So I can't apply it to get a clean view of > > > > > the new changes. I do see that it's mostly the stacksize and > > > > > stackframe > > > > > related updates, but would it be possible for you to make a patch > > > > > that can be applied to the github sources? > > > > > > > > Here is what you requested. Pls check. > > > > > > > > Thanks, > > > > -Takahiro AKASHI > > > > > > > > ===8<=== > > > > >From 7b99a1c2e688ba81e18541c21a7d0fa70504e5bc Mon Sep 17 00:00:00 > > > > >2001 > > > > From: AKASHI Takahiro <takahiro.akashi(a)linaro.org&gt; > > > > Date: Thu, 19 Oct 2017 10:18:22 +0900 > > > > Subject: [PATCH] arm64: bt: cleanup stuff > > > > > > > > --- > > > > arm64.c | 159 > > > > +++++++++++++++++++++++++++++++++------------------------------- > > > > defs.h | 3 ++ > > > > task.c | 2 + > > > > 3 files changed, 86 insertions(+), 78 deletions(-) > > > > > > > > diff --git a/arm64.c b/arm64.c > > > > index c75669b..1f742d4 100644 > > > > --- a/arm64.c > > > > +++ b/arm64.c > > > > @@ -612,6 +612,7 @@ arm64_dump_machdep_table(ulong arg) > > > > fprintf(fp, " exp_entry2_end: %lx\n", ms->exp_entry2_end); > > > > fprintf(fp, " panic_task_regs: %lx\n", > > > > (ulong)ms->panic_task_regs); > > > > fprintf(fp, " user_eframe_offset: %ld\n", > > > > ms->user_eframe_offset); > > > > + fprintf(fp, " kern_eframe_offset: %ld\n", > > > > ms->kern_eframe_offset); > > > > fprintf(fp, " PTE_PROT_NONE: %lx\n", ms->PTE_PROT_NONE); > > > > fprintf(fp, " PTE_FILE: "); > > > > if (ms->PTE_FILE) > > > > @@ -1383,7 +1384,7 @@ arm64_irq_stack_init(void) > > > > > > > > if (!(ms->irq_stacks = (ulong *)malloc((size_t)(kt->cpus * > > > > sizeof(ulong))))) > > > > error(FATAL, "cannot malloc irq_stack addresses\n"); > > > > - ms->irq_stack_size = 16384; > > > > + ms->irq_stack_size = ARM64_IRQ_STACK_SIZE; > > > > machdep->flags |= IRQ_STACKS; > > > > > > > > for (i = 0; i < kt->cpus; i++) { > > > > @@ -1410,10 +1411,13 @@ arm64_stackframe_init(void) > > > > MEMBER_OFFSET_INIT(elf_prstatus_pr_pid, "elf_prstatus", "pr_pid"); > > > > MEMBER_OFFSET_INIT(elf_prstatus_pr_reg, "elf_prstatus", "pr_reg"); > > > > > > > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) > > > > + if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > > > machdep->machspec->user_eframe_offset = SIZE(pt_regs); > > > > - else > > > > + machdep->machspec->kern_eframe_offset = SIZE(pt_regs) - 16; > > > > + } else { > > > > machdep->machspec->user_eframe_offset = SIZE(pt_regs) + 16; > > > > + machdep->machspec->kern_eframe_offset = SIZE(pt_regs); > > > > + } > > > > > > > > machdep->machspec->__exception_text_start = > > > > symbol_value("__exception_text_start"); > > > > @@ -1503,6 +1507,7 @@ arm64_stackframe_init(void) > > > > #define USER_MODE (2) > > > > > > > > #define USER_EFRAME_OFFSET (machdep->machspec->user_eframe_offset) > > > > +#define KERN_EFRAME_OFFSET (machdep->machspec->kern_eframe_offset) > > > > > > > > /* > > > > * PSR bits > > > > @@ -1778,7 +1783,7 @@ arm64_display_full_frame(struct bt_info *bt, > > > > ulong > > > > sp) > > > > ulong words, addr; > > > > char buf[BUFSIZE]; > > > > > > > > - if (bt->frameptr == sp) > > > > + if (bt->frameptr >= sp) > > > > return; > > > > > > > > if (INSTACK(bt->frameptr, bt)) { > > > > @@ -1793,7 +1798,7 @@ arm64_display_full_frame(struct bt_info *bt, > > > > ulong > > > > sp) > > > > sp = bt->stacktop; > > > > } > > > > } else { > > > > - /* IRQ exception frame */ > > > > + /* This is a transition case from irq to process stack. */ > > > > return; > > > > } > > > > > > > > @@ -1903,61 +1908,73 @@ arm64_unwind_frame(struct bt_info *bt, struct > > > > arm64_stackframe *frame) > > > > if (!(machdep->flags & IRQ_STACKS)) > > > > return TRUE; > > > > > > > > - /* > > > > - * The kernel's manner of determining the end of the IRQ stack: > > > > - * > > > > - * #define THREAD_SIZE 16384 > > > > - * #define THREAD_START_SP (THREAD_SIZE - 16) > > > > - * #define IRQ_STACK_START_SP THREAD_START_SP > > > > - * #define IRQ_STACK_PTR(cpu) ((unsigned long)per_cpu(irq_stack, > > > > cpu) + > > > > IRQ_STACK_START_SP) > > > > - * #define IRQ_STACK_TO_TASK_STACK(ptr) (*((unsigned long *)((ptr) > > > > - > > > > 0x08))) > > > > - * > > > > - * irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id()); > > > > - * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs > > > > pointer > > > > on > > > > process stack) > > > > - */ > > > > + if (!(machdep->flags & IRQ_STACKS)) > > > > + return TRUE; > > > > + > > > > if (machdep->flags & UNW_4_14) { > > > > if ((bt->flags & BT_IRQSTACK) && > > > > !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { > > > > if (arm64_on_process_stack(bt, frame->fp)) { > > > > arm64_set_process_stack(bt); > > > > > > > > - frame->sp = frame->fp - SIZE(pt_regs) + 16; > > > > - /* for switch_stack */ > > > > - /* fp still points to irq stack */ > > > > + frame->sp = frame->fp - KERN_EFRAME_OFFSET; > > > > + /* > > > > + * for switch_stack > > > > + * fp still points to irq stack > > > > + */ > > > > bt->bptr = fp; > > > > - /* for display_full_frame */ > > > > - /* sp points to process stack */ > > > > - bt->frameptr = frame->sp; > > > > + /* > > > > + * for display_full_frame > > > > + * sp points to process stack > > > > + * > > > > + * If we want to see pt_regs, > > > > + * comment out the below. > > > > + * bt->frameptr = frame->sp; > > > > + */ > > > > } else { > > > > /* irq -> user */ > > > > return FALSE; > > > > } > > > > } > > > > - } else { /* !UNW_4_14 */ > > > > - ms = machdep->machspec; > > > > - irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + > > > > ms->irq_stack_size - > > > > 16; > > > > - > > > > - if (frame->sp == irq_stack_ptr) { > > > > - orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); > > > > - arm64_set_process_stack(bt); > > > > - if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp > > > > == > > > > 0))) > > > > { > > > > - ptregs = (struct arm64_pt_regs > > > > *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; > > > > - frame->sp = orig_sp; > > > > - frame->pc = ptregs->pc; > > > > - bt->bptr = fp; > > > > - if (CRASHDEBUG(1)) > > > > - error(INFO, > > > > - "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: > > > > %lx\n", > > > > - frame->fp, frame->sp, frame->pc); > > > > - } else { > > > > - error(WARNING, > > > > - "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: > > > > %lx%s\n", > > > > - orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", > > > > - frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); > > > > - return FALSE; > > > > - } > > > > + > > > > + return TRUE; > > > > + } > > > > + > > > > + /* > > > > + * The kernel's manner of determining the end of the IRQ stack: > > > > + * > > > > + * #define THREAD_SIZE 16384 > > > > + * #define THREAD_START_SP (THREAD_SIZE - 16) > > > > + * #define IRQ_STACK_START_SP THREAD_START_SP > > > > + * #define IRQ_STACK_PTR(cpu) ((unsigned long)per_cpu(irq_stack, > > > > cpu) + > > > > IRQ_STACK_START_SP) > > > > + * #define IRQ_STACK_TO_TASK_STACK(ptr) (*((unsigned long *)((ptr) > > > > - > > > > 0x08))) > > > > + * > > > > + * irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id()); > > > > + * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs > > > > pointer > > > > on > > > > process stack) > > > > + */ > > > > + ms = machdep->machspec; > > > > + irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + > > > > ms->irq_stack_size - > > > > 16; > > > > + > > > > + if (frame->sp == irq_stack_ptr) { > > > > + orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); > > > > + arm64_set_process_stack(bt); > > > > + if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp > > > > == > > > > 0))) > > > > { > > > > + ptregs = (struct arm64_pt_regs > > > > *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; > > > > + frame->sp = orig_sp; > > > > + frame->pc = ptregs->pc; > > > > + bt->bptr = fp; > > > > + if (CRASHDEBUG(1)) > > > > + error(INFO, > > > > + "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: > > > > %lx\n", > > > > + frame->fp, frame->sp, frame->pc); > > > > + } else { > > > > + error(WARNING, > > > > + "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: > > > > %lx%s\n", > > > > + orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", > > > > + frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); > > > > + return FALSE; > > > > } > > > > - } /* UNW_4_14 */ > > > > + } > > > > > > > > return TRUE; > > > > } > > > > @@ -2147,17 +2164,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, > > > > struct > > > > arm64_stackframe *frame, > > > > * We are on process stack. Just add a faked frame > > > > */ > > > > > > > > - if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) { > > > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > > > - frame->sp = ext_frame.fp > > > > - - sizeof(struct arm64_pt_regs) - 16; > > > > - frame->fp = ext_frame.fp; > > > > - } else { > > > > - frame->sp = ext_frame.fp > > > > - - sizeof(struct arm64_pt_regs); > > > > - frame->fp = frame->sp; > > > > - } > > > > - } else { > > > > + if (!arm64_on_irq_stack(bt->tc->processor, ext_frame.fp)) > > > > + frame->sp = ext_frame.fp > > > > + - sizeof(struct arm64_pt_regs); > > > > + else { > > > > /* > > > > * FIXME: very exceptional case > > > > * We are already back on process stack, but > > > > @@ -2177,10 +2187,10 @@ arm64_unwind_frame_v2(struct bt_info *bt, > > > > struct > > > > arm64_stackframe *frame, > > > > * Really ugly > > > > */ > > > > frame->sp = frame->fp + 0x20; > > > > - frame->fp = frame->sp; > > > > fprintf(ofp, " (Next exception frame might be wrong)\n"); > > > > } > > > > > > > > + frame->fp = frame->sp; > > > > } else { > > > > /* We are on IRQ stack */ > > > > > > > > @@ -2190,15 +2200,9 @@ arm64_unwind_frame_v2(struct bt_info *bt, > > > > struct > > > > arm64_stackframe *frame, > > > > if (ext_frame.fp != irq_stack_ptr) { > > > > /* (2) Just add a faked frame */ > > > > > > > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) { > > > > - frame->sp = ext_frame.fp > > > > - - sizeof(struct arm64_pt_regs); > > > > - frame->fp = ext_frame.fp; > > > > - } else { > > > > - frame->sp = ext_frame.fp > > > > - - sizeof(struct arm64_pt_regs) - 16; > > > > - frame->fp = frame->sp; > > > > - } > > > > + frame->sp = ext_frame.fp > > > > + - sizeof(struct arm64_pt_regs); > > > > + frame->fp = frame->sp; > > > > } else { > > > > /* > > > > * (3) > > > > @@ -2285,6 +2289,11 @@ arm64_back_trace_cmd(struct bt_info *bt) > > > > FILE *ofp; > > > > > > > > if (bt->flags & BT_OPT_BACK_TRACE) { > > > > + if (machdep->flags & UNW_4_14) { > > > > + error(WARNING, "\"-o\" is no longer supported for this version of > > > > kernel. > > > > Please use bt\n"); > > > > + return; > > > > + } > > > > + > > > > arm64_back_trace_cmd_v2(bt); > > > > return; > > > > } > > > > @@ -2346,7 +2355,7 @@ arm64_back_trace_cmd(struct bt_info *bt) > > > > goto complete_user; > > > > > > > > if (DUMPFILE() && is_task_active(bt->task)) { > > > > - exception_frame = stackframe.fp - SIZE(pt_regs); > > > > + exception_frame = stackframe.fp - KERN_EFRAME_OFFSET; > > > > if (arm64_is_kernel_exception_frame(bt, exception_frame)) > > > > arm64_print_exception_frame(bt, exception_frame, > > > > KERNEL_MODE, ofp); > > > > @@ -2377,13 +2386,9 @@ arm64_back_trace_cmd(struct bt_info *bt) > > > > > > > > if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, > > > > bt)) > > > > { > > > > if (!(bt->flags & BT_IRQSTACK) || > > > > - (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) { > > > > - if (MEMBER_EXISTS("pt_regs", "stackframe")) > > > > - /* v4.14 or later */ > > > > - exception_frame = stackframe.fp - SIZE(pt_regs) + 16; > > > > - else > > > > - exception_frame = stackframe.fp - SIZE(pt_regs); > > > > - } > > > > + (((stackframe.sp + SIZE(pt_regs)) < bt->stacktop))) > > > > + exception_frame = stackframe.fp > > > > + - KERN_EFRAME_OFFSET; > > > > } > > > > > > > > if ((bt->flags & BT_IRQSTACK) && > > > > @@ -2503,8 +2508,6 @@ user_space: > > > > * otherwise show an exception frame. > > > > * Since exception entry code doesn't have a real > > > > * stackframe, we fake a dummy frame here. > > > > - * Note: Since we have a real stack frame in pt_regs, > > > > - * We no longer need a dummy frame on v4.14 or later. > > > > */ > > > > if (!arm64_in_exp_entry(stackframe.pc)) > > > > continue; > > > > diff --git a/defs.h b/defs.h > > > > index 7768895..a694a66 100644 > > > > --- a/defs.h > > > > +++ b/defs.h > > > > @@ -3038,6 +3038,7 @@ typedef signed int s32; > > > > #define ARM64_VMEMMAP_END (ARM64_VMEMMAP_VADDR + GIGABYTES(8UL) - > > > > 1) > > > > > > > > #define ARM64_STACK_SIZE (16384) > > > > +#define ARM64_IRQ_STACK_SIZE ARM64_STACK_SIZE > > > > > > > > #define _SECTION_SIZE_BITS 30 > > > > #define _MAX_PHYSMEM_BITS 40 > > > > @@ -3117,6 +3118,8 @@ struct machine_specific { > > > > ulong kimage_text; > > > > ulong kimage_end; > > > > ulong user_eframe_offset; > > > > + /* for v4.14 or later */ > > > > + ulong kern_eframe_offset; > > > > }; > > > > > > > > struct arm64_stackframe { > > > > diff --git a/task.c b/task.c > > > > index 2b12af0..23c2b7b 100644 > > > > --- a/task.c > > > > +++ b/task.c > > > > @@ -6750,6 +6750,8 @@ panic_search(void) > > > > fd->keyword_array[0] = FOREACH_BT; > > > > if (machine_type("S390X")) > > > > fd->flags |= FOREACH_o_FLAG; > > > > + else if (machine_type("ARM64") && (machdep->flags & UNW_4_14)) > > > > + fd->flags |= FOREACH_t_FLAG; > > > > else > > > > fd->flags |= (FOREACH_t_FLAG|FOREACH_o_FLAG); > > > > > > > > -- > > > > 2.14.1 > > > > > > > > -- > > > > Crash-utility mailing list > > > > Crash-utility(a)redhat.com > > > > https://www.redhat.com/mailman/listinfo/crash-utility > > > > > > > > > > -- > > > Crash-utility mailing list > > > Crash-utility(a)redhat.com > > > https://www.redhat.com/mailman/listinfo/crash-utility > > > > > > > -- > > Crash-utility mailing list > > Crash-utility(a)redhat.com > > https://www.redhat.com/mailman/listinfo/crash-utility > > -- > Crash-utility mailing list > Crash-utility(a)redhat.com > https://www.redhat.com/mailman/listinfo/crash-utility > -- Crash-utility mailing list Crash-utility(a)redhat.com https://www.redhat.com/mailman/listinfo/crash-utility