Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 132cd887 authored by AKASHI Takahiro's avatar AKASHI Takahiro Committed by Will Deacon
Browse files

arm64: Modify stack trace and dump for use with irq_stack 



This patch allows unwind_frame() to traverse from interrupt stack to task
stack correctly. It requires data from a dummy stack frame, created
during irq_stack_entry(), added by a later patch.

A similar approach is taken to modify dump_backtrace(), which expects to
find struct pt_regs underneath any call to functions marked __exception.
When on an irq_stack, the struct pt_regs is stored on the old task stack,
the location of which is stored in the dummy stack frame.

Reviewed-by: default avatarCatalin Marinas <catalin.marinas@arm.com>
Signed-off-by: default avatarAKASHI Takahiro <takahiro.akashi@linaro.org>
[james.morse: merged two patches, reworked for per_cpu irq_stacks, and
 no alignment guarantees, added irq_stack definitions]
Signed-off-by: default avatarJames Morse <james.morse@arm.com>
Signed-off-by: default avatarWill Deacon <will.deacon@arm.com>
parent 6cdf9c7c

arch/arm64/include/asm/irq.h

+32 −0
Original line number Diff line number Diff line 
#ifndef __ASM_IRQ_H

#define __ASM_IRQ_H



#define IRQ_STACK_SIZE			THREAD_SIZE

#define IRQ_STACK_START_SP		THREAD_START_SP



#ifndef __ASSEMBLER__



#include <linux/percpu.h>



#include <asm-generic/irq.h>

#include <asm/thread_info.h>



struct pt_regs;



DECLARE_PER_CPU(unsigned long [IRQ_STACK_SIZE/sizeof(long)], irq_stack);



/*

 * The highest address on the stack, and the first to be used. Used to

 * find the dummy-stack frame put down by el?_irq() in entry.S.

 */

#define IRQ_STACK_PTR(cpu) ((unsigned long)per_cpu(irq_stack, cpu) + IRQ_STACK_START_SP)



/*

 * The offset from irq_stack_ptr where entry.S will store the original

 * stack pointer. Used by unwind_frame() and dump_backtrace().

 */

#define IRQ_STACK_TO_TASK_STACK(ptr) *((unsigned long *)(ptr - 0x10));



extern void set_handle_irq(void (*handle_irq)(struct pt_regs *));



static inline int nr_legacy_irqs(void)
@@ -12,4 +34,14 @@ static inline int nr_legacy_irqs(void) 
	return 0;

}



static inline bool on_irq_stack(unsigned long sp, int cpu)

{

	/* variable names the same as kernel/stacktrace.c */

	unsigned long low = (unsigned long)per_cpu(irq_stack, cpu);

	unsigned long high = low + IRQ_STACK_START_SP;



	return (low <= sp && sp <= high);

}



#endif /* !__ASSEMBLER__ */

#endif

arch/arm64/kernel/irq.c

+3 −0
Original line number Diff line number Diff line
@@ -30,6 +30,9 @@ 


unsigned long irq_err_count;



/* irq stack only needs to be 16 byte aligned - not IRQ_STACK_SIZE aligned */

DEFINE_PER_CPU(unsigned long [IRQ_STACK_SIZE/sizeof(long)], irq_stack) __aligned(16);



int arch_show_interrupts(struct seq_file *p, int prec)

{

	show_ipi_list(p, prec);

arch/arm64/kernel/stacktrace.c

+27 −2
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include <linux/sched.h>

#include <linux/stacktrace.h>



#include <asm/irq.h>

#include <asm/stacktrace.h>



/*
@@ -39,17 +40,41 @@ int notrace unwind_frame(struct stackframe *frame) 
{

	unsigned long high, low;

	unsigned long fp = frame->fp;

	unsigned long irq_stack_ptr;



	/*

	 * Use raw_smp_processor_id() to avoid false-positives from

	 * CONFIG_DEBUG_PREEMPT. get_wchan() calls unwind_frame() on sleeping

	 * task stacks, we can be pre-empted in this case, so

	 * {raw_,}smp_processor_id() may give us the wrong value. Sleeping

	 * tasks can't ever be on an interrupt stack, so regardless of cpu,

	 * the checks will always fail.

	 */

	irq_stack_ptr = IRQ_STACK_PTR(raw_smp_processor_id());



	low  = frame->sp;

	high = ALIGN(low, THREAD_SIZE);

	/* irq stacks are not THREAD_SIZE aligned */

	if (on_irq_stack(frame->sp, raw_smp_processor_id()))

		high = irq_stack_ptr;

	else

		high = ALIGN(low, THREAD_SIZE) - 0x20;



	if (fp < low || fp > high - 0x18 || fp & 0xf)

	if (fp < low || fp > high || fp & 0xf)

		return -EINVAL;



	frame->sp = fp + 0x10;

	frame->fp = *(unsigned long *)(fp);

	frame->pc = *(unsigned long *)(fp + 8);



	/*

	 * Check whether we are going to walk through from interrupt stack

	 * to task stack.

	 * If we reach the end of the stack - and its an interrupt stack,

	 * read the original task stack pointer from the dummy frame.

	 */

	if (frame->sp == irq_stack_ptr)

		frame->sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr);



	return 0;

}

arch/arm64/kernel/traps.c

+13 −1
Original line number Diff line number Diff line
@@ -146,6 +146,7 @@ static void dump_instr(const char *lvl, struct pt_regs *regs) 
static void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk)

{

	struct stackframe frame;

	unsigned long irq_stack_ptr = IRQ_STACK_PTR(smp_processor_id());



	pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk);
@@ -180,11 +181,22 @@ static void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk) 
		if (ret < 0)

			break;

		stack = frame.sp;

		if (in_exception_text(where))

		if (in_exception_text(where)) {

			/*

			 * If we switched to the irq_stack before calling this

			 * exception handler, then the pt_regs will be on the

			 * task stack. The easiest way to tell is if the large

			 * pt_regs would overlap with the end of the irq_stack.

			 */

			if (stack < irq_stack_ptr &&

			    (stack + sizeof(struct pt_regs)) > irq_stack_ptr)

				stack = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr);



			dump_mem("", "Exception stack", stack,

				 stack + sizeof(struct pt_regs), false);

		}

	}

}



void show_stack(struct task_struct *tsk, unsigned long *sp)

{