ptrace_32.c 13.0 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * SuperH process tracing
L
Linus Torvalds 已提交
3
 *
4
 * Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
5
 * Copyright (C) 2002 - 2009  Paul Mundt
L
Linus Torvalds 已提交
6
 *
7 8 9 10 11
 * Audit support by Yuichi Nakamura <ynakam@hitachisoft.jp>
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
L
Linus Torvalds 已提交
12 13 14 15 16 17 18 19 20
 */
#include <linux/kernel.h>
#include <linux/sched.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>
21
#include <linux/signal.h>
S
Stuart Menefy 已提交
22
#include <linux/io.h>
Y
Yuichi Nakamura 已提交
23
#include <linux/audit.h>
P
Paul Mundt 已提交
24
#include <linux/seccomp.h>
25
#include <linux/tracehook.h>
26 27
#include <linux/elf.h>
#include <linux/regset.h>
28
#include <linux/hw_breakpoint.h>
L
Linus Torvalds 已提交
29 30 31 32 33
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/system.h>
#include <asm/processor.h>
#include <asm/mmu_context.h>
P
Paul Mundt 已提交
34
#include <asm/syscalls.h>
35
#include <asm/fpu.h>
L
Linus Torvalds 已提交
36

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

L
Linus Torvalds 已提交
40 41 42 43 44 45 46
/*
 * 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;

A
Al Viro 已提交
47
	stack = (unsigned char *)task_pt_regs(task);
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55 56 57 58 59
	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;

A
Al Viro 已提交
60
	stack = (unsigned char *)task_pt_regs(task);
L
Linus Torvalds 已提交
61 62 63 64 65
	stack += offset;
	*(unsigned long *) stack = data;
	return 0;
}

66 67
void ptrace_triggered(struct perf_event *bp, int nmi,
		      struct perf_sample_data *data, struct pt_regs *regs)
68
{
69 70 71 72 73 74 75 76 77 78 79 80
	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)
81
{
82 83 84 85 86 87
	struct thread_struct *thread = &tsk->thread;
	struct perf_event *bp;
	struct perf_event_attr attr;

	bp = thread->ptrace_bps[0];
	if (!bp) {
88
		ptrace_breakpoint_init(&attr);
89 90 91 92

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

94 95 96 97 98 99 100 101 102 103
		bp = register_user_hw_breakpoint(&attr, ptrace_triggered, tsk);
		if (IS_ERR(bp))
			return PTR_ERR(bp);

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

		attr = bp->attr;
		attr.bp_addr = addr;
104 105
		/* reenable breakpoint */
		attr.disabled = false;
106 107 108 109 110 111 112
		err = modify_user_hw_breakpoint(bp, &attr);
		if (unlikely(err))
			return err;
	}

	return 0;
}
113 114 115

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

	set_tsk_thread_flag(child, TIF_SINGLESTEP);
119

120 121 122
	if (ptrace_get_breakpoints(child) < 0)
		return;

123
	set_single_step(child, pc);
124
	ptrace_put_breakpoints(child);
125 126 127
}

void user_disable_single_step(struct task_struct *child)
S
Stuart Menefy 已提交
128 129 130 131
{
	clear_tsk_thread_flag(child, TIF_SINGLESTEP);
}

L
Linus Torvalds 已提交
132 133 134 135 136 137 138
/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure single step bits etc are not set.
 */
void ptrace_disable(struct task_struct *child)
{
139
	user_disable_single_step(child);
L
Linus Torvalds 已提交
140 141
}

142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
static int genregs_get(struct task_struct *target,
		       const struct user_regset *regset,
		       unsigned int pos, unsigned int count,
		       void *kbuf, void __user *ubuf)
{
	const struct pt_regs *regs = task_pt_regs(target);
	int ret;

	ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
				  regs->regs,
				  0, 16 * sizeof(unsigned long));
	if (!ret)
		/* PC, PR, SR, GBR, MACH, MACL, TRA */
		ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
					  &regs->pc,
					  offsetof(struct pt_regs, pc),
					  sizeof(struct pt_regs));
	if (!ret)
		ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
					       sizeof(struct pt_regs), -1);

	return ret;
}

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

189 190 191 192 193 194 195 196 197 198 199 200 201 202
#ifdef CONFIG_SH_FPU
int fpregs_get(struct task_struct *target,
	       const struct user_regset *regset,
	       unsigned int pos, unsigned int count,
	       void *kbuf, void __user *ubuf)
{
	int ret;

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

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

	return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
206
				   &target->thread.xstate->softfpu, 0, -1);
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
}

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,
224
					  &target->thread.xstate->hardfpu, 0, -1);
225 226

	return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
227
				  &target->thread.xstate->softfpu, 0, -1);
228 229 230 231 232 233 234 235 236
}

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

237 238 239 240 241 242
#ifdef CONFIG_SH_DSP
static int dspregs_get(struct task_struct *target,
		       const struct user_regset *regset,
		       unsigned int pos, unsigned int count,
		       void *kbuf, void __user *ubuf)
{
243 244
	const struct pt_dspregs *regs =
		(struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
	int ret;

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

	return ret;
}

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)
{
261 262
	struct pt_dspregs *regs =
		(struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
263 264 265 266 267 268 269 270 271 272
	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;
}
273 274 275 276 277 278 279 280

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;
}
281 282
#endif

P
Paul Mundt 已提交
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
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,
};

310 311 312 313 314
/*
 * These are our native regset flavours.
 */
enum sh_regset {
	REGSET_GENERAL,
315 316 317
#ifdef CONFIG_SH_FPU
	REGSET_FPU,
#endif
318 319 320
#ifdef CONFIG_SH_DSP
	REGSET_DSP,
#endif
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
};

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),
		.get		= genregs_get,
		.set		= genregs_set,
	},
337

338 339 340 341 342 343 344 345 346 347 348 349
#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),
		.get		= fpregs_get,
		.set		= fpregs_set,
		.active		= fpregs_active,
	},
#endif

350 351 352 353 354 355 356
#ifdef CONFIG_SH_DSP
	[REGSET_DSP] = {
		.n		= sizeof(struct pt_dspregs) / sizeof(long),
		.size		= sizeof(long),
		.align		= sizeof(long),
		.get		= dspregs_get,
		.set		= dspregs_set,
357
		.active		= dspregs_active,
358 359
	},
#endif
360 361 362 363 364 365 366 367 368
};

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

369 370 371 372 373
const struct user_regset_view *task_user_regset_view(struct task_struct *task)
{
	return &user_sh_native_view;
}

374 375
long arch_ptrace(struct task_struct *child, long request,
		 unsigned long addr, unsigned long data)
L
Linus Torvalds 已提交
376
{
P
Paul Mundt 已提交
377
	unsigned long __user *datap = (unsigned long __user *)data;
L
Linus Torvalds 已提交
378 379 380 381 382 383 384 385
	int ret;

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

		ret = -EIO;
S
Stuart Menefy 已提交
386
		if ((addr & 3) || addr < 0 ||
L
Linus Torvalds 已提交
387 388 389 390 391
		    addr > sizeof(struct user) - 3)
			break;

		if (addr < sizeof(struct pt_regs))
			tmp = get_stack_long(child, addr);
N
Namhyung Kim 已提交
392 393
		else if (addr >= offsetof(struct user, fpu) &&
			 addr < offsetof(struct user, u_fpvalid)) {
L
Linus Torvalds 已提交
394
			if (!tsk_used_math(child)) {
N
Namhyung Kim 已提交
395
				if (addr == offsetof(struct user, fpu.fpscr))
L
Linus Torvalds 已提交
396 397 398
					tmp = FPSCR_INIT;
				else
					tmp = 0;
N
Namhyung Kim 已提交
399 400
			} else {
				unsigned long index;
401 402 403
				ret = init_fpu(child);
				if (ret)
					break;
N
Namhyung Kim 已提交
404
				index = addr - offsetof(struct user, fpu);
405
				tmp = ((unsigned long *)child->thread.xstate)
N
Namhyung Kim 已提交
406 407 408
					[index >> 2];
			}
		} else if (addr == offsetof(struct user, u_fpvalid))
L
Linus Torvalds 已提交
409
			tmp = !!tsk_used_math(child);
410 411 412 413 414 415 416 417
		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;
L
Linus Torvalds 已提交
418 419
		else
			tmp = 0;
P
Paul Mundt 已提交
420
		ret = put_user(tmp, datap);
L
Linus Torvalds 已提交
421 422 423 424 425
		break;
	}

	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
		ret = -EIO;
S
Stuart Menefy 已提交
426
		if ((addr & 3) || addr < 0 ||
L
Linus Torvalds 已提交
427 428 429 430 431
		    addr > sizeof(struct user) - 3)
			break;

		if (addr < sizeof(struct pt_regs))
			ret = put_stack_long(child, addr, data);
N
Namhyung Kim 已提交
432 433 434
		else if (addr >= offsetof(struct user, fpu) &&
			 addr < offsetof(struct user, u_fpvalid)) {
			unsigned long index;
435 436 437
			ret = init_fpu(child);
			if (ret)
				break;
N
Namhyung Kim 已提交
438
			index = addr - offsetof(struct user, fpu);
L
Linus Torvalds 已提交
439
			set_stopped_child_used_math(child);
440
			((unsigned long *)child->thread.xstate)
N
Namhyung Kim 已提交
441
				[index >> 2] = data;
L
Linus Torvalds 已提交
442
			ret = 0;
N
Namhyung Kim 已提交
443
		} else if (addr == offsetof(struct user, u_fpvalid)) {
L
Linus Torvalds 已提交
444 445 446 447 448
			conditional_stopped_child_used_math(data, child);
			ret = 0;
		}
		break;

449 450 451 452
	case PTRACE_GETREGS:
		return copy_regset_to_user(child, &user_sh_native_view,
					   REGSET_GENERAL,
					   0, sizeof(struct pt_regs),
N
Namhyung Kim 已提交
453
					   datap);
454 455 456 457
	case PTRACE_SETREGS:
		return copy_regset_from_user(child, &user_sh_native_view,
					     REGSET_GENERAL,
					     0, sizeof(struct pt_regs),
N
Namhyung Kim 已提交
458
					     datap);
459 460 461 462 463
#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),
N
Namhyung Kim 已提交
464
					   datap);
465 466 467 468
	case PTRACE_SETFPREGS:
		return copy_regset_from_user(child, &user_sh_native_view,
					     REGSET_FPU,
					     0, sizeof(struct user_fpu_struct),
N
Namhyung Kim 已提交
469
					     datap);
470
#endif
L
Linus Torvalds 已提交
471
#ifdef CONFIG_SH_DSP
472 473 474 475
	case PTRACE_GETDSPREGS:
		return copy_regset_to_user(child, &user_sh_native_view,
					   REGSET_DSP,
					   0, sizeof(struct pt_dspregs),
N
Namhyung Kim 已提交
476
					   datap);
477 478 479 480
	case PTRACE_SETDSPREGS:
		return copy_regset_from_user(child, &user_sh_native_view,
					     REGSET_DSP,
					     0, sizeof(struct pt_dspregs),
N
Namhyung Kim 已提交
481
					     datap);
L
Linus Torvalds 已提交
482 483 484 485 486
#endif
	default:
		ret = ptrace_request(child, request, addr, data);
		break;
	}
487

L
Linus Torvalds 已提交
488 489 490
	return ret;
}

491 492 493 494 495 496 497 498 499 500 501
static inline int audit_arch(void)
{
	int arch = EM_SH;

#ifdef CONFIG_CPU_LITTLE_ENDIAN
	arch |= __AUDIT_ARCH_LE;
#endif

	return arch;
}

502
asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
L
Linus Torvalds 已提交
503
{
504
	long ret = 0;
L
Linus Torvalds 已提交
505

P
Paul Mundt 已提交
506 507
	secure_computing(regs->regs[0]);

508 509 510 511 512 513 514 515
	if (test_thread_flag(TIF_SYSCALL_TRACE) &&
	    tracehook_report_syscall_entry(regs))
		/*
		 * Tracing decided this syscall should not happen.
		 * We'll return a bogus call number to get an ENOSYS
		 * error, but leave the original number in regs->regs[0].
		 */
		ret = -1L;
Y
Yuichi Nakamura 已提交
516

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

520
	if (unlikely(current->audit_context))
521
		audit_syscall_entry(audit_arch(), regs->regs[3],
Y
Yuichi Nakamura 已提交
522 523 524
				    regs->regs[4], regs->regs[5],
				    regs->regs[6], regs->regs[7]);

525 526 527 528 529 530 531 532 533 534 535
	return ret ?: regs->regs[0];
}

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

	if (unlikely(current->audit_context))
		audit_syscall_exit(AUDITSC_RESULT(regs->regs[0]),
				   regs->regs[0]);

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

539 540 541
	step = test_thread_flag(TIF_SINGLESTEP);
	if (step || test_thread_flag(TIF_SYSCALL_TRACE))
		tracehook_report_syscall_exit(regs, step);
L
Linus Torvalds 已提交
542
}