arch/sh/kernel/cpu/sh5/unwind.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * arch/sh/kernel/cpu/sh5/unwind.c
  *
  * Copyright (C) 2004  Paul Mundt
  * Copyright (C) 2004  Richard Curnow
  */
 #include <linux/kallsyms.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
 #include <asm/processor.h>
 #include <asm/io.h>
 #include <asm/unwinder.h>
 #include <asm/stacktrace.h>

 static u8 regcache[63];

 /*
  * Finding the previous stack frame isn't horribly straightforward as it is
  * on some other platforms. In the sh64 case, we don't have "linked" stack
  * frames, so we need to do a bit of work to determine the previous frame,
  * and in turn, the previous r14/r18 pair.
  *
  * There are generally a few cases which determine where we can find out
  * the r14/r18 values. In the general case, this can be determined by poking
  * around the prologue of the symbol PC is in (note that we absolutely must
  * have frame pointer support as well as the kernel symbol table mapped,
  * otherwise we can't even get this far).
  *
  * In other cases, such as the interrupt/exception path, we can poke around
  * the sp/fp.
  *
  * Notably, this entire approach is somewhat error prone, and in the event
  * that the previous frame cannot be determined, that's all we can do.
  * Either way, this still leaves us with a more correct backtrace then what
  * we would be able to come up with by walking the stack (which is garbage
  * for anything beyond the first frame).
  *						-- PFM.
  */
 static int lookup_prev_stack_frame(unsigned long fp, unsigned long pc,
 		      unsigned long *pprev_fp, unsigned long *pprev_pc,
 		      struct pt_regs *regs)
 {
 	const char *sym;
 	char namebuf[128];
 	unsigned long offset;
 	unsigned long prologue = 0;
 	unsigned long fp_displacement = 0;
 	unsigned long fp_prev = 0;
 	unsigned long offset_r14 = 0, offset_r18 = 0;
 	int i, found_prologue_end = 0;

 	sym = kallsyms_lookup(pc, NULL, &offset, NULL, namebuf);
 	if (!sym)
 		return -EINVAL;

 	prologue = pc - offset;
 	if (!prologue)
 		return -EINVAL;

 	/* Validate fp, to avoid risk of dereferencing a bad pointer later.
 	   Assume 128Mb since that's the amount of RAM on a Cayman.  Modify
 	   when there is an SH-5 board with more. */
 	if ((fp < (unsigned long) phys_to_virt(__MEMORY_START)) ||
 	    (fp >= (unsigned long)(phys_to_virt(__MEMORY_START)) + 128*1024*1024) ||
 	    ((fp & 7) != 0)) {
 		return -EINVAL;
 	}

 	/*
 	 * Depth to walk, depth is completely arbitrary.
 	 */
 	for (i = 0; i < 100; i++, prologue += sizeof(unsigned long)) {
 		unsigned long op;
 		u8 major, minor;
 		u8 src, dest, disp;

 		op = *(unsigned long *)prologue;

 		major = (op >> 26) & 0x3f;
 		src   = (op >> 20) & 0x3f;
 		minor = (op >> 16) & 0xf;
 		disp  = (op >> 10) & 0x3f;
 		dest  = (op >>  4) & 0x3f;

 		/*
 		 * Stack frame creation happens in a number of ways.. in the
 		 * general case when the stack frame is less than 511 bytes,
 		 * it's generally created by an addi or addi.l:
 		 *
 		 *	addi/addi.l r15, -FRAME_SIZE, r15
 		 *
 		 * in the event that the frame size is bigger than this, it's
 		 * typically created using a movi/sub pair as follows:
 		 *
 		 *	movi	FRAME_SIZE, rX
 		 *	sub	r15, rX, r15
 		 */

 		switch (major) {
 		case (0x00 >> 2):
 			switch (minor) {
 			case 0x8: /* add.l */
 			case 0x9: /* add */
 				/* Look for r15, r63, r14 */
 				if (src == 15 && disp == 63 && dest == 14)
 					found_prologue_end = 1;

 				break;
 			case 0xa: /* sub.l */
 			case 0xb: /* sub */
 				if (src != 15 || dest != 15)
 					continue;

 				fp_displacement -= regcache[disp];
 				fp_prev = fp - fp_displacement;
 				break;
 			}
 			break;
 		case (0xa8 >> 2): /* st.l */
 			if (src != 15)
 				continue;

 			switch (dest) {
 			case 14:
 				if (offset_r14 || fp_displacement == 0)
 					continue;

 				offset_r14 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
 				offset_r14 *= sizeof(unsigned long);
 				offset_r14 += fp_displacement;
 				break;
 			case 18:
 				if (offset_r18 || fp_displacement == 0)
 					continue;

 				offset_r18 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
 				offset_r18 *= sizeof(unsigned long);
 				offset_r18 += fp_displacement;
 				break;
 			}

 			break;
 		case (0xcc >> 2): /* movi */
 			if (dest >= 63) {
 				printk(KERN_NOTICE "%s: Invalid dest reg %d "
 				       "specified in movi handler. Failed "
 				       "opcode was 0x%lx: ", __func__,
 				       dest, op);

 				continue;
 			}

 			/* Sign extend */
 			regcache[dest] =
 				sign_extend64((((u64)op >> 10) & 0xffff), 9);
 			break;
 		case (0xd0 >> 2): /* addi */
 		case (0xd4 >> 2): /* addi.l */
 			/* Look for r15, -FRAME_SIZE, r15 */
 			if (src != 15 || dest != 15)
 				continue;

 			/* Sign extended frame size.. */
 			fp_displacement +=
 				(u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
 			fp_prev = fp - fp_displacement;
 			break;
 		}

 		if (found_prologue_end && offset_r14 && (offset_r18 || *pprev_pc) && fp_prev)
 			break;
 	}

 	if (offset_r14 == 0 || fp_prev == 0) {
 		if (!offset_r14)
 			pr_debug("Unable to find r14 offset\n");
 		if (!fp_prev)
 			pr_debug("Unable to find previous fp\n");

 		return -EINVAL;
 	}

 	/* For innermost leaf function, there might not be a offset_r18 */
 	if (!*pprev_pc && (offset_r18 == 0))
 		return -EINVAL;

 	*pprev_fp = *(unsigned long *)(fp_prev + offset_r14);

 	if (offset_r18)
 		*pprev_pc = *(unsigned long *)(fp_prev + offset_r18);

 	*pprev_pc &= ~1;

 	return 0;
 }

 /*
  * Don't put this on the stack since we'll want to call in to
  * sh64_unwinder_dump() when we're close to underflowing the stack
  * anyway.
  */
 static struct pt_regs here_regs;

 extern const char syscall_ret;
 extern const char ret_from_syscall;
 extern const char ret_from_exception;
 extern const char ret_from_irq;

 static void sh64_unwind_inner(const struct stacktrace_ops *ops,
 			      void *data, struct pt_regs *regs);

 static inline void unwind_nested(const struct stacktrace_ops *ops, void *data,
 				 unsigned long pc, unsigned long fp)
 {
 	if ((fp >= __MEMORY_START) &&
 	    ((fp & 7) == 0))
 		sh64_unwind_inner(ops, data, (struct pt_regs *)fp);
 }

 static void sh64_unwind_inner(const struct stacktrace_ops *ops,
 			      void *data, struct pt_regs *regs)
 {
 	unsigned long pc, fp;
 	int ofs = 0;
 	int first_pass;

 	pc = regs->pc & ~1;
 	fp = regs->regs[14];

 	first_pass = 1;
 	for (;;) {
 		int cond;
 		unsigned long next_fp, next_pc;

 		if (pc == ((unsigned long)&syscall_ret & ~1)) {
 			printk("SYSCALL\n");
 			unwind_nested(ops, data, pc, fp);
 			return;
 		}

 		if (pc == ((unsigned long)&ret_from_syscall & ~1)) {
 			printk("SYSCALL (PREEMPTED)\n");
 			unwind_nested(ops, data, pc, fp);
 			return;
 		}

 		/* In this case, the PC is discovered by lookup_prev_stack_frame but
 		   it has 4 taken off it to look like the 'caller' */
 		if (pc == ((unsigned long)&ret_from_exception & ~1)) {
 			printk("EXCEPTION\n");
 			unwind_nested(ops, data, pc, fp);
 			return;
 		}

 		if (pc == ((unsigned long)&ret_from_irq & ~1)) {
 			printk("IRQ\n");
 			unwind_nested(ops, data, pc, fp);
 			return;
 		}

 		cond = ((pc >= __MEMORY_START) && (fp >= __MEMORY_START) &&
 			((pc & 3) == 0) && ((fp & 7) == 0));

 		pc -= ofs;

 		ops->address(data, pc, 1);

 		if (first_pass) {
 			/* If the innermost frame is a leaf function, it's
 			 * possible that r18 is never saved out to the stack.
 			 */
 			next_pc = regs->regs[18];
 		} else {
 			next_pc = 0;
 		}

 		if (lookup_prev_stack_frame(fp, pc, &next_fp, &next_pc, regs) == 0) {
 			ofs = sizeof(unsigned long);
 			pc = next_pc & ~1;
 			fp = next_fp;
 		} else {
 			printk("Unable to lookup previous stack frame\n");
 			break;
 		}
 		first_pass = 0;
 	}

 	printk("\n");
 }

 static void sh64_unwinder_dump(struct task_struct *task,
 			       struct pt_regs *regs,
 			       unsigned long *sp,
 			       const struct stacktrace_ops *ops,
 			       void *data)
 {
 	if (!regs) {
 		/*
 		 * Fetch current regs if we have no other saved state to back
 		 * trace from.
 		 */
 		regs = &here_regs;

 		__asm__ __volatile__ ("ori r14, 0, %0" : "=r" (regs->regs[14]));
 		__asm__ __volatile__ ("ori r15, 0, %0" : "=r" (regs->regs[15]));
 		__asm__ __volatile__ ("ori r18, 0, %0" : "=r" (regs->regs[18]));

 		__asm__ __volatile__ ("gettr tr0, %0" : "=r" (regs->tregs[0]));
 		__asm__ __volatile__ ("gettr tr1, %0" : "=r" (regs->tregs[1]));
 		__asm__ __volatile__ ("gettr tr2, %0" : "=r" (regs->tregs[2]));
 		__asm__ __volatile__ ("gettr tr3, %0" : "=r" (regs->tregs[3]));
 		__asm__ __volatile__ ("gettr tr4, %0" : "=r" (regs->tregs[4]));
 		__asm__ __volatile__ ("gettr tr5, %0" : "=r" (regs->tregs[5]));
 		__asm__ __volatile__ ("gettr tr6, %0" : "=r" (regs->tregs[6]));
 		__asm__ __volatile__ ("gettr tr7, %0" : "=r" (regs->tregs[7]));

 		__asm__ __volatile__ (
 			"pta 0f, tr0\n\t"
 			"blink tr0, %0\n\t"
 			"0: nop"
 			: "=r" (regs->pc)
 		);
 	}

 	sh64_unwind_inner(ops, data, regs);
 }

 static struct unwinder sh64_unwinder = {
 	.name	= "sh64-unwinder",
 	.dump	= sh64_unwinder_dump,
 	.rating	= 150,
 };

 static int __init sh64_unwinder_init(void)
 {
 	return unwinder_register(&sh64_unwinder);
 }
 early_initcall(sh64_unwinder_init);
	// SPDX-License-Identifier: GPL-2.0
	/*
	* arch/sh/kernel/cpu/sh5/unwind.c
	*
	* Copyright (C) 2004 Paul Mundt
	* Copyright (C) 2004 Richard Curnow
	*/
	#include <linux/kallsyms.h>
	#include <linux/kernel.h>
	#include <linux/types.h>
	#include <linux/errno.h>
	#include <asm/page.h>
	#include <asm/ptrace.h>
	#include <asm/processor.h>
	#include <asm/io.h>
	#include <asm/unwinder.h>
	#include <asm/stacktrace.h>

	static u8 regcache[63];

	/*
	* Finding the previous stack frame isn't horribly straightforward as it is
	* on some other platforms. In the sh64 case, we don't have "linked" stack
	* frames, so we need to do a bit of work to determine the previous frame,
	* and in turn, the previous r14/r18 pair.
	*
	* There are generally a few cases which determine where we can find out
	* the r14/r18 values. In the general case, this can be determined by poking
	* around the prologue of the symbol PC is in (note that we absolutely must
	* have frame pointer support as well as the kernel symbol table mapped,
	* otherwise we can't even get this far).
	*
	* In other cases, such as the interrupt/exception path, we can poke around
	* the sp/fp.
	*
	* Notably, this entire approach is somewhat error prone, and in the event
	* that the previous frame cannot be determined, that's all we can do.
	* Either way, this still leaves us with a more correct backtrace then what
	* we would be able to come up with by walking the stack (which is garbage
	* for anything beyond the first frame).
	* -- PFM.
	*/
	static int lookup_prev_stack_frame(unsigned long fp, unsigned long pc,
	unsigned long pprev_fp, unsigned long pprev_pc,
	struct pt_regs *regs)
	{
	const char *sym;
	char namebuf[128];
	unsigned long offset;
	unsigned long prologue = 0;
	unsigned long fp_displacement = 0;
	unsigned long fp_prev = 0;
	unsigned long offset_r14 = 0, offset_r18 = 0;
	int i, found_prologue_end = 0;

	sym = kallsyms_lookup(pc, NULL, &offset, NULL, namebuf);
	if (!sym)
	return -EINVAL;

	prologue = pc - offset;
	if (!prologue)
	return -EINVAL;

	/* Validate fp, to avoid risk of dereferencing a bad pointer later.
	Assume 128Mb since that's the amount of RAM on a Cayman. Modify
	when there is an SH-5 board with more. */
	if ((fp < (unsigned long) phys_to_virt(__MEMORY_START)) \|\|
	(fp >= (unsigned long)(phys_to_virt(__MEMORY_START)) + 12810241024) \|\|
	((fp & 7) != 0)) {
	return -EINVAL;
	}

	/*
	* Depth to walk, depth is completely arbitrary.
	*/
	for (i = 0; i < 100; i++, prologue += sizeof(unsigned long)) {
	unsigned long op;
	u8 major, minor;
	u8 src, dest, disp;

	op = (unsigned long )prologue;

	major = (op >> 26) & 0x3f;
	src = (op >> 20) & 0x3f;
	minor = (op >> 16) & 0xf;
	disp = (op >> 10) & 0x3f;
	dest = (op >> 4) & 0x3f;

	/*
	* Stack frame creation happens in a number of ways.. in the
	* general case when the stack frame is less than 511 bytes,
	* it's generally created by an addi or addi.l:
	*
	* addi/addi.l r15, -FRAME_SIZE, r15
	*
	* in the event that the frame size is bigger than this, it's
	* typically created using a movi/sub pair as follows:
	*
	* movi FRAME_SIZE, rX
	* sub r15, rX, r15
	*/

	switch (major) {
	case (0x00 >> 2):
	switch (minor) {
	case 0x8: /* add.l */
	case 0x9: /* add */
	/* Look for r15, r63, r14 */
	if (src == 15 && disp == 63 && dest == 14)
	found_prologue_end = 1;

	break;
	case 0xa: /* sub.l */
	case 0xb: /* sub */
	if (src != 15 \|\| dest != 15)
	continue;

	fp_displacement -= regcache[disp];
	fp_prev = fp - fp_displacement;
	break;
	}
	break;
	case (0xa8 >> 2): /* st.l */
	if (src != 15)
	continue;

	switch (dest) {
	case 14:
	if (offset_r14 \|\| fp_displacement == 0)
	continue;

	offset_r14 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
	offset_r14 *= sizeof(unsigned long);
	offset_r14 += fp_displacement;
	break;
	case 18:
	if (offset_r18 \|\| fp_displacement == 0)
	continue;

	offset_r18 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
	offset_r18 *= sizeof(unsigned long);
	offset_r18 += fp_displacement;
	break;
	}

	break;
	case (0xcc >> 2): /* movi */
	if (dest >= 63) {
	printk(KERN_NOTICE "%s: Invalid dest reg %d "
	"specified in movi handler. Failed "
	"opcode was 0x%lx: ", __func__,
	dest, op);

	continue;
	}

	/* Sign extend */
	regcache[dest] =
	sign_extend64((((u64)op >> 10) & 0xffff), 9);
	break;
	case (0xd0 >> 2): /* addi */
	case (0xd4 >> 2): /* addi.l */
	/* Look for r15, -FRAME_SIZE, r15 */
	if (src != 15 \|\| dest != 15)
	continue;

	/* Sign extended frame size.. */
	fp_displacement +=
	(u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
	fp_prev = fp - fp_displacement;
	break;
	}

	if (found_prologue_end && offset_r14 && (offset_r18 \|\| *pprev_pc) && fp_prev)
	break;
	}

	if (offset_r14 == 0 \|\| fp_prev == 0) {
	if (!offset_r14)
	pr_debug("Unable to find r14 offset\n");
	if (!fp_prev)
	pr_debug("Unable to find previous fp\n");

	return -EINVAL;
	}

	/* For innermost leaf function, there might not be a offset_r18 */
	if (!*pprev_pc && (offset_r18 == 0))
	return -EINVAL;

	pprev_fp = (unsigned long *)(fp_prev + offset_r14);

	if (offset_r18)
	pprev_pc = (unsigned long *)(fp_prev + offset_r18);

	*pprev_pc &= ~1;

	return 0;
	}

	/*
	* Don't put this on the stack since we'll want to call in to
	* sh64_unwinder_dump() when we're close to underflowing the stack
	* anyway.
	*/
	static struct pt_regs here_regs;

	extern const char syscall_ret;
	extern const char ret_from_syscall;
	extern const char ret_from_exception;
	extern const char ret_from_irq;

	static void sh64_unwind_inner(const struct stacktrace_ops *ops,
	void data, struct pt_regs regs);

	static inline void unwind_nested(const struct stacktrace_ops ops, void data,
	unsigned long pc, unsigned long fp)
	{
	if ((fp >= __MEMORY_START) &&
	((fp & 7) == 0))
	sh64_unwind_inner(ops, data, (struct pt_regs *)fp);
	}

	static void sh64_unwind_inner(const struct stacktrace_ops *ops,
	void data, struct pt_regs regs)
	{
	unsigned long pc, fp;
	int ofs = 0;
	int first_pass;

	pc = regs->pc & ~1;
	fp = regs->regs[14];

	first_pass = 1;
	for (;;) {
	int cond;
	unsigned long next_fp, next_pc;

	if (pc == ((unsigned long)&syscall_ret & ~1)) {
	printk("SYSCALL\n");
	unwind_nested(ops, data, pc, fp);
	return;
	}

	if (pc == ((unsigned long)&ret_from_syscall & ~1)) {
	printk("SYSCALL (PREEMPTED)\n");
	unwind_nested(ops, data, pc, fp);
	return;
	}

	/* In this case, the PC is discovered by lookup_prev_stack_frame but
	it has 4 taken off it to look like the 'caller' */
	if (pc == ((unsigned long)&ret_from_exception & ~1)) {
	printk("EXCEPTION\n");
	unwind_nested(ops, data, pc, fp);
	return;
	}

	if (pc == ((unsigned long)&ret_from_irq & ~1)) {
	printk("IRQ\n");
	unwind_nested(ops, data, pc, fp);
	return;
	}

	cond = ((pc >= __MEMORY_START) && (fp >= __MEMORY_START) &&
	((pc & 3) == 0) && ((fp & 7) == 0));

	pc -= ofs;

	ops->address(data, pc, 1);

	if (first_pass) {
	/* If the innermost frame is a leaf function, it's
	* possible that r18 is never saved out to the stack.
	*/
	next_pc = regs->regs[18];
	} else {
	next_pc = 0;
	}

	if (lookup_prev_stack_frame(fp, pc, &next_fp, &next_pc, regs) == 0) {
	ofs = sizeof(unsigned long);
	pc = next_pc & ~1;
	fp = next_fp;
	} else {
	printk("Unable to lookup previous stack frame\n");
	break;
	}
	first_pass = 0;
	}

	printk("\n");
	}

	static void sh64_unwinder_dump(struct task_struct *task,
	struct pt_regs *regs,
	unsigned long *sp,
	const struct stacktrace_ops *ops,
	void *data)
	{
	if (!regs) {
	/*
	* Fetch current regs if we have no other saved state to back
	* trace from.
	*/
	regs = &here_regs;

	__asm__ __volatile__ ("ori r14, 0, %0" : "=r" (regs->regs[14]));
	__asm__ __volatile__ ("ori r15, 0, %0" : "=r" (regs->regs[15]));
	__asm__ __volatile__ ("ori r18, 0, %0" : "=r" (regs->regs[18]));

	__asm__ __volatile__ ("gettr tr0, %0" : "=r" (regs->tregs[0]));
	__asm__ __volatile__ ("gettr tr1, %0" : "=r" (regs->tregs[1]));
	__asm__ __volatile__ ("gettr tr2, %0" : "=r" (regs->tregs[2]));
	__asm__ __volatile__ ("gettr tr3, %0" : "=r" (regs->tregs[3]));
	__asm__ __volatile__ ("gettr tr4, %0" : "=r" (regs->tregs[4]));
	__asm__ __volatile__ ("gettr tr5, %0" : "=r" (regs->tregs[5]));
	__asm__ __volatile__ ("gettr tr6, %0" : "=r" (regs->tregs[6]));
	__asm__ __volatile__ ("gettr tr7, %0" : "=r" (regs->tregs[7]));

	__asm__ __volatile__ (
	"pta 0f, tr0\n\t"
	"blink tr0, %0\n\t"
	"0: nop"
	: "=r" (regs->pc)
	);
	}

	sh64_unwind_inner(ops, data, regs);
	}

	static struct unwinder sh64_unwinder = {
	.name = "sh64-unwinder",
	.dump = sh64_unwinder_dump,
	.rating = 150,
	};

	static int __init sh64_unwinder_init(void)
	{
	return unwinder_register(&sh64_unwinder);
	}
	early_initcall(sh64_unwinder_init);