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

Commit 0a8ea52c authored by David A. Long's avatar David A. Long Committed by Catalin Marinas
Browse files

arm64: Add HAVE_REGS_AND_STACK_ACCESS_API feature 



Add HAVE_REGS_AND_STACK_ACCESS_API feature for arm64, including supporting
functions and defines.

Signed-off-by: default avatarDavid A. Long <dave.long@linaro.org>
Acked-by: default avatarMasami Hiramatsu <mhiramat@kernel.org>
[catalin.marinas@arm.com: Remove unused functions]
Signed-off-by: default avatarCatalin Marinas <catalin.marinas@arm.com>
parent 33688abb

arch/arm/include/asm/ptrace.h

+0 −1
Original line number Diff line number Diff line
@@ -121,7 +121,6 @@ extern unsigned long profile_pc(struct pt_regs *regs); 
#define MAX_REG_OFFSET (offsetof(struct pt_regs, ARM_ORIG_r0))



extern int regs_query_register_offset(const char *name);

extern const char *regs_query_register_name(unsigned int offset);

extern bool regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr);

extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,

					       unsigned int n);

arch/arm64/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -85,6 +85,7 @@ config ARM64 
	select HAVE_PERF_EVENTS

	select HAVE_PERF_REGS

	select HAVE_PERF_USER_STACK_DUMP

	select HAVE_REGS_AND_STACK_ACCESS_API

	select HAVE_RCU_TABLE_FREE

	select HAVE_SYSCALL_TRACEPOINTS

	select IOMMU_DMA if IOMMU_SUPPORT

arch/arm64/include/asm/ptrace.h

+50 −0
Original line number Diff line number Diff line
@@ -74,6 +74,7 @@ 
#define COMPAT_PT_DATA_ADDR		0x10004

#define COMPAT_PT_TEXT_END_ADDR		0x10008

#ifndef __ASSEMBLY__

#include <linux/bug.h>



/* sizeof(struct user) for AArch32 */

#define COMPAT_USER_SZ	296
@@ -119,6 +120,8 @@ struct pt_regs { 
	u64 syscallno;

};



#define MAX_REG_OFFSET offsetof(struct pt_regs, pstate)



#define arch_has_single_step()	(1)



#ifdef CONFIG_COMPAT
@@ -147,6 +150,53 @@ struct pt_regs { 
#define user_stack_pointer(regs) \

	(!compat_user_mode(regs) ? (regs)->sp : (regs)->compat_sp)



extern int regs_query_register_offset(const char *name);

extern const char *regs_query_register_name(unsigned int offset);

extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,

					       unsigned int n);



/**

 * regs_get_register() - get register value from its offset

 * @regs:	pt_regs from which register value is gotten

 * @offset:	offset of the register.

 *

 * regs_get_register returns the value of a register whose offset from @regs.

 * The @offset is the offset of the register in struct pt_regs.

 * If @offset is bigger than MAX_REG_OFFSET, this returns 0.

 */

static inline u64 regs_get_register(struct pt_regs *regs, unsigned int offset)

{

	u64 val = 0;



	WARN_ON(offset & 7);



	offset >>= 3;

	switch (offset) {

	case 0 ... 30:

		val = regs->regs[offset];

		break;

	case offsetof(struct pt_regs, sp) >> 3:

		val = regs->sp;

		break;

	case offsetof(struct pt_regs, pc) >> 3:

		val = regs->pc;

		break;

	case offsetof(struct pt_regs, pstate) >> 3:

		val = regs->pstate;

		break;

	default:

		val = 0;

	}



	return val;

}



/* Valid only for Kernel mode traps. */

static inline unsigned long kernel_stack_pointer(struct pt_regs *regs)

{

	return regs->sp;

}



static inline unsigned long regs_return_value(struct pt_regs *regs)

{

	return regs->regs[0];

arch/arm64/kernel/ptrace.c

+101 −0
Original line number Diff line number Diff line
@@ -48,6 +48,107 @@ 
#define CREATE_TRACE_POINTS

#include <trace/events/syscalls.h>



struct pt_regs_offset {

	const char *name;

	int offset;

};



#define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}

#define REG_OFFSET_END {.name = NULL, .offset = 0}

#define GPR_OFFSET_NAME(r) \

	{.name = "x" #r, .offset = offsetof(struct pt_regs, regs[r])}



static const struct pt_regs_offset regoffset_table[] = {

	GPR_OFFSET_NAME(0),

	GPR_OFFSET_NAME(1),

	GPR_OFFSET_NAME(2),

	GPR_OFFSET_NAME(3),

	GPR_OFFSET_NAME(4),

	GPR_OFFSET_NAME(5),

	GPR_OFFSET_NAME(6),

	GPR_OFFSET_NAME(7),

	GPR_OFFSET_NAME(8),

	GPR_OFFSET_NAME(9),

	GPR_OFFSET_NAME(10),

	GPR_OFFSET_NAME(11),

	GPR_OFFSET_NAME(12),

	GPR_OFFSET_NAME(13),

	GPR_OFFSET_NAME(14),

	GPR_OFFSET_NAME(15),

	GPR_OFFSET_NAME(16),

	GPR_OFFSET_NAME(17),

	GPR_OFFSET_NAME(18),

	GPR_OFFSET_NAME(19),

	GPR_OFFSET_NAME(20),

	GPR_OFFSET_NAME(21),

	GPR_OFFSET_NAME(22),

	GPR_OFFSET_NAME(23),

	GPR_OFFSET_NAME(24),

	GPR_OFFSET_NAME(25),

	GPR_OFFSET_NAME(26),

	GPR_OFFSET_NAME(27),

	GPR_OFFSET_NAME(28),

	GPR_OFFSET_NAME(29),

	GPR_OFFSET_NAME(30),

	{.name = "lr", .offset = offsetof(struct pt_regs, regs[30])},

	REG_OFFSET_NAME(sp),

	REG_OFFSET_NAME(pc),

	REG_OFFSET_NAME(pstate),

	REG_OFFSET_END,

};



/**

 * regs_query_register_offset() - query register offset from its name

 * @name:	the name of a register

 *

 * regs_query_register_offset() returns the offset of a register in struct

 * pt_regs from its name. If the name is invalid, this returns -EINVAL;

 */

int regs_query_register_offset(const char *name)

{

	const struct pt_regs_offset *roff;



	for (roff = regoffset_table; roff->name != NULL; roff++)

		if (!strcmp(roff->name, name))

			return roff->offset;

	return -EINVAL;

}



/**

 * regs_within_kernel_stack() - check the address in the stack

 * @regs:      pt_regs which contains kernel stack pointer.

 * @addr:      address which is checked.

 *

 * regs_within_kernel_stack() checks @addr is within the kernel stack page(s).

 * If @addr is within the kernel stack, it returns true. If not, returns false.

 */

static bool regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)

{

	return ((addr & ~(THREAD_SIZE - 1))  ==

		(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1))) ||

		on_irq_stack(addr, raw_smp_processor_id());

}



/**

 * regs_get_kernel_stack_nth() - get Nth entry of the stack

 * @regs:	pt_regs which contains kernel stack pointer.

 * @n:		stack entry number.

 *

 * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which

 * is specified by @regs. If the @n th entry is NOT in the kernel stack,

 * this returns 0.

 */

unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)

{

	unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);



	addr += n;

	if (regs_within_kernel_stack(regs, (unsigned long)addr))

		return *addr;

	else

		return 0;

}



/*

 * TODO: does not yet catch signals sent when the child dies.

 * in exit.c or in signal.c.