[thirdparty/linux.git] / arch / csky / kernel / ptrace.c

// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.

#include <linux/audit.h>
#include <linux/elf.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/ptrace.h>
#include <linux/regset.h>
#include <linux/sched.h>
#include <linux/sched/task_stack.h>
#include <linux/signal.h>
#include <linux/smp.h>
#include <linux/tracehook.h>
#include <linux/uaccess.h>
#include <linux/user.h>

#include <asm/thread_info.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/processor.h>
#include <asm/asm-offsets.h>

#include <abi/regdef.h>

#define CREATE_TRACE_POINTS
#include <trace/events/syscalls.h>

/* sets the trace bits. */
#define TRACE_MODE_SI      (1 << 14)
#define TRACE_MODE_RUN     0
#define TRACE_MODE_MASK    ~(0x3 << 14)

/*
 * Make sure the single step bit is not set.
 */
static void singlestep_disable(struct task_struct *tsk)
{
	struct pt_regs *regs;

	regs = task_pt_regs(tsk);
	regs->sr = (regs->sr & TRACE_MODE_MASK) | TRACE_MODE_RUN;

	/* Enable irq */
	regs->sr |= BIT(6);
}

static void singlestep_enable(struct task_struct *tsk)
{
	struct pt_regs *regs;

	regs = task_pt_regs(tsk);
	regs->sr = (regs->sr & TRACE_MODE_MASK) | TRACE_MODE_SI;

	/* Disable irq */
	regs->sr &= ~BIT(6);
}

/*
 * Make sure the single step bit is set.
 */
void user_enable_single_step(struct task_struct *child)
{
	singlestep_enable(child);
}

void user_disable_single_step(struct task_struct *child)
{
	singlestep_disable(child);
}

enum csky_regset {
	REGSET_GPR,
	REGSET_FPR,
};

static int gpr_get(struct task_struct *target,
		   const struct user_regset *regset,
		   unsigned int pos, unsigned int count,
		   void *kbuf, void __user *ubuf)
{
	struct pt_regs *regs;

	regs = task_pt_regs(target);

	/* Abiv1 regs->tls is fake and we need sync here. */
	regs->tls = task_thread_info(target)->tp_value;

	return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
}

static int gpr_set(struct task_struct *target,
		    const struct user_regset *regset,
		    unsigned int pos, unsigned int count,
		    const void *kbuf, const void __user *ubuf)
{
	int ret;
	struct pt_regs regs;

	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &regs, 0, -1);
	if (ret)
		return ret;

	regs.sr = task_pt_regs(target)->sr;
#ifdef CONFIG_CPU_HAS_HILO
	regs.dcsr = task_pt_regs(target)->dcsr;
#endif
	task_thread_info(target)->tp_value = regs.tls;

	*task_pt_regs(target) = regs;

	return 0;
}

static int fpr_get(struct task_struct *target,
		   const struct user_regset *regset,
		   unsigned int pos, unsigned int count,
		   void *kbuf, void __user *ubuf)
{
	struct user_fp *regs = (struct user_fp *)&target->thread.user_fp;

#if defined(CONFIG_CPU_HAS_FPUV2) && !defined(CONFIG_CPU_HAS_VDSP)
	int i;
	struct user_fp tmp = *regs;

	for (i = 0; i < 16; i++) {
		tmp.vr[i*4] = regs->vr[i*2];
		tmp.vr[i*4 + 1] = regs->vr[i*2 + 1];
	}

	for (i = 0; i < 32; i++)
		tmp.vr[64 + i] = regs->vr[32 + i];

	return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &tmp, 0, -1);
#else
	return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
#endif
}

static int fpr_set(struct task_struct *target,
		   const struct user_regset *regset,
		   unsigned int pos, unsigned int count,
		   const void *kbuf, const void __user *ubuf)
{
	int ret;
	struct user_fp *regs = (struct user_fp *)&target->thread.user_fp;

#if defined(CONFIG_CPU_HAS_FPUV2) && !defined(CONFIG_CPU_HAS_VDSP)
	int i;
	struct user_fp tmp;

	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &tmp, 0, -1);

	*regs = tmp;

	for (i = 0; i < 16; i++) {
		regs->vr[i*2] = tmp.vr[i*4];
		regs->vr[i*2 + 1] = tmp.vr[i*4 + 1];
	}

	for (i = 0; i < 32; i++)
		regs->vr[32 + i] = tmp.vr[64 + i];
#else
	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
#endif

	return ret;
}

static const struct user_regset csky_regsets[] = {
	[REGSET_GPR] = {
		.core_note_type = NT_PRSTATUS,
		.n = sizeof(struct pt_regs) / sizeof(u32),
		.size = sizeof(u32),
		.align = sizeof(u32),
		.get = &gpr_get,
		.set = &gpr_set,
	},
	[REGSET_FPR] = {
		.core_note_type = NT_PRFPREG,
		.n = sizeof(struct user_fp) / sizeof(u32),
		.size = sizeof(u32),
		.align = sizeof(u32),
		.get = &fpr_get,
		.set = &fpr_set,
	},
};

static const struct user_regset_view user_csky_view = {
	.name = "csky",
	.e_machine = ELF_ARCH,
	.regsets = csky_regsets,
	.n = ARRAY_SIZE(csky_regsets),
};

const struct user_regset_view *task_user_regset_view(struct task_struct *task)
{
	return &user_csky_view;
}

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}

static const struct pt_regs_offset regoffset_table[] = {
	REG_OFFSET_NAME(tls),
	REG_OFFSET_NAME(lr),
	REG_OFFSET_NAME(pc),
	REG_OFFSET_NAME(sr),
	REG_OFFSET_NAME(usp),
	REG_OFFSET_NAME(orig_a0),
	REG_OFFSET_NAME(a0),
	REG_OFFSET_NAME(a1),
	REG_OFFSET_NAME(a2),
	REG_OFFSET_NAME(a3),
	REG_OFFSET_NAME(regs[0]),
	REG_OFFSET_NAME(regs[1]),
	REG_OFFSET_NAME(regs[2]),
	REG_OFFSET_NAME(regs[3]),
	REG_OFFSET_NAME(regs[4]),
	REG_OFFSET_NAME(regs[5]),
	REG_OFFSET_NAME(regs[6]),
	REG_OFFSET_NAME(regs[7]),
	REG_OFFSET_NAME(regs[8]),
	REG_OFFSET_NAME(regs[9]),
#if defined(__CSKYABIV2__)
	REG_OFFSET_NAME(exregs[0]),
	REG_OFFSET_NAME(exregs[1]),
	REG_OFFSET_NAME(exregs[2]),
	REG_OFFSET_NAME(exregs[3]),
	REG_OFFSET_NAME(exregs[4]),
	REG_OFFSET_NAME(exregs[5]),
	REG_OFFSET_NAME(exregs[6]),
	REG_OFFSET_NAME(exregs[7]),
	REG_OFFSET_NAME(exregs[8]),
	REG_OFFSET_NAME(exregs[9]),
	REG_OFFSET_NAME(exregs[10]),
	REG_OFFSET_NAME(exregs[11]),
	REG_OFFSET_NAME(exregs[12]),
	REG_OFFSET_NAME(exregs[13]),
	REG_OFFSET_NAME(exregs[14]),
	REG_OFFSET_NAME(rhi),
	REG_OFFSET_NAME(rlo),
	REG_OFFSET_NAME(dcsr),
#endif
	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));
}

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

void ptrace_disable(struct task_struct *child)
{
	singlestep_disable(child);
}

long arch_ptrace(struct task_struct *child, long request,
		 unsigned long addr, unsigned long data)
{
	long ret = -EIO;

	switch (request) {
	default:
		ret = ptrace_request(child, request, addr, data);
		break;
	}

	return ret;
}

asmlinkage void syscall_trace_enter(struct pt_regs *regs)
{
	if (test_thread_flag(TIF_SYSCALL_TRACE))
		if (tracehook_report_syscall_entry(regs))
			syscall_set_nr(current, regs, -1);

	if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
		trace_sys_enter(regs, syscall_get_nr(current, regs));

	audit_syscall_entry(regs_syscallid(regs), regs->a0, regs->a1, regs->a2, regs->a3);
}

asmlinkage void syscall_trace_exit(struct pt_regs *regs)
{
	audit_syscall_exit(regs);

	if (test_thread_flag(TIF_SYSCALL_TRACE))
		tracehook_report_syscall_exit(regs, 0);

	if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
		trace_sys_exit(regs, syscall_get_return_value(current, regs));
}

extern void show_stack(struct task_struct *task, unsigned long *stack);
void show_regs(struct pt_regs *fp)
{
	unsigned long   *sp;
	unsigned char   *tp;
	int	i;

	pr_info("\nCURRENT PROCESS:\n\n");
	pr_info("COMM=%s PID=%d\n", current->comm, current->pid);

	if (current->mm) {
		pr_info("TEXT=%08x-%08x DATA=%08x-%08x BSS=%08x-%08x\n",
		       (int) current->mm->start_code,
		       (int) current->mm->end_code,
		       (int) current->mm->start_data,
		       (int) current->mm->end_data,
		       (int) current->mm->end_data,
		       (int) current->mm->brk);
		pr_info("USER-STACK=%08x  KERNEL-STACK=%08x\n\n",
		       (int) current->mm->start_stack,
		       (int) (((unsigned long) current) + 2 * PAGE_SIZE));
	}

	pr_info("PC: 0x%08lx (%pS)\n", (long)fp->pc, (void *)fp->pc);
	pr_info("LR: 0x%08lx (%pS)\n", (long)fp->lr, (void *)fp->lr);
	pr_info("SP: 0x%08lx\n", (long)fp);
	pr_info("orig_a0: 0x%08lx\n", fp->orig_a0);
	pr_info("PSR: 0x%08lx\n", (long)fp->sr);

	pr_info(" a0: 0x%08lx   a1: 0x%08lx   a2: 0x%08lx   a3: 0x%08lx\n",
		fp->a0, fp->a1, fp->a2, fp->a3);
#if defined(__CSKYABIV2__)
	pr_info(" r4: 0x%08lx   r5: 0x%08lx   r6: 0x%08lx   r7: 0x%08lx\n",
		fp->regs[0], fp->regs[1], fp->regs[2], fp->regs[3]);
	pr_info(" r8: 0x%08lx   r9: 0x%08lx  r10: 0x%08lx  r11: 0x%08lx\n",
		fp->regs[4], fp->regs[5], fp->regs[6], fp->regs[7]);
	pr_info("r12: 0x%08lx  r13: 0x%08lx  r15: 0x%08lx\n",
		fp->regs[8], fp->regs[9], fp->lr);
	pr_info("r16: 0x%08lx  r17: 0x%08lx  r18: 0x%08lx  r19: 0x%08lx\n",
		fp->exregs[0], fp->exregs[1], fp->exregs[2], fp->exregs[3]);
	pr_info("r20: 0x%08lx  r21: 0x%08lx  r22: 0x%08lx  r23: 0x%08lx\n",
		fp->exregs[4], fp->exregs[5], fp->exregs[6], fp->exregs[7]);
	pr_info("r24: 0x%08lx  r25: 0x%08lx  r26: 0x%08lx  r27: 0x%08lx\n",
		fp->exregs[8], fp->exregs[9], fp->exregs[10], fp->exregs[11]);
	pr_info("r28: 0x%08lx  r29: 0x%08lx  r30: 0x%08lx  tls: 0x%08lx\n",
		fp->exregs[12], fp->exregs[13], fp->exregs[14], fp->tls);
	pr_info(" hi: 0x%08lx   lo: 0x%08lx\n",
		fp->rhi, fp->rlo);
#else
	pr_info(" r6: 0x%08lx   r7: 0x%08lx   r8: 0x%08lx   r9: 0x%08lx\n",
		fp->regs[0], fp->regs[1], fp->regs[2], fp->regs[3]);
	pr_info("r10: 0x%08lx  r11: 0x%08lx  r12: 0x%08lx  r13: 0x%08lx\n",
		fp->regs[4], fp->regs[5], fp->regs[6], fp->regs[7]);
	pr_info("r14: 0x%08lx   r1: 0x%08lx  r15: 0x%08lx\n",
		fp->regs[8], fp->regs[9], fp->lr);
#endif

	pr_info("\nCODE:");
	tp = ((unsigned char *) fp->pc) - 0x20;
	tp += ((int)tp % 4) ? 2 : 0;
	for (sp = (unsigned long *) tp, i = 0; (i < 0x40);  i += 4) {
		if ((i % 0x10) == 0)
			pr_cont("\n%08x: ", (int) (tp + i));
		pr_cont("%08x ", (int) *sp++);
	}
	pr_cont("\n");

	pr_info("\nKERNEL STACK:");
	tp = ((unsigned char *) fp) - 0x40;
	for (sp = (unsigned long *) tp, i = 0; (i < 0xc0); i += 4) {
		if ((i % 0x10) == 0)
			pr_cont("\n%08x: ", (int) (tp + i));
		pr_cont("%08x ", (int) *sp++);
	}
	pr_cont("\n");

	show_stack(NULL, (unsigned long *)fp->regs[4]);
	return;
}
Commit	Line	Data
2ce36bfa GR	1	// SPDX-License-Identifier: GPL-2.0
	2	// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.
	3
2f7932b0	4	#include <linux/audit.h>
2ce36bfa GR	5	#include <linux/elf.h>
	6	#include <linux/errno.h>
	7	#include <linux/kernel.h>
	8	#include <linux/mm.h>
	9	#include <linux/ptrace.h>
	10	#include <linux/regset.h>
	11	#include <linux/sched.h>
9216cd72	12	#include <linux/sched/task_stack.h>
2ce36bfa GR	13	#include <linux/signal.h>
2ce36bfa GR	14	#include <linux/smp.h>
2f7932b0	15	#include <linux/tracehook.h>
2ce36bfa GR	16	#include <linux/uaccess.h>
	17	#include <linux/user.h>
	18
	19	#include <asm/thread_info.h>
	20	#include <asm/page.h>
	21	#include <asm/pgtable.h>
	22	#include <asm/processor.h>
	23	#include <asm/asm-offsets.h>
	24
	25	#include <abi/regdef.h>
	26
2f7932b0 GR	27	#define CREATE_TRACE_POINTS
	28	#include <trace/events/syscalls.h>
	29
2ce36bfa GR	30	/* sets the trace bits. */
	31	#define TRACE_MODE_SI (1 << 14)
	32	#define TRACE_MODE_RUN 0
	33	#define TRACE_MODE_MASK ~(0x3 << 14)
	34
	35	/*
	36	* Make sure the single step bit is not set.
	37	*/
	38	static void singlestep_disable(struct task_struct *tsk)
	39	{
	40	struct pt_regs *regs;
	41
	42	regs = task_pt_regs(tsk);
	43	regs->sr = (regs->sr & TRACE_MODE_MASK) \| TRACE_MODE_RUN;
c2e59d1f GR	44
	45	/* Enable irq */
	46	regs->sr \|= BIT(6);
2ce36bfa GR	47	}
	48
	49	static void singlestep_enable(struct task_struct *tsk)
	50	{
	51	struct pt_regs *regs;
	52
	53	regs = task_pt_regs(tsk);
	54	regs->sr = (regs->sr & TRACE_MODE_MASK) \| TRACE_MODE_SI;
c2e59d1f GR	55
	56	/* Disable irq */
	57	regs->sr &= ~BIT(6);
2ce36bfa GR	58	}
	59
	60	/*
	61	* Make sure the single step bit is set.
	62	*/
	63	void user_enable_single_step(struct task_struct *child)
	64	{
2ce36bfa GR	65	singlestep_enable(child);
	66	}
	67
	68	void user_disable_single_step(struct task_struct *child)
	69	{
2ce36bfa GR	70	singlestep_disable(child);
	71	}
	72
	73	enum csky_regset {
	74	REGSET_GPR,
	75	REGSET_FPR,
	76	};
	77
	78	static int gpr_get(struct task_struct *target,
	79	const struct user_regset *regset,
	80	unsigned int pos, unsigned int count,
	81	void kbuf, void __user ubuf)
	82	{
	83	struct pt_regs *regs;
	84
	85	regs = task_pt_regs(target);
	86
	87	/* Abiv1 regs->tls is fake and we need sync here. */
	88	regs->tls = task_thread_info(target)->tp_value;
	89
	90	return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
	91	}
	92
	93	static int gpr_set(struct task_struct *target,
	94	const struct user_regset *regset,
	95	unsigned int pos, unsigned int count,
	96	const void kbuf, const void __user ubuf)
	97	{
	98	int ret;
	99	struct pt_regs regs;
	100
	101	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &regs, 0, -1);
	102	if (ret)
	103	return ret;
	104
	105	regs.sr = task_pt_regs(target)->sr;
789154c2 GR	106	#ifdef CONFIG_CPU_HAS_HILO
	107	regs.dcsr = task_pt_regs(target)->dcsr;
	108	#endif
2ce36bfa GR	109	task_thread_info(target)->tp_value = regs.tls;
	110
	111	*task_pt_regs(target) = regs;
	112
	113	return 0;
	114	}
	115
	116	static int fpr_get(struct task_struct *target,
	117	const struct user_regset *regset,
	118	unsigned int pos, unsigned int count,
	119	void kbuf, void __user ubuf)
	120	{
	121	struct user_fp regs = (struct user_fp )&target->thread.user_fp;
	122
	123	#if defined(CONFIG_CPU_HAS_FPUV2) && !defined(CONFIG_CPU_HAS_VDSP)
	124	int i;
	125	struct user_fp tmp = *regs;
	126
	127	for (i = 0; i < 16; i++) {
	128	tmp.vr[i4] = regs->vr[i2];
	129	tmp.vr[i4 + 1] = regs->vr[i2 + 1];
	130	}
	131
	132	for (i = 0; i < 32; i++)
	133	tmp.vr[64 + i] = regs->vr[32 + i];
	134
	135	return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &tmp, 0, -1);
	136	#else
	137	return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
	138	#endif
	139	}
	140
	141	static int fpr_set(struct task_struct *target,
	142	const struct user_regset *regset,
	143	unsigned int pos, unsigned int count,
	144	const void kbuf, const void __user ubuf)
	145	{
	146	int ret;
	147	struct user_fp regs = (struct user_fp )&target->thread.user_fp;
	148
	149	#if defined(CONFIG_CPU_HAS_FPUV2) && !defined(CONFIG_CPU_HAS_VDSP)
	150	int i;
	151	struct user_fp tmp;
	152
	153	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &tmp, 0, -1);
	154
	155	*regs = tmp;
	156
	157	for (i = 0; i < 16; i++) {
	158	regs->vr[i2] = tmp.vr[i4];
	159	regs->vr[i2 + 1] = tmp.vr[i4 + 1];
	160	}
	161
	162	for (i = 0; i < 32; i++)
	163	regs->vr[32 + i] = tmp.vr[64 + i];
	164	#else
	165	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
	166	#endif
	167
	168	return ret;
	169	}
	170
	171	static const struct user_regset csky_regsets[] = {
	172	[REGSET_GPR] = {
173	.core_note_type = NT_PRSTATUS,
9216cd72	174	.n = sizeof(struct pt_regs) / sizeof(u32),
2ce36bfa GR	175	.size = sizeof(u32),
	176	.align = sizeof(u32),
	177	.get = &gpr_get,
	178	.set = &gpr_set,
	179	},
	180	[REGSET_FPR] = {
	181	.core_note_type = NT_PRFPREG,
	182	.n = sizeof(struct user_fp) / sizeof(u32),
	183	.size = sizeof(u32),
	184	.align = sizeof(u32),
	185	.get = &fpr_get,
	186	.set = &fpr_set,
	187	},
	188	};
	189
	190	static const struct user_regset_view user_csky_view = {
	191	.name = "csky",
	192	.e_machine = ELF_ARCH,
	193	.regsets = csky_regsets,
	194	.n = ARRAY_SIZE(csky_regsets),
	195	};
	196
	197	const struct user_regset_view task_user_regset_view(struct task_struct task)
	198	{
	199	return &user_csky_view;
	200	}
	201
bfe47f35 GR	202	struct pt_regs_offset {
	203	const char *name;
	204	int offset;
	205	};
	206
	207	#define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
	208	#define REG_OFFSET_END {.name = NULL, .offset = 0}
	209
	210	static const struct pt_regs_offset regoffset_table[] = {
	211	REG_OFFSET_NAME(tls),
	212	REG_OFFSET_NAME(lr),
	213	REG_OFFSET_NAME(pc),
	214	REG_OFFSET_NAME(sr),
	215	REG_OFFSET_NAME(usp),
	216	REG_OFFSET_NAME(orig_a0),
	217	REG_OFFSET_NAME(a0),
	218	REG_OFFSET_NAME(a1),
	219	REG_OFFSET_NAME(a2),
	220	REG_OFFSET_NAME(a3),
	221	REG_OFFSET_NAME(regs[0]),
	222	REG_OFFSET_NAME(regs[1]),
	223	REG_OFFSET_NAME(regs[2]),
	224	REG_OFFSET_NAME(regs[3]),
	225	REG_OFFSET_NAME(regs[4]),
	226	REG_OFFSET_NAME(regs[5]),
	227	REG_OFFSET_NAME(regs[6]),
	228	REG_OFFSET_NAME(regs[7]),
	229	REG_OFFSET_NAME(regs[8]),
	230	REG_OFFSET_NAME(regs[9]),
	231	#if defined(__CSKYABIV2__)
	232	REG_OFFSET_NAME(exregs[0]),
	233	REG_OFFSET_NAME(exregs[1]),
	234	REG_OFFSET_NAME(exregs[2]),
	235	REG_OFFSET_NAME(exregs[3]),
	236	REG_OFFSET_NAME(exregs[4]),
	237	REG_OFFSET_NAME(exregs[5]),
	238	REG_OFFSET_NAME(exregs[6]),
	239	REG_OFFSET_NAME(exregs[7]),
	240	REG_OFFSET_NAME(exregs[8]),
	241	REG_OFFSET_NAME(exregs[9]),
	242	REG_OFFSET_NAME(exregs[10]),
	243	REG_OFFSET_NAME(exregs[11]),
	244	REG_OFFSET_NAME(exregs[12]),
	245	REG_OFFSET_NAME(exregs[13]),
	246	REG_OFFSET_NAME(exregs[14]),
	247	REG_OFFSET_NAME(rhi),
	248	REG_OFFSET_NAME(rlo),
	249	REG_OFFSET_NAME(dcsr),
	250	#endif
	251	REG_OFFSET_END,
	252	};
	253
	254	/**
	255	* regs_query_register_offset() - query register offset from its name
	256	* @name: the name of a register
	257	*
	258	* regs_query_register_offset() returns the offset of a register in struct
	259	* pt_regs from its name. If the name is invalid, this returns -EINVAL;
	260	*/
	261	int regs_query_register_offset(const char *name)
	262	{
	263	const struct pt_regs_offset *roff;
	264
	265	for (roff = regoffset_table; roff->name != NULL; roff++)
266	if (!strcmp(roff->name, name))
267	return roff->offset;
268	return -EINVAL;
269	}
270
271	/**
272	* regs_within_kernel_stack() - check the address in the stack
273	* @regs: pt_regs which contains kernel stack pointer.
274	* @addr: address which is checked.
275	*
276	* regs_within_kernel_stack() checks @addr is within the kernel stack page(s).
277	* If @addr is within the kernel stack, it returns true. If not, returns false.
278	*/
279	static bool regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
280	{
281	return (addr & ~(THREAD_SIZE - 1)) ==
282	(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1));
283	}
284
285	/**
286	* regs_get_kernel_stack_nth() - get Nth entry of the stack
287	* @regs: pt_regs which contains kernel stack pointer.
288	* @n: stack entry number.
289	*
290	* regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
291	* is specified by @regs. If the @n th entry is NOT in the kernel stack,
292	* this returns 0.
293	*/
294	unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
295	{
296	unsigned long addr = (unsigned long )kernel_stack_pointer(regs);
297
298	addr += n;
299	if (regs_within_kernel_stack(regs, (unsigned long)addr))
300	return *addr;
301	else
302	return 0;
303	}
304
2ce36bfa GR	305	void ptrace_disable(struct task_struct *child)
	306	{
	307	singlestep_disable(child);
	308	}
	309
	310	long arch_ptrace(struct task_struct *child, long request,
	311	unsigned long addr, unsigned long data)
	312	{
	313	long ret = -EIO;
	314
	315	switch (request) {
	316	default:
	317	ret = ptrace_request(child, request, addr, data);
	318	break;
	319	}
	320
	321	return ret;
	322	}
	323
2f7932b0	324	asmlinkage void syscall_trace_enter(struct pt_regs *regs)
2ce36bfa	325	{
2f7932b0	326	if (test_thread_flag(TIF_SYSCALL_TRACE))
a691f333 GR	327	if (tracehook_report_syscall_entry(regs))
a691f333 GR	328	syscall_set_nr(current, regs, -1);
2f7932b0 GR	329
	330	if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
	331	trace_sys_enter(regs, syscall_get_nr(current, regs));
	332
	333	audit_syscall_entry(regs_syscallid(regs), regs->a0, regs->a1, regs->a2, regs->a3);
	334	}
	335
	336	asmlinkage void syscall_trace_exit(struct pt_regs *regs)
	337	{
	338	audit_syscall_exit(regs);
	339
	340	if (test_thread_flag(TIF_SYSCALL_TRACE))
	341	tracehook_report_syscall_exit(regs, 0);
2ce36bfa	342
2f7932b0 GR	343	if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
2f7932b0 GR	344	trace_sys_exit(regs, syscall_get_return_value(current, regs));
2ce36bfa GR	345	}
2ce36bfa GR	346
8f4f1639	347	extern void show_stack(struct task_struct task, unsigned long stack);
2ce36bfa GR	348	void show_regs(struct pt_regs *fp)
	349	{
	350	unsigned long *sp;
	351	unsigned char *tp;
	352	int i;
	353
	354	pr_info("\nCURRENT PROCESS:\n\n");
	355	pr_info("COMM=%s PID=%d\n", current->comm, current->pid);
	356
	357	if (current->mm) {
	358	pr_info("TEXT=%08x-%08x DATA=%08x-%08x BSS=%08x-%08x\n",
	359	(int) current->mm->start_code,
	360	(int) current->mm->end_code,
	361	(int) current->mm->start_data,
	362	(int) current->mm->end_data,
	363	(int) current->mm->end_data,
	364	(int) current->mm->brk);
	365	pr_info("USER-STACK=%08x KERNEL-STACK=%08x\n\n",
	366	(int) current->mm->start_stack,
	367	(int) (((unsigned long) current) + 2 * PAGE_SIZE));
	368	}
	369
8f4f1639 GR	370	pr_info("PC: 0x%08lx (%pS)\n", (long)fp->pc, (void *)fp->pc);
	371	pr_info("LR: 0x%08lx (%pS)\n", (long)fp->lr, (void *)fp->lr);
	372	pr_info("SP: 0x%08lx\n", (long)fp);
2ce36bfa GR	373	pr_info("orig_a0: 0x%08lx\n", fp->orig_a0);
	374	pr_info("PSR: 0x%08lx\n", (long)fp->sr);
	375
8f4f1639 GR	376	pr_info(" a0: 0x%08lx a1: 0x%08lx a2: 0x%08lx a3: 0x%08lx\n",
8f4f1639 GR	377	fp->a0, fp->a1, fp->a2, fp->a3);
2ce36bfa	378	#if defined(__CSKYABIV2__)
8f4f1639	379	pr_info(" r4: 0x%08lx r5: 0x%08lx r6: 0x%08lx r7: 0x%08lx\n",
2ce36bfa	380	fp->regs[0], fp->regs[1], fp->regs[2], fp->regs[3]);
8f4f1639	381	pr_info(" r8: 0x%08lx r9: 0x%08lx r10: 0x%08lx r11: 0x%08lx\n",
2ce36bfa	382	fp->regs[4], fp->regs[5], fp->regs[6], fp->regs[7]);
8f4f1639	383	pr_info("r12: 0x%08lx r13: 0x%08lx r15: 0x%08lx\n",
2ce36bfa	384	fp->regs[8], fp->regs[9], fp->lr);
8f4f1639	385	pr_info("r16: 0x%08lx r17: 0x%08lx r18: 0x%08lx r19: 0x%08lx\n",
2ce36bfa	386	fp->exregs[0], fp->exregs[1], fp->exregs[2], fp->exregs[3]);
8f4f1639	387	pr_info("r20: 0x%08lx r21: 0x%08lx r22: 0x%08lx r23: 0x%08lx\n",
2ce36bfa	388	fp->exregs[4], fp->exregs[5], fp->exregs[6], fp->exregs[7]);
8f4f1639	389	pr_info("r24: 0x%08lx r25: 0x%08lx r26: 0x%08lx r27: 0x%08lx\n",
2ce36bfa	390	fp->exregs[8], fp->exregs[9], fp->exregs[10], fp->exregs[11]);
8f4f1639	391	pr_info("r28: 0x%08lx r29: 0x%08lx r30: 0x%08lx tls: 0x%08lx\n",
2ce36bfa	392	fp->exregs[12], fp->exregs[13], fp->exregs[14], fp->tls);
8f4f1639	393	pr_info(" hi: 0x%08lx lo: 0x%08lx\n",
2ce36bfa GR	394	fp->rhi, fp->rlo);
2ce36bfa GR	395	#else
8f4f1639	396	pr_info(" r6: 0x%08lx r7: 0x%08lx r8: 0x%08lx r9: 0x%08lx\n",
2ce36bfa	397	fp->regs[0], fp->regs[1], fp->regs[2], fp->regs[3]);
8f4f1639	398	pr_info("r10: 0x%08lx r11: 0x%08lx r12: 0x%08lx r13: 0x%08lx\n",
2ce36bfa	399	fp->regs[4], fp->regs[5], fp->regs[6], fp->regs[7]);
8f4f1639	400	pr_info("r14: 0x%08lx r1: 0x%08lx r15: 0x%08lx\n",
2ce36bfa GR	401	fp->regs[8], fp->regs[9], fp->lr);
	402	#endif
	403
	404	pr_info("\nCODE:");
	405	tp = ((unsigned char *) fp->pc) - 0x20;
	406	tp += ((int)tp % 4) ? 2 : 0;
	407	for (sp = (unsigned long *) tp, i = 0; (i < 0x40); i += 4) {
	408	if ((i % 0x10) == 0)
	409	pr_cont("\n%08x: ", (int) (tp + i));
	410	pr_cont("%08x ", (int) *sp++);
	411	}
	412	pr_cont("\n");
	413
	414	pr_info("\nKERNEL STACK:");
	415	tp = ((unsigned char *) fp) - 0x40;
	416	for (sp = (unsigned long *) tp, i = 0; (i < 0xc0); i += 4) {
	417	if ((i % 0x10) == 0)
	418	pr_cont("\n%08x: ", (int) (tp + i));
	419	pr_cont("%08x ", (int) *sp++);
	420	}
	421	pr_cont("\n");
8f4f1639 GR	422
	423	show_stack(NULL, (unsigned long *)fp->regs[4]);
	424	return;
2ce36bfa	425	}