[mirror_ubuntu-hirsute-kernel.git] / arch / sh / kernel / ptrace_32.c

// SPDX-License-Identifier: GPL-2.0
/*
 * SuperH process tracing
 *
 * Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
 * Copyright (C) 2002 - 2009  Paul Mundt
 *
 * Audit support by Yuichi Nakamura <ynakam@hitachisoft.jp>
 */
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/sched/task_stack.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/user.h>
#include <linux/security.h>
#include <linux/signal.h>
#include <linux/io.h>
#include <linux/audit.h>
#include <linux/seccomp.h>
#include <linux/tracehook.h>
#include <linux/elf.h>
#include <linux/regset.h>
#include <linux/hw_breakpoint.h>
#include <linux/uaccess.h>
#include <asm/processor.h>
#include <asm/mmu_context.h>
#include <asm/syscalls.h>
#include <asm/fpu.h>

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

/*
 * This routine will get a word off of the process kernel stack.
 */
static inline int get_stack_long(struct task_struct *task, int offset)
{
	unsigned char *stack;

	stack = (unsigned char *)task_pt_regs(task);
	stack += offset;
	return (*((int *)stack));
}

/*
 * This routine will put a word on the process kernel stack.
 */
static inline int put_stack_long(struct task_struct *task, int offset,
				 unsigned long data)
{
	unsigned char *stack;

	stack = (unsigned char *)task_pt_regs(task);
	stack += offset;
	*(unsigned long *) stack = data;
	return 0;
}

void ptrace_triggered(struct perf_event *bp,
		      struct perf_sample_data *data, struct pt_regs *regs)
{
	struct perf_event_attr attr;

	/*
	 * Disable the breakpoint request here since ptrace has defined a
	 * one-shot behaviour for breakpoint exceptions.
	 */
	attr = bp->attr;
	attr.disabled = true;
	modify_user_hw_breakpoint(bp, &attr);
}

static int set_single_step(struct task_struct *tsk, unsigned long addr)
{
	struct thread_struct *thread = &tsk->thread;
	struct perf_event *bp;
	struct perf_event_attr attr;

	bp = thread->ptrace_bps[0];
	if (!bp) {
		ptrace_breakpoint_init(&attr);

		attr.bp_addr = addr;
		attr.bp_len = HW_BREAKPOINT_LEN_2;
		attr.bp_type = HW_BREAKPOINT_R;

		bp = register_user_hw_breakpoint(&attr, ptrace_triggered,
						 NULL, tsk);
		if (IS_ERR(bp))
			return PTR_ERR(bp);

		thread->ptrace_bps[0] = bp;
	} else {
		int err;

		attr = bp->attr;
		attr.bp_addr = addr;
		/* reenable breakpoint */
		attr.disabled = false;
		err = modify_user_hw_breakpoint(bp, &attr);
		if (unlikely(err))
			return err;
	}

	return 0;
}

void user_enable_single_step(struct task_struct *child)
{
	unsigned long pc = get_stack_long(child, offsetof(struct pt_regs, pc));

	set_tsk_thread_flag(child, TIF_SINGLESTEP);

	set_single_step(child, pc);
}

void user_disable_single_step(struct task_struct *child)
{
	clear_tsk_thread_flag(child, TIF_SINGLESTEP);
}

/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure single step bits etc are not set.
 */
void ptrace_disable(struct task_struct *child)
{
	user_disable_single_step(child);
}

static int genregs_get(struct task_struct *target,
		       const struct user_regset *regset,
		       struct membuf to)
{
	const struct pt_regs *regs = task_pt_regs(target);

	return membuf_write(&to, regs, sizeof(struct pt_regs));
}

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

	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
				 regs->regs,
				 0, 16 * sizeof(unsigned long));
	if (!ret && count > 0)
		ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
					 &regs->pc,
					 offsetof(struct pt_regs, pc),
					 sizeof(struct pt_regs));
	if (!ret)
		ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
						sizeof(struct pt_regs), -1);

	return ret;
}

#ifdef CONFIG_SH_FPU
static int fpregs_get(struct task_struct *target,
	       const struct user_regset *regset,
	       struct membuf to)
{
	int ret;

	ret = init_fpu(target);
	if (ret)
		return ret;

	return membuf_write(&to, target->thread.xstate,
			    sizeof(struct user_fpu_struct));
}

static int fpregs_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;

	ret = init_fpu(target);
	if (ret)
		return ret;

	set_stopped_child_used_math(target);

	if ((boot_cpu_data.flags & CPU_HAS_FPU))
		return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
					  &target->thread.xstate->hardfpu, 0, -1);

	return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
				  &target->thread.xstate->softfpu, 0, -1);
}

static int fpregs_active(struct task_struct *target,
			 const struct user_regset *regset)
{
	return tsk_used_math(target) ? regset->n : 0;
}
#endif

#ifdef CONFIG_SH_DSP
static int dspregs_get(struct task_struct *target,
		       const struct user_regset *regset,
		       struct membuf to)
{
	const struct pt_dspregs *regs =
		(struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;

	return membuf_write(&to, regs, sizeof(struct pt_dspregs));
}

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

	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs,
				 0, sizeof(struct pt_dspregs));
	if (!ret)
		ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
						sizeof(struct pt_dspregs), -1);

	return ret;
}

static int dspregs_active(struct task_struct *target,
			  const struct user_regset *regset)
{
	struct pt_regs *regs = task_pt_regs(target);

	return regs->sr & SR_DSP ? regset->n : 0;
}
#endif

const struct pt_regs_offset regoffset_table[] = {
	REGS_OFFSET_NAME(0),
	REGS_OFFSET_NAME(1),
	REGS_OFFSET_NAME(2),
	REGS_OFFSET_NAME(3),
	REGS_OFFSET_NAME(4),
	REGS_OFFSET_NAME(5),
	REGS_OFFSET_NAME(6),
	REGS_OFFSET_NAME(7),
	REGS_OFFSET_NAME(8),
	REGS_OFFSET_NAME(9),
	REGS_OFFSET_NAME(10),
	REGS_OFFSET_NAME(11),
	REGS_OFFSET_NAME(12),
	REGS_OFFSET_NAME(13),
	REGS_OFFSET_NAME(14),
	REGS_OFFSET_NAME(15),
	REG_OFFSET_NAME(pc),
	REG_OFFSET_NAME(pr),
	REG_OFFSET_NAME(sr),
	REG_OFFSET_NAME(gbr),
	REG_OFFSET_NAME(mach),
	REG_OFFSET_NAME(macl),
	REG_OFFSET_NAME(tra),
	REG_OFFSET_END,
};

/*
 * These are our native regset flavours.
 */
enum sh_regset {
	REGSET_GENERAL,
#ifdef CONFIG_SH_FPU
	REGSET_FPU,
#endif
#ifdef CONFIG_SH_DSP
	REGSET_DSP,
#endif
};

static const struct user_regset sh_regsets[] = {
	/*
	 * Format is:
	 *	R0 --> R15
	 *	PC, PR, SR, GBR, MACH, MACL, TRA
	 */
	[REGSET_GENERAL] = {
		.core_note_type	= NT_PRSTATUS,
		.n		= ELF_NGREG,
		.size		= sizeof(long),
		.align		= sizeof(long),
		.regset_get		= genregs_get,
		.set		= genregs_set,
	},

#ifdef CONFIG_SH_FPU
	[REGSET_FPU] = {
		.core_note_type	= NT_PRFPREG,
		.n		= sizeof(struct user_fpu_struct) / sizeof(long),
		.size		= sizeof(long),
		.align		= sizeof(long),
		.regset_get		= fpregs_get,
		.set		= fpregs_set,
		.active		= fpregs_active,
	},
#endif

#ifdef CONFIG_SH_DSP
	[REGSET_DSP] = {
		.n		= sizeof(struct pt_dspregs) / sizeof(long),
		.size		= sizeof(long),
		.align		= sizeof(long),
		.regset_get		= dspregs_get,
		.set		= dspregs_set,
		.active		= dspregs_active,
	},
#endif
};

static const struct user_regset_view user_sh_native_view = {
	.name		= "sh",
	.e_machine	= EM_SH,
	.regsets	= sh_regsets,
	.n		= ARRAY_SIZE(sh_regsets),
};

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

long arch_ptrace(struct task_struct *child, long request,
		 unsigned long addr, unsigned long data)
{
	unsigned long __user *datap = (unsigned long __user *)data;
	int ret;

	switch (request) {
	/* read the word at location addr in the USER area. */
	case PTRACE_PEEKUSR: {
		unsigned long tmp;

		ret = -EIO;
		if ((addr & 3) || addr < 0 ||
		    addr > sizeof(struct user) - 3)
			break;

		if (addr < sizeof(struct pt_regs))
			tmp = get_stack_long(child, addr);
		else if (addr >= offsetof(struct user, fpu) &&
			 addr < offsetof(struct user, u_fpvalid)) {
			if (!tsk_used_math(child)) {
				if (addr == offsetof(struct user, fpu.fpscr))
					tmp = FPSCR_INIT;
				else
					tmp = 0;
			} else {
				unsigned long index;
				ret = init_fpu(child);
				if (ret)
					break;
				index = addr - offsetof(struct user, fpu);
				tmp = ((unsigned long *)child->thread.xstate)
					[index >> 2];
			}
		} else if (addr == offsetof(struct user, u_fpvalid))
			tmp = !!tsk_used_math(child);
		else if (addr == PT_TEXT_ADDR)
			tmp = child->mm->start_code;
		else if (addr == PT_DATA_ADDR)
			tmp = child->mm->start_data;
		else if (addr == PT_TEXT_END_ADDR)
			tmp = child->mm->end_code;
		else if (addr == PT_TEXT_LEN)
			tmp = child->mm->end_code - child->mm->start_code;
		else
			tmp = 0;
		ret = put_user(tmp, datap);
		break;
	}

	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
		ret = -EIO;
		if ((addr & 3) || addr < 0 ||
		    addr > sizeof(struct user) - 3)
			break;

		if (addr < sizeof(struct pt_regs))
			ret = put_stack_long(child, addr, data);
		else if (addr >= offsetof(struct user, fpu) &&
			 addr < offsetof(struct user, u_fpvalid)) {
			unsigned long index;
			ret = init_fpu(child);
			if (ret)
				break;
			index = addr - offsetof(struct user, fpu);
			set_stopped_child_used_math(child);
			((unsigned long *)child->thread.xstate)
				[index >> 2] = data;
			ret = 0;
		} else if (addr == offsetof(struct user, u_fpvalid)) {
			conditional_stopped_child_used_math(data, child);
			ret = 0;
		}
		break;

	case PTRACE_GETREGS:
		return copy_regset_to_user(child, &user_sh_native_view,
					   REGSET_GENERAL,
					   0, sizeof(struct pt_regs),
					   datap);
	case PTRACE_SETREGS:
		return copy_regset_from_user(child, &user_sh_native_view,
					     REGSET_GENERAL,
					     0, sizeof(struct pt_regs),
					     datap);
#ifdef CONFIG_SH_FPU
	case PTRACE_GETFPREGS:
		return copy_regset_to_user(child, &user_sh_native_view,
					   REGSET_FPU,
					   0, sizeof(struct user_fpu_struct),
					   datap);
	case PTRACE_SETFPREGS:
		return copy_regset_from_user(child, &user_sh_native_view,
					     REGSET_FPU,
					     0, sizeof(struct user_fpu_struct),
					     datap);
#endif
#ifdef CONFIG_SH_DSP
	case PTRACE_GETDSPREGS:
		return copy_regset_to_user(child, &user_sh_native_view,
					   REGSET_DSP,
					   0, sizeof(struct pt_dspregs),
					   datap);
	case PTRACE_SETDSPREGS:
		return copy_regset_from_user(child, &user_sh_native_view,
					     REGSET_DSP,
					     0, sizeof(struct pt_dspregs),
					     datap);
#endif
	default:
		ret = ptrace_request(child, request, addr, data);
		break;
	}

	return ret;
}

asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
{
	if (test_thread_flag(TIF_SYSCALL_TRACE) &&
	    tracehook_report_syscall_entry(regs)) {
		regs->regs[0] = -ENOSYS;
		return -1;
	}

	if (secure_computing() == -1)
		return -1;

	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
		trace_sys_enter(regs, regs->regs[0]);

	audit_syscall_entry(regs->regs[3], regs->regs[4], regs->regs[5],
			    regs->regs[6], regs->regs[7]);

	return 0;
}

asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
{
	int step;

	audit_syscall_exit(regs);

	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
		trace_sys_exit(regs, regs->regs[0]);

	step = test_thread_flag(TIF_SINGLESTEP);
	if (step || test_thread_flag(TIF_SYSCALL_TRACE))
		tracehook_report_syscall_exit(regs, step);
}
Commit	Line	Data
5933f6d2	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
934135c1	3	* SuperH process tracing
1da177e4	4	*
934135c1	5	* Copyright (C) 1999, 2000 Kaz Kojima & Niibe Yutaka
34d0b5af	6	* Copyright (C) 2002 - 2009 Paul Mundt
1da177e4	7	*
934135c1	8	* Audit support by Yuichi Nakamura <ynakam@hitachisoft.jp>
1da177e4	9	*/
1da177e4 LT	10	#include <linux/kernel.h>
1da177e4 LT	11	#include <linux/sched.h>
68db0cf1	12	#include <linux/sched/task_stack.h>
1da177e4 LT	13	#include <linux/mm.h>
1da177e4 LT	14	#include <linux/smp.h>
1da177e4 LT	15	#include <linux/errno.h>
	16	#include <linux/ptrace.h>
	17	#include <linux/user.h>
1da177e4	18	#include <linux/security.h>
7ed20e1a	19	#include <linux/signal.h>
9432f968	20	#include <linux/io.h>
1322b9de	21	#include <linux/audit.h>
c4637d47	22	#include <linux/seccomp.h>
ab99c733	23	#include <linux/tracehook.h>
934135c1 PM	24	#include <linux/elf.h>
934135c1 PM	25	#include <linux/regset.h>
34d0b5af	26	#include <linux/hw_breakpoint.h>
7c0f6ba6	27	#include <linux/uaccess.h>
1da177e4 LT	28	#include <asm/processor.h>
1da177e4 LT	29	#include <asm/mmu_context.h>
fa43972f	30	#include <asm/syscalls.h>
e7ab3cd2	31	#include <asm/fpu.h>
1da177e4	32
a74f7e04 PM	33	#define CREATE_TRACE_POINTS
a74f7e04 PM	34	#include <trace/events/syscalls.h>
c652d780	35
1da177e4 LT	36	/*
	37	* This routine will get a word off of the process kernel stack.
	38	*/
	39	static inline int get_stack_long(struct task_struct *task, int offset)
	40	{
	41	unsigned char *stack;
	42
3cf0f4ec	43	stack = (unsigned char *)task_pt_regs(task);
1da177e4 LT	44	stack += offset;
	45	return (((int )stack));
	46	}
	47
	48	/*
	49	* This routine will put a word on the process kernel stack.
	50	*/
	51	static inline int put_stack_long(struct task_struct *task, int offset,
	52	unsigned long data)
	53	{
	54	unsigned char *stack;
	55
3cf0f4ec	56	stack = (unsigned char *)task_pt_regs(task);
1da177e4 LT	57	stack += offset;
	58	(unsigned long ) stack = data;
	59	return 0;
	60	}
	61
a8b0ca17	62	void ptrace_triggered(struct perf_event *bp,
34d0b5af	63	struct perf_sample_data data, struct pt_regs regs)
c459dbf2	64	{
34d0b5af PM	65	struct perf_event_attr attr;
	66
	67	/*
	68	* Disable the breakpoint request here since ptrace has defined a
	69	* one-shot behaviour for breakpoint exceptions.
	70	*/
	71	attr = bp->attr;
	72	attr.disabled = true;
	73	modify_user_hw_breakpoint(bp, &attr);
	74	}
	75
	76	static int set_single_step(struct task_struct *tsk, unsigned long addr)
c459dbf2	77	{
34d0b5af PM	78	struct thread_struct *thread = &tsk->thread;
	79	struct perf_event *bp;
	80	struct perf_event_attr attr;
	81
	82	bp = thread->ptrace_bps[0];
	83	if (!bp) {
73266fc1	84	ptrace_breakpoint_init(&attr);
34d0b5af PM	85
	86	attr.bp_addr = addr;
	87	attr.bp_len = HW_BREAKPOINT_LEN_2;
	88	attr.bp_type = HW_BREAKPOINT_R;
c459dbf2	89
4dc0da86 AK	90	bp = register_user_hw_breakpoint(&attr, ptrace_triggered,
4dc0da86 AK	91	NULL, tsk);
34d0b5af PM	92	if (IS_ERR(bp))
	93	return PTR_ERR(bp);
	94
	95	thread->ptrace_bps[0] = bp;
	96	} else {
	97	int err;
	98
	99	attr = bp->attr;
	100	attr.bp_addr = addr;
fb7f045a DE	101	/* reenable breakpoint */
fb7f045a DE	102	attr.disabled = false;
34d0b5af PM	103	err = modify_user_hw_breakpoint(bp, &attr);
	104	if (unlikely(err))
	105	return err;
	106	}
	107
	108	return 0;
	109	}
c459dbf2	110
c459dbf2 PM	111	void user_enable_single_step(struct task_struct *child)
c459dbf2 PM	112	{
34d0b5af	113	unsigned long pc = get_stack_long(child, offsetof(struct pt_regs, pc));
c459dbf2 PM	114
c459dbf2 PM	115	set_tsk_thread_flag(child, TIF_SINGLESTEP);
34d0b5af PM	116
34d0b5af PM	117	set_single_step(child, pc);
c459dbf2 PM	118	}
	119
	120	void user_disable_single_step(struct task_struct *child)
9432f968 SM	121	{
9432f968 SM	122	clear_tsk_thread_flag(child, TIF_SINGLESTEP);
9432f968 SM	123	}
9432f968 SM	124
1da177e4 LT	125	/*
	126	* Called by kernel/ptrace.c when detaching..
	127	*
	128	* Make sure single step bits etc are not set.
	129	*/
	130	void ptrace_disable(struct task_struct *child)
	131	{
c459dbf2	132	user_disable_single_step(child);
1da177e4 LT	133	}
1da177e4 LT	134
934135c1 PM	135	static int genregs_get(struct task_struct *target,
934135c1 PM	136	const struct user_regset *regset,
3399d90c	137	struct membuf to)
934135c1 PM	138	{
934135c1 PM	139	const struct pt_regs *regs = task_pt_regs(target);
934135c1	140
3399d90c	141	return membuf_write(&to, regs, sizeof(struct pt_regs));
934135c1 PM	142	}
	143
	144	static int genregs_set(struct task_struct *target,
	145	const struct user_regset *regset,
	146	unsigned int pos, unsigned int count,
	147	const void kbuf, const void __user ubuf)
	148	{
	149	struct pt_regs *regs = task_pt_regs(target);
	150	int ret;
	151
	152	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
	153	regs->regs,
	154	0, 16 * sizeof(unsigned long));
	155	if (!ret && count > 0)
	156	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
	157	&regs->pc,
	158	offsetof(struct pt_regs, pc),
	159	sizeof(struct pt_regs));
	160	if (!ret)
	161	ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
	162	sizeof(struct pt_regs), -1);
	163
	164	return ret;
	165	}
	166
e7ab3cd2	167	#ifdef CONFIG_SH_FPU
bb1a773d	168	static int fpregs_get(struct task_struct *target,
e7ab3cd2	169	const struct user_regset *regset,
3399d90c	170	struct membuf to)
e7ab3cd2 PM	171	{
	172	int ret;
	173
	174	ret = init_fpu(target);
	175	if (ret)
	176	return ret;
	177
3399d90c AV	178	return membuf_write(&to, target->thread.xstate,
3399d90c AV	179	sizeof(struct user_fpu_struct));
e7ab3cd2 PM	180	}
	181
	182	static int fpregs_set(struct task_struct *target,
	183	const struct user_regset *regset,
	184	unsigned int pos, unsigned int count,
	185	const void kbuf, const void __user ubuf)
	186	{
	187	int ret;
	188
	189	ret = init_fpu(target);
	190	if (ret)
	191	return ret;
	192
	193	set_stopped_child_used_math(target);
	194
	195	if ((boot_cpu_data.flags & CPU_HAS_FPU))
	196	return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
0ea820cf	197	&target->thread.xstate->hardfpu, 0, -1);
e7ab3cd2 PM	198
e7ab3cd2 PM	199	return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
0ea820cf	200	&target->thread.xstate->softfpu, 0, -1);
e7ab3cd2 PM	201	}
	202
	203	static int fpregs_active(struct task_struct *target,
	204	const struct user_regset *regset)
	205	{
	206	return tsk_used_math(target) ? regset->n : 0;
	207	}
	208	#endif
	209
5dadb343 PM	210	#ifdef CONFIG_SH_DSP
	211	static int dspregs_get(struct task_struct *target,
	212	const struct user_regset *regset,
3399d90c	213	struct membuf to)
5dadb343	214	{
01ab1039 MT	215	const struct pt_dspregs *regs =
01ab1039 MT	216	(struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
5dadb343	217
3399d90c	218	return membuf_write(&to, regs, sizeof(struct pt_dspregs));
5dadb343 PM	219	}
	220
	221	static int dspregs_set(struct task_struct *target,
	222	const struct user_regset *regset,
	223	unsigned int pos, unsigned int count,
	224	const void kbuf, const void __user ubuf)
	225	{
01ab1039 MT	226	struct pt_dspregs *regs =
01ab1039 MT	227	(struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
5dadb343 PM	228	int ret;
	229
	230	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs,
	231	0, sizeof(struct pt_dspregs));
	232	if (!ret)
	233	ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
	234	sizeof(struct pt_dspregs), -1);
	235
	236	return ret;
	237	}
72461997 PM	238
	239	static int dspregs_active(struct task_struct *target,
	240	const struct user_regset *regset)
	241	{
	242	struct pt_regs *regs = task_pt_regs(target);
	243
	244	return regs->sr & SR_DSP ? regset->n : 0;
	245	}
5dadb343 PM	246	#endif
5dadb343 PM	247
eaaaeef3 PM	248	const struct pt_regs_offset regoffset_table[] = {
	249	REGS_OFFSET_NAME(0),
	250	REGS_OFFSET_NAME(1),
	251	REGS_OFFSET_NAME(2),
	252	REGS_OFFSET_NAME(3),
	253	REGS_OFFSET_NAME(4),
	254	REGS_OFFSET_NAME(5),
	255	REGS_OFFSET_NAME(6),
	256	REGS_OFFSET_NAME(7),
	257	REGS_OFFSET_NAME(8),
	258	REGS_OFFSET_NAME(9),
	259	REGS_OFFSET_NAME(10),
	260	REGS_OFFSET_NAME(11),
	261	REGS_OFFSET_NAME(12),
	262	REGS_OFFSET_NAME(13),
	263	REGS_OFFSET_NAME(14),
	264	REGS_OFFSET_NAME(15),
	265	REG_OFFSET_NAME(pc),
	266	REG_OFFSET_NAME(pr),
	267	REG_OFFSET_NAME(sr),
	268	REG_OFFSET_NAME(gbr),
	269	REG_OFFSET_NAME(mach),
	270	REG_OFFSET_NAME(macl),
	271	REG_OFFSET_NAME(tra),
	272	REG_OFFSET_END,
	273	};
	274
934135c1 PM	275	/*
	276	* These are our native regset flavours.
	277	*/
	278	enum sh_regset {
	279	REGSET_GENERAL,
e7ab3cd2 PM	280	#ifdef CONFIG_SH_FPU
	281	REGSET_FPU,
	282	#endif
5dadb343 PM	283	#ifdef CONFIG_SH_DSP
	284	REGSET_DSP,
	285	#endif
934135c1 PM	286	};
	287
	288	static const struct user_regset sh_regsets[] = {
	289	/*
	290	* Format is:
	291	* R0 --> R15
	292	* PC, PR, SR, GBR, MACH, MACL, TRA
	293	*/
	294	[REGSET_GENERAL] = {
	295	.core_note_type = NT_PRSTATUS,
	296	.n = ELF_NGREG,
	297	.size = sizeof(long),
	298	.align = sizeof(long),
3399d90c	299	.regset_get = genregs_get,
934135c1 PM	300	.set = genregs_set,
934135c1 PM	301	},
5dadb343	302
e7ab3cd2 PM	303	#ifdef CONFIG_SH_FPU
	304	[REGSET_FPU] = {
	305	.core_note_type = NT_PRFPREG,
	306	.n = sizeof(struct user_fpu_struct) / sizeof(long),
	307	.size = sizeof(long),
	308	.align = sizeof(long),
3399d90c	309	.regset_get = fpregs_get,
e7ab3cd2 PM	310	.set = fpregs_set,
	311	.active = fpregs_active,
	312	},
	313	#endif
	314
5dadb343 PM	315	#ifdef CONFIG_SH_DSP
	316	[REGSET_DSP] = {
	317	.n = sizeof(struct pt_dspregs) / sizeof(long),
	318	.size = sizeof(long),
	319	.align = sizeof(long),
3399d90c	320	.regset_get = dspregs_get,
5dadb343	321	.set = dspregs_set,
72461997	322	.active = dspregs_active,
5dadb343 PM	323	},
5dadb343 PM	324	#endif
934135c1 PM	325	};
	326
	327	static const struct user_regset_view user_sh_native_view = {
	328	.name = "sh",
	329	.e_machine = EM_SH,
	330	.regsets = sh_regsets,
	331	.n = ARRAY_SIZE(sh_regsets),
	332	};
	333
f9540ece PM	334	const struct user_regset_view task_user_regset_view(struct task_struct task)
	335	{
	336	return &user_sh_native_view;
	337	}
	338
9b05a69e NK	339	long arch_ptrace(struct task_struct *child, long request,
9b05a69e NK	340	unsigned long addr, unsigned long data)
1da177e4	341	{
fa43972f	342	unsigned long __user datap = (unsigned long __user )data;
1da177e4 LT	343	int ret;
1da177e4 LT	344
1da177e4	345	switch (request) {
1da177e4 LT	346	/* read the word at location addr in the USER area. */
	347	case PTRACE_PEEKUSR: {
	348	unsigned long tmp;
	349
	350	ret = -EIO;
9432f968	351	if ((addr & 3) \|\| addr < 0 \|\|
1da177e4 LT	352	addr > sizeof(struct user) - 3)
	353	break;
	354
	355	if (addr < sizeof(struct pt_regs))
	356	tmp = get_stack_long(child, addr);
9e1cb206 NK	357	else if (addr >= offsetof(struct user, fpu) &&
9e1cb206 NK	358	addr < offsetof(struct user, u_fpvalid)) {
1da177e4	359	if (!tsk_used_math(child)) {
9e1cb206	360	if (addr == offsetof(struct user, fpu.fpscr))
1da177e4 LT	361	tmp = FPSCR_INIT;
	362	else
	363	tmp = 0;
9e1cb206 NK	364	} else {
9e1cb206 NK	365	unsigned long index;
c49b6ecf PE	366	ret = init_fpu(child);
	367	if (ret)
	368	break;
9e1cb206	369	index = addr - offsetof(struct user, fpu);
9b05a69e	370	tmp = ((unsigned long *)child->thread.xstate)
9e1cb206 NK	371	[index >> 2];
	372	}
	373	} else if (addr == offsetof(struct user, u_fpvalid))
1da177e4	374	tmp = !!tsk_used_math(child);
ba0d4740 PG	375	else if (addr == PT_TEXT_ADDR)
	376	tmp = child->mm->start_code;
	377	else if (addr == PT_DATA_ADDR)
	378	tmp = child->mm->start_data;
	379	else if (addr == PT_TEXT_END_ADDR)
	380	tmp = child->mm->end_code;
	381	else if (addr == PT_TEXT_LEN)
	382	tmp = child->mm->end_code - child->mm->start_code;
1da177e4 LT	383	else
1da177e4 LT	384	tmp = 0;
fa43972f	385	ret = put_user(tmp, datap);
1da177e4 LT	386	break;
	387	}
	388
1da177e4 LT	389	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
1da177e4 LT	390	ret = -EIO;
9432f968	391	if ((addr & 3) \|\| addr < 0 \|\|
1da177e4 LT	392	addr > sizeof(struct user) - 3)
	393	break;
	394
	395	if (addr < sizeof(struct pt_regs))
	396	ret = put_stack_long(child, addr, data);
9e1cb206 NK	397	else if (addr >= offsetof(struct user, fpu) &&
	398	addr < offsetof(struct user, u_fpvalid)) {
	399	unsigned long index;
c49b6ecf PE	400	ret = init_fpu(child);
	401	if (ret)
	402	break;
9e1cb206	403	index = addr - offsetof(struct user, fpu);
1da177e4	404	set_stopped_child_used_math(child);
9b05a69e	405	((unsigned long *)child->thread.xstate)
9e1cb206	406	[index >> 2] = data;
1da177e4	407	ret = 0;
9e1cb206	408	} else if (addr == offsetof(struct user, u_fpvalid)) {
1da177e4 LT	409	conditional_stopped_child_used_math(data, child);
	410	ret = 0;
	411	}
	412	break;
	413
934135c1 PM	414	case PTRACE_GETREGS:
	415	return copy_regset_to_user(child, &user_sh_native_view,
	416	REGSET_GENERAL,
	417	0, sizeof(struct pt_regs),
9e1cb206	418	datap);
934135c1 PM	419	case PTRACE_SETREGS:
	420	return copy_regset_from_user(child, &user_sh_native_view,
	421	REGSET_GENERAL,
	422	0, sizeof(struct pt_regs),
9e1cb206	423	datap);
e7ab3cd2 PM	424	#ifdef CONFIG_SH_FPU
	425	case PTRACE_GETFPREGS:
	426	return copy_regset_to_user(child, &user_sh_native_view,
	427	REGSET_FPU,
	428	0, sizeof(struct user_fpu_struct),
9e1cb206	429	datap);
e7ab3cd2 PM	430	case PTRACE_SETFPREGS:
	431	return copy_regset_from_user(child, &user_sh_native_view,
	432	REGSET_FPU,
	433	0, sizeof(struct user_fpu_struct),
9e1cb206	434	datap);
e7ab3cd2	435	#endif
1da177e4	436	#ifdef CONFIG_SH_DSP
5dadb343 PM	437	case PTRACE_GETDSPREGS:
	438	return copy_regset_to_user(child, &user_sh_native_view,
	439	REGSET_DSP,
	440	0, sizeof(struct pt_dspregs),
9e1cb206	441	datap);
5dadb343 PM	442	case PTRACE_SETDSPREGS:
	443	return copy_regset_from_user(child, &user_sh_native_view,
	444	REGSET_DSP,
	445	0, sizeof(struct pt_dspregs),
9e1cb206	446	datap);
1da177e4 LT	447	#endif
	448	default:
	449	ret = ptrace_request(child, request, addr, data);
	450	break;
	451	}
481bed45	452
1da177e4 LT	453	return ret;
	454	}
	455
ab99c733	456	asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
1da177e4	457	{
ab99c733	458	if (test_thread_flag(TIF_SYSCALL_TRACE) &&
b0cfc315 RF	459	tracehook_report_syscall_entry(regs)) {
	460	regs->regs[0] = -ENOSYS;
	461	return -1;
	462	}
1322b9de	463
0bb605c2 MK	464	if (secure_computing() == -1)
	465	return -1;
	466
a74f7e04 PM	467	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
a74f7e04 PM	468	trace_sys_enter(regs, regs->regs[0]);
c652d780	469
91397401	470	audit_syscall_entry(regs->regs[3], regs->regs[4], regs->regs[5],
b05d8447	471	regs->regs[6], regs->regs[7]);
1322b9de	472
b0cfc315	473	return 0;
ab99c733 PM	474	}
	475
	476	asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
	477	{
	478	int step;
	479
d7e7528b	480	audit_syscall_exit(regs);
ab99c733	481
a74f7e04 PM	482	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
a74f7e04 PM	483	trace_sys_exit(regs, regs->regs[0]);
c652d780	484
ab99c733 PM	485	step = test_thread_flag(TIF_SINGLESTEP);
	486	if (step \|\| test_thread_flag(TIF_SYSCALL_TRACE))
	487	tracehook_report_syscall_exit(regs, step);
1da177e4	488	}