powerpc: Add kprobe-based event tracer (359e4284) · Commits · e / devices / android_kernel_fairphone_FP3

arch/powerpc/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -140,6 +140,7 @@ config PPC
		select HAVE_SYSCALL_WRAPPERS if PPC64
		select GENERIC_ATOMIC64 if PPC32
		select HAVE_PERF_EVENTS
		select HAVE_REGS_AND_STACK_ACCESS_API

		config EARLY_PRINTK
		bool

arch/powerpc/include/asm/ptrace.h

+64 −0

Original line number	Diff line number	Diff line
		@@ -89,6 +89,7 @@ struct pt_regs {

		#define instruction_pointer(regs) ((regs)->nip)
		#define user_stack_pointer(regs) ((regs)->gpr[1])
		#define kernel_stack_pointer(regs) ((regs)->gpr[1])
		#define regs_return_value(regs) ((regs)->gpr[3])

		#ifdef CONFIG_SMP
		@@ -141,6 +142,69 @@ do { \
		#define arch_has_block_step() (!cpu_has_feature(CPU_FTR_601))
		#define ARCH_HAS_USER_SINGLE_STEP_INFO

		/*
		* kprobe-based event tracer support
		*/

		#include <linux/stddef.h>
		#include <linux/thread_info.h>
		extern int regs_query_register_offset(const char *name);
		extern const char *regs_query_register_name(unsigned int offset);
		#define MAX_REG_OFFSET (offsetof(struct pt_regs, dsisr))

		/**
		* regs_get_register() - get register value from its offset
		* @regs: pt_regs from which register value is gotten
		* @offset: offset number 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 unsigned long regs_get_register(struct pt_regs *regs,
		unsigned int offset)
		{
		if (unlikely(offset > MAX_REG_OFFSET))
		return 0;
		return (unsigned long )((unsigned long)regs + offset);
		}

		/**
		* 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 inline bool regs_within_kernel_stack(struct pt_regs *regs,
		unsigned long addr)
		{
		return ((addr & ~(THREAD_SIZE - 1)) ==
		(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));
		}

		/**
		* 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.
		*/
		static inline 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;
		}

		#endif /* __ASSEMBLY__ */

		#endif /* __KERNEL__ */

arch/powerpc/kernel/ptrace.c

+103 −0

Original line number	Diff line number	Diff line
		@@ -38,6 +38,109 @@
		#include <asm/pgtable.h>
		#include <asm/system.h>

		/*
		* The parameter save area on the stack is used to store arguments being passed
		* to callee function and is located at fixed offset from stack pointer.
		*/
		#ifdef CONFIG_PPC32
		#define PARAMETER_SAVE_AREA_OFFSET 24 /* bytes */
		#else /* CONFIG_PPC32 */
		#define PARAMETER_SAVE_AREA_OFFSET 48 /* bytes */
		#endif

		struct pt_regs_offset {
		const char *name;
		int offset;
		};

		#define STR(s) #s /* convert to string */
		#define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
		#define GPR_OFFSET_NAME(num) \
		{.name = STR(gpr##num), .offset = offsetof(struct pt_regs, gpr[num])}
		#define REG_OFFSET_END {.name = NULL, .offset = 0}

		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),
		GPR_OFFSET_NAME(31),
		REG_OFFSET_NAME(nip),
		REG_OFFSET_NAME(msr),
		REG_OFFSET_NAME(ctr),
		REG_OFFSET_NAME(link),
		REG_OFFSET_NAME(xer),
		REG_OFFSET_NAME(ccr),
		#ifdef CONFIG_PPC64
		REG_OFFSET_NAME(softe),
		#else
		REG_OFFSET_NAME(mq),
		#endif
		REG_OFFSET_NAME(trap),
		REG_OFFSET_NAME(dar),
		REG_OFFSET_NAME(dsisr),
		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_query_register_name() - query register name from its offset
		* @offset: the offset of a register in struct pt_regs.
		*
		* regs_query_register_name() returns the name of a register from its
		* offset in struct pt_regs. If the @offset is invalid, this returns NULL;
		*/
		const char *regs_query_register_name(unsigned int offset)
		{
		const struct pt_regs_offset *roff;
		for (roff = regoffset_table; roff->name != NULL; roff++)
		if (roff->offset == offset)
		return roff->name;
		return NULL;
		}

		/*
		* does not yet catch signals sent when the child dies.
		* in exit.c or in signal.c.