ptrace.c 34.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8
/* By Ross Biro 1/23/92 */
/*
 * Pentium III FXSR, SSE support
 *	Gareth Hughes <gareth@valinux.com>, May 2000
 */

#include <linux/kernel.h>
#include <linux/sched.h>
9
#include <linux/sched/task_stack.h>
Linus Torvalds's avatar
Linus Torvalds committed
10 11 12
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/errno.h>
13
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
14
#include <linux/ptrace.h>
Roland McGrath's avatar
Roland McGrath committed
15
#include <linux/tracehook.h>
Linus Torvalds's avatar
Linus Torvalds committed
16
#include <linux/user.h>
Roland McGrath's avatar
Roland McGrath committed
17
#include <linux/elf.h>
Linus Torvalds's avatar
Linus Torvalds committed
18 19 20
#include <linux/security.h>
#include <linux/audit.h>
#include <linux/seccomp.h>
21
#include <linux/signal.h>
22 23
#include <linux/perf_event.h>
#include <linux/hw_breakpoint.h>
24
#include <linux/rcupdate.h>
25
#include <linux/export.h>
26
#include <linux/context_tracking.h>
Linus Torvalds's avatar
Linus Torvalds committed
27

28
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
29 30
#include <asm/pgtable.h>
#include <asm/processor.h>
31
#include <asm/fpu/internal.h>
32
#include <asm/fpu/signal.h>
33
#include <asm/fpu/regset.h>
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36
#include <asm/debugreg.h>
#include <asm/ldt.h>
#include <asm/desc.h>
37 38
#include <asm/prctl.h>
#include <asm/proto.h>
39
#include <asm/hw_breakpoint.h>
40
#include <asm/traps.h>
41
#include <asm/syscall.h>
42

Roland McGrath's avatar
Roland McGrath committed
43 44 45 46 47 48
#include "tls.h"

enum x86_regset {
	REGSET_GENERAL,
	REGSET_FP,
	REGSET_XFP,
Roland McGrath's avatar
Roland McGrath committed
49
	REGSET_IOPERM64 = REGSET_XFP,
50
	REGSET_XSTATE,
Roland McGrath's avatar
Roland McGrath committed
51
	REGSET_TLS,
Roland McGrath's avatar
Roland McGrath committed
52
	REGSET_IOPERM32,
Roland McGrath's avatar
Roland McGrath committed
53
};
54

55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
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[] = {
#ifdef CONFIG_X86_64
	REG_OFFSET_NAME(r15),
	REG_OFFSET_NAME(r14),
	REG_OFFSET_NAME(r13),
	REG_OFFSET_NAME(r12),
	REG_OFFSET_NAME(r11),
	REG_OFFSET_NAME(r10),
	REG_OFFSET_NAME(r9),
	REG_OFFSET_NAME(r8),
#endif
	REG_OFFSET_NAME(bx),
	REG_OFFSET_NAME(cx),
	REG_OFFSET_NAME(dx),
	REG_OFFSET_NAME(si),
	REG_OFFSET_NAME(di),
	REG_OFFSET_NAME(bp),
	REG_OFFSET_NAME(ax),
#ifdef CONFIG_X86_32
	REG_OFFSET_NAME(ds),
	REG_OFFSET_NAME(es),
	REG_OFFSET_NAME(fs),
	REG_OFFSET_NAME(gs),
#endif
	REG_OFFSET_NAME(orig_ax),
	REG_OFFSET_NAME(ip),
	REG_OFFSET_NAME(cs),
	REG_OFFSET_NAME(flags),
	REG_OFFSET_NAME(sp),
	REG_OFFSET_NAME(ss),
	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;
}

Linus Torvalds's avatar
Linus Torvalds committed
128 129 130 131 132
/*
 * does not yet catch signals sent when the child dies.
 * in exit.c or in signal.c.
 */

133 134 135
/*
 * Determines which flags the user has access to [1 = access, 0 = no access].
 */
136 137 138 139 140 141 142
#define FLAG_MASK_32		((unsigned long)			\
				 (X86_EFLAGS_CF | X86_EFLAGS_PF |	\
				  X86_EFLAGS_AF | X86_EFLAGS_ZF |	\
				  X86_EFLAGS_SF | X86_EFLAGS_TF |	\
				  X86_EFLAGS_DF | X86_EFLAGS_OF |	\
				  X86_EFLAGS_RF | X86_EFLAGS_AC))

143 144 145 146 147 148 149 150 151 152
/*
 * Determines whether a value may be installed in a segment register.
 */
static inline bool invalid_selector(u16 value)
{
	return unlikely(value != 0 && (value & SEGMENT_RPL_MASK) != USER_RPL);
}

#ifdef CONFIG_X86_32

153
#define FLAG_MASK		FLAG_MASK_32
Linus Torvalds's avatar
Linus Torvalds committed
154

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
/*
 * X86_32 CPUs don't save ss and esp if the CPU is already in kernel mode
 * when it traps.  The previous stack will be directly underneath the saved
 * registers, and 'sp/ss' won't even have been saved. Thus the '&regs->sp'.
 *
 * Now, if the stack is empty, '&regs->sp' is out of range. In this
 * case we try to take the previous stack. To always return a non-null
 * stack pointer we fall back to regs as stack if no previous stack
 * exists.
 *
 * This is valid only for kernel mode traps.
 */
unsigned long kernel_stack_pointer(struct pt_regs *regs)
{
	unsigned long context = (unsigned long)regs & ~(THREAD_SIZE - 1);
	unsigned long sp = (unsigned long)&regs->sp;
171
	u32 *prev_esp;
172 173 174 175

	if (context == (sp & ~(THREAD_SIZE - 1)))
		return sp;

176
	prev_esp = (u32 *)(context);
177 178
	if (*prev_esp)
		return (unsigned long)*prev_esp;
179 180 181

	return (unsigned long)regs;
}
182
EXPORT_SYMBOL_GPL(kernel_stack_pointer);
183

184
static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long regno)
Linus Torvalds's avatar
Linus Torvalds committed
185
{
186
	BUILD_BUG_ON(offsetof(struct pt_regs, bx) != 0);
187
	return &regs->bx + (regno >> 2);
Linus Torvalds's avatar
Linus Torvalds committed
188 189
}

190
static u16 get_segment_reg(struct task_struct *task, unsigned long offset)
Linus Torvalds's avatar
Linus Torvalds committed
191
{
192 193 194 195 196 197 198 199
	/*
	 * Returning the value truncates it to 16 bits.
	 */
	unsigned int retval;
	if (offset != offsetof(struct user_regs_struct, gs))
		retval = *pt_regs_access(task_pt_regs(task), offset);
	else {
		if (task == current)
200 201 202
			retval = get_user_gs(task_pt_regs(task));
		else
			retval = task_user_gs(task);
203 204 205 206 207 208 209 210 211 212
	}
	return retval;
}

static int set_segment_reg(struct task_struct *task,
			   unsigned long offset, u16 value)
{
	/*
	 * The value argument was already truncated to 16 bits.
	 */
213
	if (invalid_selector(value))
214 215
		return -EIO;

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	/*
	 * For %cs and %ss we cannot permit a null selector.
	 * We can permit a bogus selector as long as it has USER_RPL.
	 * Null selectors are fine for other segment registers, but
	 * we will never get back to user mode with invalid %cs or %ss
	 * and will take the trap in iret instead.  Much code relies
	 * on user_mode() to distinguish a user trap frame (which can
	 * safely use invalid selectors) from a kernel trap frame.
	 */
	switch (offset) {
	case offsetof(struct user_regs_struct, cs):
	case offsetof(struct user_regs_struct, ss):
		if (unlikely(value == 0))
			return -EIO;

	default:
232
		*pt_regs_access(task_pt_regs(task), offset) = value;
233 234 235
		break;

	case offsetof(struct user_regs_struct, gs):
236
		if (task == current)
237 238 239
			set_user_gs(task_pt_regs(task), value);
		else
			task_user_gs(task) = value;
Linus Torvalds's avatar
Linus Torvalds committed
240
	}
241

Linus Torvalds's avatar
Linus Torvalds committed
242 243 244
	return 0;
}

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 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 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
#else  /* CONFIG_X86_64 */

#define FLAG_MASK		(FLAG_MASK_32 | X86_EFLAGS_NT)

static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long offset)
{
	BUILD_BUG_ON(offsetof(struct pt_regs, r15) != 0);
	return &regs->r15 + (offset / sizeof(regs->r15));
}

static u16 get_segment_reg(struct task_struct *task, unsigned long offset)
{
	/*
	 * Returning the value truncates it to 16 bits.
	 */
	unsigned int seg;

	switch (offset) {
	case offsetof(struct user_regs_struct, fs):
		if (task == current) {
			/* Older gas can't assemble movq %?s,%r?? */
			asm("movl %%fs,%0" : "=r" (seg));
			return seg;
		}
		return task->thread.fsindex;
	case offsetof(struct user_regs_struct, gs):
		if (task == current) {
			asm("movl %%gs,%0" : "=r" (seg));
			return seg;
		}
		return task->thread.gsindex;
	case offsetof(struct user_regs_struct, ds):
		if (task == current) {
			asm("movl %%ds,%0" : "=r" (seg));
			return seg;
		}
		return task->thread.ds;
	case offsetof(struct user_regs_struct, es):
		if (task == current) {
			asm("movl %%es,%0" : "=r" (seg));
			return seg;
		}
		return task->thread.es;

	case offsetof(struct user_regs_struct, cs):
	case offsetof(struct user_regs_struct, ss):
		break;
	}
	return *pt_regs_access(task_pt_regs(task), offset);
}

static int set_segment_reg(struct task_struct *task,
			   unsigned long offset, u16 value)
{
	/*
	 * The value argument was already truncated to 16 bits.
	 */
	if (invalid_selector(value))
		return -EIO;

	switch (offset) {
	case offsetof(struct user_regs_struct,fs):
		task->thread.fsindex = value;
		if (task == current)
			loadsegment(fs, task->thread.fsindex);
		break;
	case offsetof(struct user_regs_struct,gs):
		task->thread.gsindex = value;
		if (task == current)
			load_gs_index(task->thread.gsindex);
		break;
	case offsetof(struct user_regs_struct,ds):
		task->thread.ds = value;
		if (task == current)
			loadsegment(ds, task->thread.ds);
		break;
	case offsetof(struct user_regs_struct,es):
		task->thread.es = value;
		if (task == current)
			loadsegment(es, task->thread.es);
		break;

		/*
		 * Can't actually change these in 64-bit mode.
		 */
	case offsetof(struct user_regs_struct,cs):
331 332
		if (unlikely(value == 0))
			return -EIO;
333
		task_pt_regs(task)->cs = value;
334
		break;
335
	case offsetof(struct user_regs_struct,ss):
336 337
		if (unlikely(value == 0))
			return -EIO;
338
		task_pt_regs(task)->ss = value;
339
		break;
340 341 342 343 344 345 346
	}

	return 0;
}

#endif	/* CONFIG_X86_32 */

347
static unsigned long get_flags(struct task_struct *task)
Linus Torvalds's avatar
Linus Torvalds committed
348
{
349 350 351 352 353 354 355
	unsigned long retval = task_pt_regs(task)->flags;

	/*
	 * If the debugger set TF, hide it from the readout.
	 */
	if (test_tsk_thread_flag(task, TIF_FORCED_TF))
		retval &= ~X86_EFLAGS_TF;
Linus Torvalds's avatar
Linus Torvalds committed
356 357 358 359

	return retval;
}

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
static int set_flags(struct task_struct *task, unsigned long value)
{
	struct pt_regs *regs = task_pt_regs(task);

	/*
	 * If the user value contains TF, mark that
	 * it was not "us" (the debugger) that set it.
	 * If not, make sure it stays set if we had.
	 */
	if (value & X86_EFLAGS_TF)
		clear_tsk_thread_flag(task, TIF_FORCED_TF);
	else if (test_tsk_thread_flag(task, TIF_FORCED_TF))
		value |= X86_EFLAGS_TF;

	regs->flags = (regs->flags & ~FLAG_MASK) | (value & FLAG_MASK);

	return 0;
}

static int putreg(struct task_struct *child,
		  unsigned long offset, unsigned long value)
{
	switch (offset) {
	case offsetof(struct user_regs_struct, cs):
	case offsetof(struct user_regs_struct, ds):
	case offsetof(struct user_regs_struct, es):
	case offsetof(struct user_regs_struct, fs):
	case offsetof(struct user_regs_struct, gs):
	case offsetof(struct user_regs_struct, ss):
		return set_segment_reg(child, offset, value);

	case offsetof(struct user_regs_struct, flags):
		return set_flags(child, value);
393 394 395

#ifdef CONFIG_X86_64
	case offsetof(struct user_regs_struct,fs_base):
396
		if (value >= TASK_SIZE_MAX)
397 398
			return -EIO;
		/*
399
		 * When changing the segment base, use do_arch_prctl_64
400 401 402
		 * to set either thread.fs or thread.fsindex and the
		 * corresponding GDT slot.
		 */
403
		if (child->thread.fsbase != value)
404
			return do_arch_prctl_64(child, ARCH_SET_FS, value);
405 406 407 408 409
		return 0;
	case offsetof(struct user_regs_struct,gs_base):
		/*
		 * Exactly the same here as the %fs handling above.
		 */
410
		if (value >= TASK_SIZE_MAX)
411
			return -EIO;
412
		if (child->thread.gsbase != value)
413
			return do_arch_prctl_64(child, ARCH_SET_GS, value);
414 415
		return 0;
#endif
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
	}

	*pt_regs_access(task_pt_regs(child), offset) = value;
	return 0;
}

static unsigned long getreg(struct task_struct *task, unsigned long offset)
{
	switch (offset) {
	case offsetof(struct user_regs_struct, cs):
	case offsetof(struct user_regs_struct, ds):
	case offsetof(struct user_regs_struct, es):
	case offsetof(struct user_regs_struct, fs):
	case offsetof(struct user_regs_struct, gs):
	case offsetof(struct user_regs_struct, ss):
		return get_segment_reg(task, offset);

	case offsetof(struct user_regs_struct, flags):
		return get_flags(task);
435 436 437 438

#ifdef CONFIG_X86_64
	case offsetof(struct user_regs_struct, fs_base): {
		/*
439 440
		 * XXX: This will not behave as expected if called on
		 * current or if fsindex != 0.
441
		 */
442
		return task->thread.fsbase;
443 444 445
	}
	case offsetof(struct user_regs_struct, gs_base): {
		/*
446 447
		 * XXX: This will not behave as expected if called on
		 * current or if fsindex != 0.
448
		 */
449
		return task->thread.gsbase;
450 451
	}
#endif
452 453 454 455 456
	}

	return *pt_regs_access(task_pt_regs(task), offset);
}

457 458 459 460 461 462 463
static int genregs_get(struct task_struct *target,
		       const struct user_regset *regset,
		       unsigned int pos, unsigned int count,
		       void *kbuf, void __user *ubuf)
{
	if (kbuf) {
		unsigned long *k = kbuf;
464
		while (count >= sizeof(*k)) {
465 466 467 468 469 470
			*k++ = getreg(target, pos);
			count -= sizeof(*k);
			pos += sizeof(*k);
		}
	} else {
		unsigned long __user *u = ubuf;
471
		while (count >= sizeof(*u)) {
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
			if (__put_user(getreg(target, pos), u++))
				return -EFAULT;
			count -= sizeof(*u);
			pos += sizeof(*u);
		}
	}

	return 0;
}

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)
{
	int ret = 0;
	if (kbuf) {
		const unsigned long *k = kbuf;
490
		while (count >= sizeof(*k) && !ret) {
491 492 493 494 495 496
			ret = putreg(target, pos, *k++);
			count -= sizeof(*k);
			pos += sizeof(*k);
		}
	} else {
		const unsigned long  __user *u = ubuf;
497
		while (count >= sizeof(*u) && !ret) {
498 499 500 501 502 503 504 505 506 507 508 509
			unsigned long word;
			ret = __get_user(word, u++);
			if (ret)
				break;
			ret = putreg(target, pos, word);
			count -= sizeof(*u);
			pos += sizeof(*u);
		}
	}
	return ret;
}

510
static void ptrace_triggered(struct perf_event *bp,
511 512
			     struct perf_sample_data *data,
			     struct pt_regs *regs)
513
{
514
	int i;
515
	struct thread_struct *thread = &(current->thread);
516

517 518 519 520
	/*
	 * Store in the virtual DR6 register the fact that the breakpoint
	 * was hit so the thread's debugger will see it.
	 */
521 522
	for (i = 0; i < HBP_NUM; i++) {
		if (thread->ptrace_bps[i] == bp)
523
			break;
524
	}
525

526 527
	thread->debugreg6 |= (DR_TRAP0 << i);
}
528 529

/*
530 531 532
 * Walk through every ptrace breakpoints for this thread and
 * build the dr7 value on top of their attributes.
 *
533
 */
534
static unsigned long ptrace_get_dr7(struct perf_event *bp[])
535
{
536 537 538 539 540 541 542 543 544
	int i;
	int dr7 = 0;
	struct arch_hw_breakpoint *info;

	for (i = 0; i < HBP_NUM; i++) {
		if (bp[i] && !bp[i]->attr.disabled) {
			info = counter_arch_bp(bp[i]);
			dr7 |= encode_dr7(i, info->len, info->type);
		}
545
	}
546 547

	return dr7;
548 549
}

550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
static int ptrace_fill_bp_fields(struct perf_event_attr *attr,
					int len, int type, bool disabled)
{
	int err, bp_len, bp_type;

	err = arch_bp_generic_fields(len, type, &bp_len, &bp_type);
	if (!err) {
		attr->bp_len = bp_len;
		attr->bp_type = bp_type;
		attr->disabled = disabled;
	}

	return err;
}

static struct perf_event *
ptrace_register_breakpoint(struct task_struct *tsk, int len, int type,
				unsigned long addr, bool disabled)
568
{
569
	struct perf_event_attr attr;
570 571 572 573
	int err;

	ptrace_breakpoint_init(&attr);
	attr.bp_addr = addr;
574

575
	err = ptrace_fill_bp_fields(&attr, len, type, disabled);
576
	if (err)
577 578 579 580 581 582 583 584 585 586 587
		return ERR_PTR(err);

	return register_user_hw_breakpoint(&attr, ptrace_triggered,
						 NULL, tsk);
}

static int ptrace_modify_breakpoint(struct perf_event *bp, int len, int type,
					int disabled)
{
	struct perf_event_attr attr = bp->attr;
	int err;
588

589 590 591
	err = ptrace_fill_bp_fields(&attr, len, type, disabled);
	if (err)
		return err;
592

593
	return modify_user_hw_breakpoint(bp, &attr);
594 595
}

596 597 598 599
/*
 * Handle ptrace writes to debug register 7.
 */
static int ptrace_write_dr7(struct task_struct *tsk, unsigned long data)
600
{
601
	struct thread_struct *thread = &tsk->thread;
602
	unsigned long old_dr7;
603 604
	bool second_pass = false;
	int i, rc, ret = 0;
605 606

	data &= ~DR_CONTROL_RESERVED;
607
	old_dr7 = ptrace_get_dr7(thread->ptrace_bps);
608

609
restore:
610
	rc = 0;
611
	for (i = 0; i < HBP_NUM; i++) {
612 613 614 615
		unsigned len, type;
		bool disabled = !decode_dr7(data, i, &len, &type);
		struct perf_event *bp = thread->ptrace_bps[i];

616 617 618
		if (!bp) {
			if (disabled)
				continue;
619 620 621 622 623 624 625 626 627 628

			bp = ptrace_register_breakpoint(tsk,
					len, type, 0, disabled);
			if (IS_ERR(bp)) {
				rc = PTR_ERR(bp);
				break;
			}

			thread->ptrace_bps[i] = bp;
			continue;
629
		}
630

631
		rc = ptrace_modify_breakpoint(bp, len, type, disabled);
632
		if (rc)
633
			break;
634
	}
635 636 637 638 639 640

	/* Restore if the first pass failed, second_pass shouldn't fail. */
	if (rc && !WARN_ON(second_pass)) {
		ret = rc;
		data = old_dr7;
		second_pass = true;
641 642
		goto restore;
	}
643

644
	return ret;
645
}
646

647 648 649
/*
 * Handle PTRACE_PEEKUSR calls for the debug register area.
 */
650
static unsigned long ptrace_get_debugreg(struct task_struct *tsk, int n)
651
{
652
	struct thread_struct *thread = &tsk->thread;
653 654
	unsigned long val = 0;

655
	if (n < HBP_NUM) {
656
		struct perf_event *bp = thread->ptrace_bps[n];
657

658
		if (bp)
659
			val = bp->hw.info.address;
660
	} else if (n == 6) {
661
		val = thread->debugreg6;
662
	} else if (n == 7) {
663
		val = thread->ptrace_dr7;
664
	}
665 666
	return val;
}
667

668 669 670 671
static int ptrace_set_breakpoint_addr(struct task_struct *tsk, int nr,
				      unsigned long addr)
{
	struct thread_struct *t = &tsk->thread;
672
	struct perf_event *bp = t->ptrace_bps[nr];
673 674
	int err = 0;

675
	if (!bp) {
676
		/*
677 678
		 * Put stub len and type to create an inactive but correct bp.
		 *
679 680 681 682 683 684 685 686
		 * CHECKME: the previous code returned -EIO if the addr wasn't
		 * a valid task virtual addr. The new one will return -EINVAL in
		 *  this case.
		 * -EINVAL may be what we want for in-kernel breakpoints users,
		 * but -EIO looks better for ptrace, since we refuse a register
		 * writing for the user. And anyway this is the previous
		 * behaviour.
		 */
687 688 689 690
		bp = ptrace_register_breakpoint(tsk,
				X86_BREAKPOINT_LEN_1, X86_BREAKPOINT_WRITE,
				addr, true);
		if (IS_ERR(bp))
691
			err = PTR_ERR(bp);
692 693
		else
			t->ptrace_bps[nr] = bp;
694
	} else {
695
		struct perf_event_attr attr = bp->attr;
696 697

		attr.bp_addr = addr;
698
		err = modify_user_hw_breakpoint(bp, &attr);
699
	}
700

701
	return err;
702 703
}

704 705 706
/*
 * Handle PTRACE_POKEUSR calls for the debug register area.
 */
707 708
static int ptrace_set_debugreg(struct task_struct *tsk, int n,
			       unsigned long val)
709
{
710
	struct thread_struct *thread = &tsk->thread;
711
	/* There are no DR4 or DR5 registers */
712
	int rc = -EIO;
713 714

	if (n < HBP_NUM) {
715
		rc = ptrace_set_breakpoint_addr(tsk, n, val);
716 717 718 719
	} else if (n == 6) {
		thread->debugreg6 = val;
		rc = 0;
	} else if (n == 7) {
720
		rc = ptrace_write_dr7(tsk, val);
721 722 723
		if (!rc)
			thread->ptrace_dr7 = val;
	}
724
	return rc;
725 726
}

Roland McGrath's avatar
Roland McGrath committed
727 728 729 730 731 732 733 734 735
/*
 * These access the current or another (stopped) task's io permission
 * bitmap for debugging or core dump.
 */
static int ioperm_active(struct task_struct *target,
			 const struct user_regset *regset)
{
	return target->thread.io_bitmap_max / regset->size;
}
736

Roland McGrath's avatar
Roland McGrath committed
737 738 739 740
static int ioperm_get(struct task_struct *target,
		      const struct user_regset *regset,
		      unsigned int pos, unsigned int count,
		      void *kbuf, void __user *ubuf)
741
{
Roland McGrath's avatar
Roland McGrath committed
742
	if (!target->thread.io_bitmap_ptr)
743 744
		return -ENXIO;

Roland McGrath's avatar
Roland McGrath committed
745 746 747 748 749
	return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
				   target->thread.io_bitmap_ptr,
				   0, IO_BITMAP_BYTES);
}

Linus Torvalds's avatar
Linus Torvalds committed
750 751 752 753 754 755
/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure the single step bit is not set.
 */
void ptrace_disable(struct task_struct *child)
756
{
Roland McGrath's avatar
Roland McGrath committed
757
	user_disable_single_step(child);
Roland McGrath's avatar
Roland McGrath committed
758
#ifdef TIF_SYSCALL_EMU
759
	clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
Roland McGrath's avatar
Roland McGrath committed
760
#endif
Linus Torvalds's avatar
Linus Torvalds committed
761 762
}

Roland McGrath's avatar
Roland McGrath committed
763 764 765 766
#if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
static const struct user_regset_view user_x86_32_view; /* Initialized below. */
#endif

767 768
long arch_ptrace(struct task_struct *child, long request,
		 unsigned long addr, unsigned long data)
Linus Torvalds's avatar
Linus Torvalds committed
769
{
Roland McGrath's avatar
Roland McGrath committed
770
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
771 772 773 774 775 776 777 778
	unsigned long __user *datap = (unsigned long __user *)data;

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

		ret = -EIO;
779
		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user))
Linus Torvalds's avatar
Linus Torvalds committed
780 781 782
			break;

		tmp = 0;  /* Default return condition */
Roland McGrath's avatar
Roland McGrath committed
783
		if (addr < sizeof(struct user_regs_struct))
Linus Torvalds's avatar
Linus Torvalds committed
784
			tmp = getreg(child, addr);
Roland McGrath's avatar
Roland McGrath committed
785 786 787 788
		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
			 addr <= offsetof(struct user, u_debugreg[7])) {
			addr -= offsetof(struct user, u_debugreg[0]);
			tmp = ptrace_get_debugreg(child, addr / sizeof(data));
Linus Torvalds's avatar
Linus Torvalds committed
789 790 791 792 793 794 795
		}
		ret = put_user(tmp, datap);
		break;
	}

	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
		ret = -EIO;
796
		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user))
Linus Torvalds's avatar
Linus Torvalds committed
797 798
			break;

Roland McGrath's avatar
Roland McGrath committed
799
		if (addr < sizeof(struct user_regs_struct))
Linus Torvalds's avatar
Linus Torvalds committed
800
			ret = putreg(child, addr, data);
Roland McGrath's avatar
Roland McGrath committed
801 802 803 804 805
		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
			 addr <= offsetof(struct user, u_debugreg[7])) {
			addr -= offsetof(struct user, u_debugreg[0]);
			ret = ptrace_set_debugreg(child,
						  addr / sizeof(data), data);
Linus Torvalds's avatar
Linus Torvalds committed
806
		}
Roland McGrath's avatar
Roland McGrath committed
807
		break;
Linus Torvalds's avatar
Linus Torvalds committed
808

Roland McGrath's avatar
Roland McGrath committed
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
	case PTRACE_GETREGS:	/* Get all gp regs from the child. */
		return copy_regset_to_user(child,
					   task_user_regset_view(current),
					   REGSET_GENERAL,
					   0, sizeof(struct user_regs_struct),
					   datap);

	case PTRACE_SETREGS:	/* Set all gp regs in the child. */
		return copy_regset_from_user(child,
					     task_user_regset_view(current),
					     REGSET_GENERAL,
					     0, sizeof(struct user_regs_struct),
					     datap);

	case PTRACE_GETFPREGS:	/* Get the child FPU state. */
		return copy_regset_to_user(child,
					   task_user_regset_view(current),
					   REGSET_FP,
					   0, sizeof(struct user_i387_struct),
					   datap);

	case PTRACE_SETFPREGS:	/* Set the child FPU state. */
		return copy_regset_from_user(child,
					     task_user_regset_view(current),
					     REGSET_FP,
					     0, sizeof(struct user_i387_struct),
					     datap);
Linus Torvalds's avatar
Linus Torvalds committed
836

Roland McGrath's avatar
Roland McGrath committed
837
#ifdef CONFIG_X86_32
Roland McGrath's avatar
Roland McGrath committed
838 839 840 841
	case PTRACE_GETFPXREGS:	/* Get the child extended FPU state. */
		return copy_regset_to_user(child, &user_x86_32_view,
					   REGSET_XFP,
					   0, sizeof(struct user_fxsr_struct),
842
					   datap) ? -EIO : 0;
Roland McGrath's avatar
Roland McGrath committed
843 844 845 846 847

	case PTRACE_SETFPXREGS:	/* Set the child extended FPU state. */
		return copy_regset_from_user(child, &user_x86_32_view,
					     REGSET_XFP,
					     0, sizeof(struct user_fxsr_struct),
848
					     datap) ? -EIO : 0;
Roland McGrath's avatar
Roland McGrath committed
849
#endif
Linus Torvalds's avatar
Linus Torvalds committed
850

Roland McGrath's avatar
Roland McGrath committed
851
#if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
Linus Torvalds's avatar
Linus Torvalds committed
852
	case PTRACE_GET_THREAD_AREA:
853
		if ((int) addr < 0)
Roland McGrath's avatar
Roland McGrath committed
854 855
			return -EIO;
		ret = do_get_thread_area(child, addr,
856
					(struct user_desc __user *)data);
Linus Torvalds's avatar
Linus Torvalds committed
857 858 859
		break;

	case PTRACE_SET_THREAD_AREA:
860
		if ((int) addr < 0)
Roland McGrath's avatar
Roland McGrath committed
861 862
			return -EIO;
		ret = do_set_thread_area(child, addr,
863
					(struct user_desc __user *)data, 0);
Linus Torvalds's avatar
Linus Torvalds committed
864
		break;
Roland McGrath's avatar
Roland McGrath committed
865 866 867 868 869 870 871
#endif

#ifdef CONFIG_X86_64
		/* normal 64bit interface to access TLS data.
		   Works just like arch_prctl, except that the arguments
		   are reversed. */
	case PTRACE_ARCH_PRCTL:
872
		ret = do_arch_prctl_64(child, data, addr);
Roland McGrath's avatar
Roland McGrath committed
873 874
		break;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
875 876 877 878 879

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

Linus Torvalds's avatar
Linus Torvalds committed
881 882 883
	return ret;
}

884 885
#ifdef CONFIG_IA32_EMULATION

886 887 888
#include <linux/compat.h>
#include <linux/syscalls.h>
#include <asm/ia32.h>
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
#include <asm/user32.h>

#define R32(l,q)							\
	case offsetof(struct user32, regs.l):				\
		regs->q = value; break

#define SEG32(rs)							\
	case offsetof(struct user32, regs.rs):				\
		return set_segment_reg(child,				\
				       offsetof(struct user_regs_struct, rs), \
				       value);				\
		break

static int putreg32(struct task_struct *child, unsigned regno, u32 value)
{
	struct pt_regs *regs = task_pt_regs(child);

	switch (regno) {

	SEG32(cs);
	SEG32(ds);
	SEG32(es);
	SEG32(fs);
	SEG32(gs);
	SEG32(ss);

	R32(ebx, bx);
	R32(ecx, cx);
	R32(edx, dx);
	R32(edi, di);
	R32(esi, si);
	R32(ebp, bp);
	R32(eax, ax);
	R32(eip, ip);
	R32(esp, sp);

925 926
	case offsetof(struct user32, regs.orig_eax):
		/*
927 928 929 930 931 932 933 934
		 * Warning: bizarre corner case fixup here.  A 32-bit
		 * debugger setting orig_eax to -1 wants to disable
		 * syscall restart.  Make sure that the syscall
		 * restart code sign-extends orig_ax.  Also make sure
		 * we interpret the -ERESTART* codes correctly if
		 * loaded into regs->ax in case the task is not
		 * actually still sitting at the exit from a 32-bit
		 * syscall with TS_COMPAT still set.
935
		 */
936 937
		regs->orig_ax = value;
		if (syscall_get_nr(child, regs) >= 0)
938
			child->thread_info.status |= TS_I386_REGS_POKED;
939 940
		break;

941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
	case offsetof(struct user32, regs.eflags):
		return set_flags(child, value);

	case offsetof(struct user32, u_debugreg[0]) ...
		offsetof(struct user32, u_debugreg[7]):
		regno -= offsetof(struct user32, u_debugreg[0]);
		return ptrace_set_debugreg(child, regno / 4, value);

	default:
		if (regno > sizeof(struct user32) || (regno & 3))
			return -EIO;

		/*
		 * Other dummy fields in the virtual user structure
		 * are ignored
		 */
		break;
	}
	return 0;
}

#undef R32
#undef SEG32

#define R32(l,q)							\
	case offsetof(struct user32, regs.l):				\
		*val = regs->q; break

#define SEG32(rs)							\
	case offsetof(struct user32, regs.rs):				\
		*val = get_segment_reg(child,				\
				       offsetof(struct user_regs_struct, rs)); \
		break

static int getreg32(struct task_struct *child, unsigned regno, u32 *val)
{
	struct pt_regs *regs = task_pt_regs(child);

	switch (regno) {

	SEG32(ds);
	SEG32(es);
	SEG32(fs);
	SEG32(gs);

	R32(cs, cs);
	R32(ss, ss);
	R32(ebx, bx);
	R32(ecx, cx);
	R32(edx, dx);
	R32(edi, di);
	R32(esi, si);
	R32(ebp, bp);
	R32(eax, ax);
	R32(orig_eax, orig_ax);
	R32(eip, ip);
	R32(esp, sp);

	case offsetof(struct user32, regs.eflags):
		*val = get_flags(child);
		break;

	case offsetof(struct user32, u_debugreg[0]) ...
		offsetof(struct user32, u_debugreg[7]):
		regno -= offsetof(struct user32, u_debugreg[0]);
		*val = ptrace_get_debugreg(child, regno / 4);
		break;

	default:
		if (regno > sizeof(struct user32) || (regno & 3))
			return -EIO;

		/*
		 * Other dummy fields in the virtual user structure
		 * are ignored
		 */
		*val = 0;
		break;
	}
	return 0;
}

#undef R32
#undef SEG32

1026 1027 1028 1029 1030 1031 1032
static int genregs32_get(struct task_struct *target,
			 const struct user_regset *regset,
			 unsigned int pos, unsigned int count,
			 void *kbuf, void __user *ubuf)
{
	if (kbuf) {
		compat_ulong_t *k = kbuf;
1033
		while (count >= sizeof(*k)) {
1034 1035 1036 1037 1038 1039
			getreg32(target, pos, k++);
			count -= sizeof(*k);
			pos += sizeof(*k);
		}
	} else {
		compat_ulong_t __user *u = ubuf;
1040
		while (count >= sizeof(*u)) {
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
			compat_ulong_t word;
			getreg32(target, pos, &word);
			if (__put_user(word, u++))
				return -EFAULT;
			count -= sizeof(*u);
			pos += sizeof(*u);
		}
	}

	return 0;
}

static int genregs32_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 = 0;
	if (kbuf) {
		const compat_ulong_t *k = kbuf;
1061
		while (count >= sizeof(*k) && !ret) {
1062
			ret = putreg32(target, pos, *k++);
1063 1064 1065 1066 1067
			count -= sizeof(*k);
			pos += sizeof(*k);
		}
	} else {
		const compat_ulong_t __user *u = ubuf;
1068
		while (count >= sizeof(*u) && !ret) {
1069 1070 1071 1072
			compat_ulong_t word;
			ret = __get_user(word, u++);
			if (ret)
				break;
1073
			ret = putreg32(target, pos, word);
1074 1075 1076 1077 1078 1079 1080
			count -= sizeof(*u);
			pos += sizeof(*u);
		}
	}
	return ret;
}

1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
static long ia32_arch_ptrace(struct task_struct *child, compat_long_t request,
			     compat_ulong_t caddr, compat_ulong_t cdata)
{
	unsigned long addr = caddr;
	unsigned long data = cdata;
	void __user *datap = compat_ptr(data);
	int ret;
	__u32 val;

	switch (request) {
	case PTRACE_PEEKUSR:
		ret = getreg32(child, addr, &val);
		if (ret == 0)
			ret = put_user(val, (__u32 __user *)datap);
		break;

	case PTRACE_POKEUSR:
		ret = putreg32(child, addr, data);
		break;

	case PTRACE_GETREGS:	/* Get all gp regs from the child. */
		return copy_regset_to_user(child, &user_x86_32_view,
					   REGSET_GENERAL,
					   0, sizeof(struct user_regs_struct32),
					   datap);

	case PTRACE_SETREGS:	/* Set all gp regs in the child. */
		return copy_regset_from_user(child, &user_x86_32_view,
					     REGSET_GENERAL, 0,
					     sizeof(struct user_regs_struct32),
					     datap);

	case PTRACE_GETFPREGS:	/* Get the child FPU state. */
		return copy_regset_to_user(child, &user_x86_32_view,
					   REGSET_FP, 0,
					   sizeof(struct user_i387_ia32_struct),
					   datap);

	case PTRACE_SETFPREGS:	/* Set the child FPU state. */
		return copy_regset_from_user(
			child, &user_x86_32_view, REGSET_FP,
			0, sizeof(struct user_i387_ia32_struct), datap);

	case PTRACE_GETFPXREGS:	/* Get the child extended FPU state. */
		return copy_regset_to_user(child, &user_x86_32_view,
					   REGSET_XFP, 0,
					   sizeof(struct user32_fxsr_struct),
					   datap);

	case PTRACE_SETFPXREGS:	/* Set the child extended FPU state. */
		return copy_regset_from_user(child, &user_x86_32_view,
					     REGSET_XFP, 0,
					     sizeof(struct user32_fxsr_struct),
					     datap);

	case PTRACE_GET_THREAD_AREA:
	case PTRACE_SET_THREAD_AREA:
		return arch_ptrace(child, request, addr, data);

	default:
		return compat_ptrace_request(child, request, addr, data);
	}

	return ret;
}
#endif /* CONFIG_IA32_EMULATION */

H.J. Lu's avatar
H.J. Lu committed
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
#ifdef CONFIG_X86_X32_ABI
static long x32_arch_ptrace(struct task_struct *child,
			    compat_long_t request, compat_ulong_t caddr,
			    compat_ulong_t cdata)
{
	unsigned long addr = caddr;
	unsigned long data = cdata;
	void __user *datap = compat_ptr(data);
	int ret;

	switch (request) {
	/* Read 32bits at location addr in the USER area.  Only allow
	   to return the lower 32bits of segment and debug registers.  */
	case PTRACE_PEEKUSR: {
		u32 tmp;

		ret = -EIO;
		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user) ||
		    addr < offsetof(struct user_regs_struct, cs))
			break;

		tmp = 0;  /* Default return condition */
		if (addr < sizeof(struct user_regs_struct))
			tmp = getreg(child, addr);
		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
			 addr <= offsetof(struct user, u_debugreg[7])) {
			addr -= offsetof(struct user, u_debugreg[0]);
			tmp = ptrace_get_debugreg(child, addr / sizeof(data));
		}
		ret = put_user(tmp, (__u32 __user *)datap);
		break;
	}

	/* Write the word at location addr in the USER area.  Only allow
	   to update segment and debug registers with the upper 32bits
	   zero-extended. */
	case PTRACE_POKEUSR:
		ret = -EIO;
		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user) ||
		    addr < offsetof(struct user_regs_struct, cs))
			break;

		if (addr < sizeof(struct user_regs_struct))
			ret = putreg(child, addr, data);
		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
			 addr <= offsetof(struct user, u_debugreg[7])) {
			addr -= offsetof(struct user, u_debugreg[0]);
			ret = ptrace_set_debugreg(child,
						  addr / sizeof(data), data);
		}
		break;

	case PTRACE_GETREGS:	/* Get all gp regs from the child. */
		return copy_regset_to_user(child,
					   task_user_regset_view(current),
					   REGSET_GENERAL,
					   0, sizeof(struct user_regs_struct),
					   datap);

	case PTRACE_SETREGS:	/* Set all gp regs in the child. */
		return copy_regset_from_user(child,
					     task_user_regset_view(current),
					     REGSET_GENERAL,
					     0, sizeof(struct user_regs_struct),
					     datap);

	case PTRACE_GETFPREGS:	/* Get the child FPU state. */
		return copy_regset_to_user(child,
					   task_user_regset_view(current),
					   REGSET_FP,
					   0, sizeof(struct user_i387_struct),
					   datap);

	case PTRACE_SETFPREGS:	/* Set the child FPU state. */
		return copy_regset_from_user(child,
					     task_user_regset_view(current),
					     REGSET_FP,
					     0, sizeof(struct user_i387_struct),
					     datap);

	default:
		return compat_ptrace_request(child, request, addr, data);
	}

	return ret;
}
#endif

1236
#ifdef CONFIG_COMPAT
1237 1238
long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
			compat_ulong_t caddr, compat_ulong_t cdata)
1239
{
H.J. Lu's avatar
H.J. Lu committed
1240
#ifdef CONFIG_X86_X32_ABI
1241
	if (!in_ia32_syscall())
H.J. Lu's avatar
H.J. Lu committed
1242 1243
		return x32_arch_ptrace(child, request, caddr, cdata);
#endif
1244 1245 1246 1247 1248
#ifdef CONFIG_IA32_EMULATION
	return ia32_arch_ptrace(child, request, caddr, cdata);
#else
	return 0;
#endif
1249
}
1250
#endif	/* CONFIG_COMPAT */
1251

Roland McGrath's avatar
Roland McGrath committed
1252 1253
#ifdef CONFIG_X86_64

1254
static struct user_regset x86_64_regsets[] __ro_after_init = {
Roland McGrath's avatar
Roland McGrath committed
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
	[REGSET_GENERAL] = {
		.core_note_type = NT_PRSTATUS,
		.n = sizeof(struct user_regs_struct) / sizeof(long),
		.size = sizeof(long), .align = sizeof(long),
		.get = genregs_get, .set = genregs_set
	},
	[REGSET_FP] = {
		.core_note_type = NT_PRFPREG,
		.n = sizeof(struct user_i387_struct) / sizeof(long),
		.size = sizeof(long), .align = sizeof(long),
1265
		.active = regset_xregset_fpregs_active, .get = xfpregs_get, .set = xfpregs_set
Roland McGrath's avatar
Roland McGrath committed
1266
	},
1267 1268 1269 1270 1271 1272
	[REGSET_XSTATE] = {
		.core_note_type = NT_X86_XSTATE,
		.size = sizeof(u64), .align = sizeof(u64),
		.active = xstateregs_active, .get = xstateregs_get,
		.set = xstateregs_set
	},
Roland McGrath's avatar
Roland McGrath committed
1273 1274 1275 1276 1277 1278
	[REGSET_IOPERM64] = {
		.core_note_type = NT_386_IOPERM,
		.n = IO_BITMAP_LONGS,
		.size = sizeof(long), .align = sizeof(long),
		.active = ioperm_active, .get = ioperm_get
	},
Roland McGrath's avatar
Roland McGrath committed
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
};

static const struct user_regset_view user_x86_64_view = {
	.name = "x86_64", .e_machine = EM_X86_64,
	.regsets = x86_64_regsets, .n = ARRAY_SIZE(x86_64_regsets)
};

#else  /* CONFIG_X86_32 */

#define user_regs_struct32	user_regs_struct
#define genregs32_get		genregs_get
#define genregs32_set		genregs_set

#endif	/* CONFIG_X86_64 */

#if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
1295
static struct user_regset x86_32_regsets[] __ro_after_init = {
Roland McGrath's avatar
Roland McGrath committed
1296 1297 1298 1299 1300 1301 1302 1303
	[REGSET_GENERAL] = {
		.core_note_type = NT_PRSTATUS,
		.n = sizeof(struct user_regs_struct32) / sizeof(u32),
		.size = sizeof(u32), .align = sizeof(u32),
		.get = genregs32_get, .set = genregs32_set
	},
	[REGSET_FP] = {
		.core_note_type = NT_PRFPREG,
1304
		.n = sizeof(struct user_i387_ia32_struct) / sizeof(u32),
Roland McGrath's avatar
Roland McGrath committed
1305
		.size = sizeof(u32), .align = sizeof(u32),
1306
		.active = regset_fpregs_active, .get = fpregs_get, .set = fpregs_set
Roland McGrath's avatar
Roland McGrath committed
1307 1308 1309
	},
	[REGSET_XFP] = {
		.core_note_type = NT_PRXFPREG,
1310
		.n = sizeof(struct user32_fxsr_struct) / sizeof(u32),
Roland McGrath's avatar
Roland McGrath committed
1311
		.size = sizeof(u32), .align = sizeof(u32),
1312
		.active = regset_xregset_fpregs_active, .get = xfpregs_get, .set = xfpregs_set
Roland McGrath's avatar
Roland McGrath committed
1313
	},
1314 1315 1316 1317 1318 1319
	[REGSET_XSTATE] = {
		.core_note_type = NT_X86_XSTATE,
		.size = sizeof(u64), .align = sizeof(u64),
		.active = xstateregs_active, .get = xstateregs_get,
		.set = xstateregs_set
	},
Roland McGrath's avatar
Roland McGrath committed
1320
	[REGSET_TLS] = {
Roland McGrath's avatar
Roland McGrath committed
1321
		.core_note_type = NT_386_TLS,
Roland McGrath's avatar
Roland McGrath committed
1322 1323 1324 1325 1326 1327
		.n = GDT_ENTRY_TLS_ENTRIES, .bias = GDT_ENTRY_TLS_MIN,
		.size = sizeof(struct user_desc),
		.align = sizeof(struct user_desc),
		.active = regset_tls_active,
		.get = regset_tls_get, .set = regset_tls_set
	},
Roland McGrath's avatar
Roland McGrath committed
1328 1329 1330 1331 1332 1333
	[REGSET_IOPERM32] = {
		.core_note_type = NT_386_IOPERM,
		.n = IO_BITMAP_BYTES / sizeof(u32),
		.size = sizeof(u32), .align = sizeof(u32),
		.active = ioperm_active, .get = ioperm_get
	},
Roland McGrath's avatar
Roland McGrath committed
1334 1335 1336 1337 1338 1339 1340 1341
};

static const struct user_regset_view user_x86_32_view = {
	.name = "i386", .e_machine = EM_386,
	.regsets = x86_32_regsets, .n = ARRAY_SIZE(x86_32_regsets)
};
#endif

1342 1343 1344 1345 1346 1347
/*
 * This represents bytes 464..511 in the memory layout exported through
 * the REGSET_XSTATE interface.
 */
u64 xstate_fx_sw_bytes[USER_XSTATE_FX_SW_WORDS];

1348
void __init update_regset_xstate_info(unsigned int size, u64 xstate_mask)
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
{
#ifdef CONFIG_X86_64
	x86_64_regsets[REGSET_XSTATE].n = size / sizeof(u64);
#endif
#if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
	x86_32_regsets[REGSET_XSTATE].n = size / sizeof(u64);
#endif
	xstate_fx_sw_bytes[USER_XSTATE_XCR0_WORD] = xstate_mask;
}

Roland McGrath's avatar
Roland McGrath committed
1359 1360 1361
const struct user_regset_view *task_user_regset_view(struct task_struct *task)
{
#ifdef CONFIG_IA32_EMULATION
1362
	if (!user_64bit_mode(task_pt_regs(task)))
Roland McGrath's avatar
Roland McGrath committed
1363 1364 1365 1366 1367 1368 1369 1370 1371
#endif
#if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
		return &user_x86_32_view;
#endif
#ifdef CONFIG_X86_64
	return &user_x86_64_view;
#endif
}

1372 1373 1374 1375
static void fill_sigtrap_info(struct task_struct *tsk,
				struct pt_regs *regs,
				int error_code, int si_code,
				struct siginfo *info)
Linus Torvalds's avatar
Linus Torvalds committed
1376
{
1377
	tsk->thread.trap_nr = X86_TRAP_DB;
Linus Torvalds's avatar
Linus Torvalds committed
1378 1379
	tsk->thread.error_code = error_code;

1380 1381 1382
	memset(info, 0, sizeof(*info));
	info->si_signo = SIGTRAP;
	info->si_code = si_code;
1383
	info->si_addr = user_mode(regs) ? (void __user *)regs->ip : NULL;
1384 1385 1386 1387 1388 1389 1390 1391
}

void user_single_step_siginfo(struct task_struct *tsk,
				struct pt_regs *regs,
				struct siginfo *info)
{
	fill_sigtrap_info(tsk, regs, 0, TRAP_BRKPT, info);
}
Linus Torvalds's avatar
Linus Torvalds committed
1392

1393 1394 1395 1396
void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,
					 int error_code, int si_code)
{
	struct siginfo info;
Linus Torvalds's avatar
Linus Torvalds committed
1397

1398
	fill_sigtrap_info(tsk, regs, error_code, si_code, &info);
Simon Arlott's avatar
Simon Arlott committed
1399
	/* Send us the fake SIGTRAP */
Linus Torvalds's avatar
Linus Torvalds committed
1400 1401
	force_sig_info(SIGTRAP, &info, tsk);
}