xref: /openbmc/linux/arch/x86/kernel/ptrace.c (revision 2d96b44f)
1 /* By Ross Biro 1/23/92 */
2 /*
3  * Pentium III FXSR, SSE support
4  *	Gareth Hughes <gareth@valinux.com>, May 2000
5  */
6 
7 #include <linux/kernel.h>
8 #include <linux/sched.h>
9 #include <linux/mm.h>
10 #include <linux/smp.h>
11 #include <linux/errno.h>
12 #include <linux/slab.h>
13 #include <linux/ptrace.h>
14 #include <linux/tracehook.h>
15 #include <linux/user.h>
16 #include <linux/elf.h>
17 #include <linux/security.h>
18 #include <linux/audit.h>
19 #include <linux/seccomp.h>
20 #include <linux/signal.h>
21 #include <linux/perf_event.h>
22 #include <linux/hw_breakpoint.h>
23 #include <linux/rcupdate.h>
24 #include <linux/export.h>
25 #include <linux/context_tracking.h>
26 
27 #include <asm/uaccess.h>
28 #include <asm/pgtable.h>
29 #include <asm/processor.h>
30 #include <asm/fpu/internal.h>
31 #include <asm/fpu/signal.h>
32 #include <asm/fpu/regset.h>
33 #include <asm/debugreg.h>
34 #include <asm/ldt.h>
35 #include <asm/desc.h>
36 #include <asm/prctl.h>
37 #include <asm/proto.h>
38 #include <asm/hw_breakpoint.h>
39 #include <asm/traps.h>
40 #include <asm/syscall.h>
41 
42 #include "tls.h"
43 
44 enum x86_regset {
45 	REGSET_GENERAL,
46 	REGSET_FP,
47 	REGSET_XFP,
48 	REGSET_IOPERM64 = REGSET_XFP,
49 	REGSET_XSTATE,
50 	REGSET_TLS,
51 	REGSET_IOPERM32,
52 };
53 
54 struct pt_regs_offset {
55 	const char *name;
56 	int offset;
57 };
58 
59 #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
60 #define REG_OFFSET_END {.name = NULL, .offset = 0}
61 
62 static const struct pt_regs_offset regoffset_table[] = {
63 #ifdef CONFIG_X86_64
64 	REG_OFFSET_NAME(r15),
65 	REG_OFFSET_NAME(r14),
66 	REG_OFFSET_NAME(r13),
67 	REG_OFFSET_NAME(r12),
68 	REG_OFFSET_NAME(r11),
69 	REG_OFFSET_NAME(r10),
70 	REG_OFFSET_NAME(r9),
71 	REG_OFFSET_NAME(r8),
72 #endif
73 	REG_OFFSET_NAME(bx),
74 	REG_OFFSET_NAME(cx),
75 	REG_OFFSET_NAME(dx),
76 	REG_OFFSET_NAME(si),
77 	REG_OFFSET_NAME(di),
78 	REG_OFFSET_NAME(bp),
79 	REG_OFFSET_NAME(ax),
80 #ifdef CONFIG_X86_32
81 	REG_OFFSET_NAME(ds),
82 	REG_OFFSET_NAME(es),
83 	REG_OFFSET_NAME(fs),
84 	REG_OFFSET_NAME(gs),
85 #endif
86 	REG_OFFSET_NAME(orig_ax),
87 	REG_OFFSET_NAME(ip),
88 	REG_OFFSET_NAME(cs),
89 	REG_OFFSET_NAME(flags),
90 	REG_OFFSET_NAME(sp),
91 	REG_OFFSET_NAME(ss),
92 	REG_OFFSET_END,
93 };
94 
95 /**
96  * regs_query_register_offset() - query register offset from its name
97  * @name:	the name of a register
98  *
99  * regs_query_register_offset() returns the offset of a register in struct
100  * pt_regs from its name. If the name is invalid, this returns -EINVAL;
101  */
102 int regs_query_register_offset(const char *name)
103 {
104 	const struct pt_regs_offset *roff;
105 	for (roff = regoffset_table; roff->name != NULL; roff++)
106 		if (!strcmp(roff->name, name))
107 			return roff->offset;
108 	return -EINVAL;
109 }
110 
111 /**
112  * regs_query_register_name() - query register name from its offset
113  * @offset:	the offset of a register in struct pt_regs.
114  *
115  * regs_query_register_name() returns the name of a register from its
116  * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
117  */
118 const char *regs_query_register_name(unsigned int offset)
119 {
120 	const struct pt_regs_offset *roff;
121 	for (roff = regoffset_table; roff->name != NULL; roff++)
122 		if (roff->offset == offset)
123 			return roff->name;
124 	return NULL;
125 }
126 
127 /*
128  * does not yet catch signals sent when the child dies.
129  * in exit.c or in signal.c.
130  */
131 
132 /*
133  * Determines which flags the user has access to [1 = access, 0 = no access].
134  */
135 #define FLAG_MASK_32		((unsigned long)			\
136 				 (X86_EFLAGS_CF | X86_EFLAGS_PF |	\
137 				  X86_EFLAGS_AF | X86_EFLAGS_ZF |	\
138 				  X86_EFLAGS_SF | X86_EFLAGS_TF |	\
139 				  X86_EFLAGS_DF | X86_EFLAGS_OF |	\
140 				  X86_EFLAGS_RF | X86_EFLAGS_AC))
141 
142 /*
143  * Determines whether a value may be installed in a segment register.
144  */
145 static inline bool invalid_selector(u16 value)
146 {
147 	return unlikely(value != 0 && (value & SEGMENT_RPL_MASK) != USER_RPL);
148 }
149 
150 #ifdef CONFIG_X86_32
151 
152 #define FLAG_MASK		FLAG_MASK_32
153 
154 /*
155  * X86_32 CPUs don't save ss and esp if the CPU is already in kernel mode
156  * when it traps.  The previous stack will be directly underneath the saved
157  * registers, and 'sp/ss' won't even have been saved. Thus the '&regs->sp'.
158  *
159  * Now, if the stack is empty, '&regs->sp' is out of range. In this
160  * case we try to take the previous stack. To always return a non-null
161  * stack pointer we fall back to regs as stack if no previous stack
162  * exists.
163  *
164  * This is valid only for kernel mode traps.
165  */
166 unsigned long kernel_stack_pointer(struct pt_regs *regs)
167 {
168 	unsigned long context = (unsigned long)regs & ~(THREAD_SIZE - 1);
169 	unsigned long sp = (unsigned long)&regs->sp;
170 	u32 *prev_esp;
171 
172 	if (context == (sp & ~(THREAD_SIZE - 1)))
173 		return sp;
174 
175 	prev_esp = (u32 *)(context);
176 	if (*prev_esp)
177 		return (unsigned long)*prev_esp;
178 
179 	return (unsigned long)regs;
180 }
181 EXPORT_SYMBOL_GPL(kernel_stack_pointer);
182 
183 static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long regno)
184 {
185 	BUILD_BUG_ON(offsetof(struct pt_regs, bx) != 0);
186 	return &regs->bx + (regno >> 2);
187 }
188 
189 static u16 get_segment_reg(struct task_struct *task, unsigned long offset)
190 {
191 	/*
192 	 * Returning the value truncates it to 16 bits.
193 	 */
194 	unsigned int retval;
195 	if (offset != offsetof(struct user_regs_struct, gs))
196 		retval = *pt_regs_access(task_pt_regs(task), offset);
197 	else {
198 		if (task == current)
199 			retval = get_user_gs(task_pt_regs(task));
200 		else
201 			retval = task_user_gs(task);
202 	}
203 	return retval;
204 }
205 
206 static int set_segment_reg(struct task_struct *task,
207 			   unsigned long offset, u16 value)
208 {
209 	/*
210 	 * The value argument was already truncated to 16 bits.
211 	 */
212 	if (invalid_selector(value))
213 		return -EIO;
214 
215 	/*
216 	 * For %cs and %ss we cannot permit a null selector.
217 	 * We can permit a bogus selector as long as it has USER_RPL.
218 	 * Null selectors are fine for other segment registers, but
219 	 * we will never get back to user mode with invalid %cs or %ss
220 	 * and will take the trap in iret instead.  Much code relies
221 	 * on user_mode() to distinguish a user trap frame (which can
222 	 * safely use invalid selectors) from a kernel trap frame.
223 	 */
224 	switch (offset) {
225 	case offsetof(struct user_regs_struct, cs):
226 	case offsetof(struct user_regs_struct, ss):
227 		if (unlikely(value == 0))
228 			return -EIO;
229 
230 	default:
231 		*pt_regs_access(task_pt_regs(task), offset) = value;
232 		break;
233 
234 	case offsetof(struct user_regs_struct, gs):
235 		if (task == current)
236 			set_user_gs(task_pt_regs(task), value);
237 		else
238 			task_user_gs(task) = value;
239 	}
240 
241 	return 0;
242 }
243 
244 #else  /* CONFIG_X86_64 */
245 
246 #define FLAG_MASK		(FLAG_MASK_32 | X86_EFLAGS_NT)
247 
248 static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long offset)
249 {
250 	BUILD_BUG_ON(offsetof(struct pt_regs, r15) != 0);
251 	return &regs->r15 + (offset / sizeof(regs->r15));
252 }
253 
254 static u16 get_segment_reg(struct task_struct *task, unsigned long offset)
255 {
256 	/*
257 	 * Returning the value truncates it to 16 bits.
258 	 */
259 	unsigned int seg;
260 
261 	switch (offset) {
262 	case offsetof(struct user_regs_struct, fs):
263 		if (task == current) {
264 			/* Older gas can't assemble movq %?s,%r?? */
265 			asm("movl %%fs,%0" : "=r" (seg));
266 			return seg;
267 		}
268 		return task->thread.fsindex;
269 	case offsetof(struct user_regs_struct, gs):
270 		if (task == current) {
271 			asm("movl %%gs,%0" : "=r" (seg));
272 			return seg;
273 		}
274 		return task->thread.gsindex;
275 	case offsetof(struct user_regs_struct, ds):
276 		if (task == current) {
277 			asm("movl %%ds,%0" : "=r" (seg));
278 			return seg;
279 		}
280 		return task->thread.ds;
281 	case offsetof(struct user_regs_struct, es):
282 		if (task == current) {
283 			asm("movl %%es,%0" : "=r" (seg));
284 			return seg;
285 		}
286 		return task->thread.es;
287 
288 	case offsetof(struct user_regs_struct, cs):
289 	case offsetof(struct user_regs_struct, ss):
290 		break;
291 	}
292 	return *pt_regs_access(task_pt_regs(task), offset);
293 }
294 
295 static int set_segment_reg(struct task_struct *task,
296 			   unsigned long offset, u16 value)
297 {
298 	/*
299 	 * The value argument was already truncated to 16 bits.
300 	 */
301 	if (invalid_selector(value))
302 		return -EIO;
303 
304 	switch (offset) {
305 	case offsetof(struct user_regs_struct,fs):
306 		task->thread.fsindex = value;
307 		if (task == current)
308 			loadsegment(fs, task->thread.fsindex);
309 		break;
310 	case offsetof(struct user_regs_struct,gs):
311 		task->thread.gsindex = value;
312 		if (task == current)
313 			load_gs_index(task->thread.gsindex);
314 		break;
315 	case offsetof(struct user_regs_struct,ds):
316 		task->thread.ds = value;
317 		if (task == current)
318 			loadsegment(ds, task->thread.ds);
319 		break;
320 	case offsetof(struct user_regs_struct,es):
321 		task->thread.es = value;
322 		if (task == current)
323 			loadsegment(es, task->thread.es);
324 		break;
325 
326 		/*
327 		 * Can't actually change these in 64-bit mode.
328 		 */
329 	case offsetof(struct user_regs_struct,cs):
330 		if (unlikely(value == 0))
331 			return -EIO;
332 		task_pt_regs(task)->cs = value;
333 		break;
334 	case offsetof(struct user_regs_struct,ss):
335 		if (unlikely(value == 0))
336 			return -EIO;
337 		task_pt_regs(task)->ss = value;
338 		break;
339 	}
340 
341 	return 0;
342 }
343 
344 #endif	/* CONFIG_X86_32 */
345 
346 static unsigned long get_flags(struct task_struct *task)
347 {
348 	unsigned long retval = task_pt_regs(task)->flags;
349 
350 	/*
351 	 * If the debugger set TF, hide it from the readout.
352 	 */
353 	if (test_tsk_thread_flag(task, TIF_FORCED_TF))
354 		retval &= ~X86_EFLAGS_TF;
355 
356 	return retval;
357 }
358 
359 static int set_flags(struct task_struct *task, unsigned long value)
360 {
361 	struct pt_regs *regs = task_pt_regs(task);
362 
363 	/*
364 	 * If the user value contains TF, mark that
365 	 * it was not "us" (the debugger) that set it.
366 	 * If not, make sure it stays set if we had.
367 	 */
368 	if (value & X86_EFLAGS_TF)
369 		clear_tsk_thread_flag(task, TIF_FORCED_TF);
370 	else if (test_tsk_thread_flag(task, TIF_FORCED_TF))
371 		value |= X86_EFLAGS_TF;
372 
373 	regs->flags = (regs->flags & ~FLAG_MASK) | (value & FLAG_MASK);
374 
375 	return 0;
376 }
377 
378 static int putreg(struct task_struct *child,
379 		  unsigned long offset, unsigned long value)
380 {
381 	switch (offset) {
382 	case offsetof(struct user_regs_struct, cs):
383 	case offsetof(struct user_regs_struct, ds):
384 	case offsetof(struct user_regs_struct, es):
385 	case offsetof(struct user_regs_struct, fs):
386 	case offsetof(struct user_regs_struct, gs):
387 	case offsetof(struct user_regs_struct, ss):
388 		return set_segment_reg(child, offset, value);
389 
390 	case offsetof(struct user_regs_struct, flags):
391 		return set_flags(child, value);
392 
393 #ifdef CONFIG_X86_64
394 	case offsetof(struct user_regs_struct,fs_base):
395 		if (value >= TASK_SIZE_MAX)
396 			return -EIO;
397 		/*
398 		 * When changing the segment base, use do_arch_prctl
399 		 * to set either thread.fs or thread.fsindex and the
400 		 * corresponding GDT slot.
401 		 */
402 		if (child->thread.fsbase != value)
403 			return do_arch_prctl(child, ARCH_SET_FS, value);
404 		return 0;
405 	case offsetof(struct user_regs_struct,gs_base):
406 		/*
407 		 * Exactly the same here as the %fs handling above.
408 		 */
409 		if (value >= TASK_SIZE_MAX)
410 			return -EIO;
411 		if (child->thread.gsbase != value)
412 			return do_arch_prctl(child, ARCH_SET_GS, value);
413 		return 0;
414 #endif
415 	}
416 
417 	*pt_regs_access(task_pt_regs(child), offset) = value;
418 	return 0;
419 }
420 
421 static unsigned long getreg(struct task_struct *task, unsigned long offset)
422 {
423 	switch (offset) {
424 	case offsetof(struct user_regs_struct, cs):
425 	case offsetof(struct user_regs_struct, ds):
426 	case offsetof(struct user_regs_struct, es):
427 	case offsetof(struct user_regs_struct, fs):
428 	case offsetof(struct user_regs_struct, gs):
429 	case offsetof(struct user_regs_struct, ss):
430 		return get_segment_reg(task, offset);
431 
432 	case offsetof(struct user_regs_struct, flags):
433 		return get_flags(task);
434 
435 #ifdef CONFIG_X86_64
436 	case offsetof(struct user_regs_struct, fs_base): {
437 		/*
438 		 * XXX: This will not behave as expected if called on
439 		 * current or if fsindex != 0.
440 		 */
441 		return task->thread.fsbase;
442 	}
443 	case offsetof(struct user_regs_struct, gs_base): {
444 		/*
445 		 * XXX: This will not behave as expected if called on
446 		 * current or if fsindex != 0.
447 		 */
448 		return task->thread.gsbase;
449 	}
450 #endif
451 	}
452 
453 	return *pt_regs_access(task_pt_regs(task), offset);
454 }
455 
456 static int genregs_get(struct task_struct *target,
457 		       const struct user_regset *regset,
458 		       unsigned int pos, unsigned int count,
459 		       void *kbuf, void __user *ubuf)
460 {
461 	if (kbuf) {
462 		unsigned long *k = kbuf;
463 		while (count >= sizeof(*k)) {
464 			*k++ = getreg(target, pos);
465 			count -= sizeof(*k);
466 			pos += sizeof(*k);
467 		}
468 	} else {
469 		unsigned long __user *u = ubuf;
470 		while (count >= sizeof(*u)) {
471 			if (__put_user(getreg(target, pos), u++))
472 				return -EFAULT;
473 			count -= sizeof(*u);
474 			pos += sizeof(*u);
475 		}
476 	}
477 
478 	return 0;
479 }
480 
481 static int genregs_set(struct task_struct *target,
482 		       const struct user_regset *regset,
483 		       unsigned int pos, unsigned int count,
484 		       const void *kbuf, const void __user *ubuf)
485 {
486 	int ret = 0;
487 	if (kbuf) {
488 		const unsigned long *k = kbuf;
489 		while (count >= sizeof(*k) && !ret) {
490 			ret = putreg(target, pos, *k++);
491 			count -= sizeof(*k);
492 			pos += sizeof(*k);
493 		}
494 	} else {
495 		const unsigned long  __user *u = ubuf;
496 		while (count >= sizeof(*u) && !ret) {
497 			unsigned long word;
498 			ret = __get_user(word, u++);
499 			if (ret)
500 				break;
501 			ret = putreg(target, pos, word);
502 			count -= sizeof(*u);
503 			pos += sizeof(*u);
504 		}
505 	}
506 	return ret;
507 }
508 
509 static void ptrace_triggered(struct perf_event *bp,
510 			     struct perf_sample_data *data,
511 			     struct pt_regs *regs)
512 {
513 	int i;
514 	struct thread_struct *thread = &(current->thread);
515 
516 	/*
517 	 * Store in the virtual DR6 register the fact that the breakpoint
518 	 * was hit so the thread's debugger will see it.
519 	 */
520 	for (i = 0; i < HBP_NUM; i++) {
521 		if (thread->ptrace_bps[i] == bp)
522 			break;
523 	}
524 
525 	thread->debugreg6 |= (DR_TRAP0 << i);
526 }
527 
528 /*
529  * Walk through every ptrace breakpoints for this thread and
530  * build the dr7 value on top of their attributes.
531  *
532  */
533 static unsigned long ptrace_get_dr7(struct perf_event *bp[])
534 {
535 	int i;
536 	int dr7 = 0;
537 	struct arch_hw_breakpoint *info;
538 
539 	for (i = 0; i < HBP_NUM; i++) {
540 		if (bp[i] && !bp[i]->attr.disabled) {
541 			info = counter_arch_bp(bp[i]);
542 			dr7 |= encode_dr7(i, info->len, info->type);
543 		}
544 	}
545 
546 	return dr7;
547 }
548 
549 static int ptrace_fill_bp_fields(struct perf_event_attr *attr,
550 					int len, int type, bool disabled)
551 {
552 	int err, bp_len, bp_type;
553 
554 	err = arch_bp_generic_fields(len, type, &bp_len, &bp_type);
555 	if (!err) {
556 		attr->bp_len = bp_len;
557 		attr->bp_type = bp_type;
558 		attr->disabled = disabled;
559 	}
560 
561 	return err;
562 }
563 
564 static struct perf_event *
565 ptrace_register_breakpoint(struct task_struct *tsk, int len, int type,
566 				unsigned long addr, bool disabled)
567 {
568 	struct perf_event_attr attr;
569 	int err;
570 
571 	ptrace_breakpoint_init(&attr);
572 	attr.bp_addr = addr;
573 
574 	err = ptrace_fill_bp_fields(&attr, len, type, disabled);
575 	if (err)
576 		return ERR_PTR(err);
577 
578 	return register_user_hw_breakpoint(&attr, ptrace_triggered,
579 						 NULL, tsk);
580 }
581 
582 static int ptrace_modify_breakpoint(struct perf_event *bp, int len, int type,
583 					int disabled)
584 {
585 	struct perf_event_attr attr = bp->attr;
586 	int err;
587 
588 	err = ptrace_fill_bp_fields(&attr, len, type, disabled);
589 	if (err)
590 		return err;
591 
592 	return modify_user_hw_breakpoint(bp, &attr);
593 }
594 
595 /*
596  * Handle ptrace writes to debug register 7.
597  */
598 static int ptrace_write_dr7(struct task_struct *tsk, unsigned long data)
599 {
600 	struct thread_struct *thread = &tsk->thread;
601 	unsigned long old_dr7;
602 	bool second_pass = false;
603 	int i, rc, ret = 0;
604 
605 	data &= ~DR_CONTROL_RESERVED;
606 	old_dr7 = ptrace_get_dr7(thread->ptrace_bps);
607 
608 restore:
609 	rc = 0;
610 	for (i = 0; i < HBP_NUM; i++) {
611 		unsigned len, type;
612 		bool disabled = !decode_dr7(data, i, &len, &type);
613 		struct perf_event *bp = thread->ptrace_bps[i];
614 
615 		if (!bp) {
616 			if (disabled)
617 				continue;
618 
619 			bp = ptrace_register_breakpoint(tsk,
620 					len, type, 0, disabled);
621 			if (IS_ERR(bp)) {
622 				rc = PTR_ERR(bp);
623 				break;
624 			}
625 
626 			thread->ptrace_bps[i] = bp;
627 			continue;
628 		}
629 
630 		rc = ptrace_modify_breakpoint(bp, len, type, disabled);
631 		if (rc)
632 			break;
633 	}
634 
635 	/* Restore if the first pass failed, second_pass shouldn't fail. */
636 	if (rc && !WARN_ON(second_pass)) {
637 		ret = rc;
638 		data = old_dr7;
639 		second_pass = true;
640 		goto restore;
641 	}
642 
643 	return ret;
644 }
645 
646 /*
647  * Handle PTRACE_PEEKUSR calls for the debug register area.
648  */
649 static unsigned long ptrace_get_debugreg(struct task_struct *tsk, int n)
650 {
651 	struct thread_struct *thread = &tsk->thread;
652 	unsigned long val = 0;
653 
654 	if (n < HBP_NUM) {
655 		struct perf_event *bp = thread->ptrace_bps[n];
656 
657 		if (bp)
658 			val = bp->hw.info.address;
659 	} else if (n == 6) {
660 		val = thread->debugreg6;
661 	} else if (n == 7) {
662 		val = thread->ptrace_dr7;
663 	}
664 	return val;
665 }
666 
667 static int ptrace_set_breakpoint_addr(struct task_struct *tsk, int nr,
668 				      unsigned long addr)
669 {
670 	struct thread_struct *t = &tsk->thread;
671 	struct perf_event *bp = t->ptrace_bps[nr];
672 	int err = 0;
673 
674 	if (!bp) {
675 		/*
676 		 * Put stub len and type to create an inactive but correct bp.
677 		 *
678 		 * CHECKME: the previous code returned -EIO if the addr wasn't
679 		 * a valid task virtual addr. The new one will return -EINVAL in
680 		 *  this case.
681 		 * -EINVAL may be what we want for in-kernel breakpoints users,
682 		 * but -EIO looks better for ptrace, since we refuse a register
683 		 * writing for the user. And anyway this is the previous
684 		 * behaviour.
685 		 */
686 		bp = ptrace_register_breakpoint(tsk,
687 				X86_BREAKPOINT_LEN_1, X86_BREAKPOINT_WRITE,
688 				addr, true);
689 		if (IS_ERR(bp))
690 			err = PTR_ERR(bp);
691 		else
692 			t->ptrace_bps[nr] = bp;
693 	} else {
694 		struct perf_event_attr attr = bp->attr;
695 
696 		attr.bp_addr = addr;
697 		err = modify_user_hw_breakpoint(bp, &attr);
698 	}
699 
700 	return err;
701 }
702 
703 /*
704  * Handle PTRACE_POKEUSR calls for the debug register area.
705  */
706 static int ptrace_set_debugreg(struct task_struct *tsk, int n,
707 			       unsigned long val)
708 {
709 	struct thread_struct *thread = &tsk->thread;
710 	/* There are no DR4 or DR5 registers */
711 	int rc = -EIO;
712 
713 	if (n < HBP_NUM) {
714 		rc = ptrace_set_breakpoint_addr(tsk, n, val);
715 	} else if (n == 6) {
716 		thread->debugreg6 = val;
717 		rc = 0;
718 	} else if (n == 7) {
719 		rc = ptrace_write_dr7(tsk, val);
720 		if (!rc)
721 			thread->ptrace_dr7 = val;
722 	}
723 	return rc;
724 }
725 
726 /*
727  * These access the current or another (stopped) task's io permission
728  * bitmap for debugging or core dump.
729  */
730 static int ioperm_active(struct task_struct *target,
731 			 const struct user_regset *regset)
732 {
733 	return target->thread.io_bitmap_max / regset->size;
734 }
735 
736 static int ioperm_get(struct task_struct *target,
737 		      const struct user_regset *regset,
738 		      unsigned int pos, unsigned int count,
739 		      void *kbuf, void __user *ubuf)
740 {
741 	if (!target->thread.io_bitmap_ptr)
742 		return -ENXIO;
743 
744 	return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
745 				   target->thread.io_bitmap_ptr,
746 				   0, IO_BITMAP_BYTES);
747 }
748 
749 /*
750  * Called by kernel/ptrace.c when detaching..
751  *
752  * Make sure the single step bit is not set.
753  */
754 void ptrace_disable(struct task_struct *child)
755 {
756 	user_disable_single_step(child);
757 #ifdef TIF_SYSCALL_EMU
758 	clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
759 #endif
760 }
761 
762 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
763 static const struct user_regset_view user_x86_32_view; /* Initialized below. */
764 #endif
765 
766 long arch_ptrace(struct task_struct *child, long request,
767 		 unsigned long addr, unsigned long data)
768 {
769 	int ret;
770 	unsigned long __user *datap = (unsigned long __user *)data;
771 
772 	switch (request) {
773 	/* read the word at location addr in the USER area. */
774 	case PTRACE_PEEKUSR: {
775 		unsigned long tmp;
776 
777 		ret = -EIO;
778 		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user))
779 			break;
780 
781 		tmp = 0;  /* Default return condition */
782 		if (addr < sizeof(struct user_regs_struct))
783 			tmp = getreg(child, addr);
784 		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
785 			 addr <= offsetof(struct user, u_debugreg[7])) {
786 			addr -= offsetof(struct user, u_debugreg[0]);
787 			tmp = ptrace_get_debugreg(child, addr / sizeof(data));
788 		}
789 		ret = put_user(tmp, datap);
790 		break;
791 	}
792 
793 	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
794 		ret = -EIO;
795 		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user))
796 			break;
797 
798 		if (addr < sizeof(struct user_regs_struct))
799 			ret = putreg(child, addr, data);
800 		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
801 			 addr <= offsetof(struct user, u_debugreg[7])) {
802 			addr -= offsetof(struct user, u_debugreg[0]);
803 			ret = ptrace_set_debugreg(child,
804 						  addr / sizeof(data), data);
805 		}
806 		break;
807 
808 	case PTRACE_GETREGS:	/* Get all gp regs from the child. */
809 		return copy_regset_to_user(child,
810 					   task_user_regset_view(current),
811 					   REGSET_GENERAL,
812 					   0, sizeof(struct user_regs_struct),
813 					   datap);
814 
815 	case PTRACE_SETREGS:	/* Set all gp regs in the child. */
816 		return copy_regset_from_user(child,
817 					     task_user_regset_view(current),
818 					     REGSET_GENERAL,
819 					     0, sizeof(struct user_regs_struct),
820 					     datap);
821 
822 	case PTRACE_GETFPREGS:	/* Get the child FPU state. */
823 		return copy_regset_to_user(child,
824 					   task_user_regset_view(current),
825 					   REGSET_FP,
826 					   0, sizeof(struct user_i387_struct),
827 					   datap);
828 
829 	case PTRACE_SETFPREGS:	/* Set the child FPU state. */
830 		return copy_regset_from_user(child,
831 					     task_user_regset_view(current),
832 					     REGSET_FP,
833 					     0, sizeof(struct user_i387_struct),
834 					     datap);
835 
836 #ifdef CONFIG_X86_32
837 	case PTRACE_GETFPXREGS:	/* Get the child extended FPU state. */
838 		return copy_regset_to_user(child, &user_x86_32_view,
839 					   REGSET_XFP,
840 					   0, sizeof(struct user_fxsr_struct),
841 					   datap) ? -EIO : 0;
842 
843 	case PTRACE_SETFPXREGS:	/* Set the child extended FPU state. */
844 		return copy_regset_from_user(child, &user_x86_32_view,
845 					     REGSET_XFP,
846 					     0, sizeof(struct user_fxsr_struct),
847 					     datap) ? -EIO : 0;
848 #endif
849 
850 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
851 	case PTRACE_GET_THREAD_AREA:
852 		if ((int) addr < 0)
853 			return -EIO;
854 		ret = do_get_thread_area(child, addr,
855 					(struct user_desc __user *)data);
856 		break;
857 
858 	case PTRACE_SET_THREAD_AREA:
859 		if ((int) addr < 0)
860 			return -EIO;
861 		ret = do_set_thread_area(child, addr,
862 					(struct user_desc __user *)data, 0);
863 		break;
864 #endif
865 
866 #ifdef CONFIG_X86_64
867 		/* normal 64bit interface to access TLS data.
868 		   Works just like arch_prctl, except that the arguments
869 		   are reversed. */
870 	case PTRACE_ARCH_PRCTL:
871 		ret = do_arch_prctl(child, data, addr);
872 		break;
873 #endif
874 
875 	default:
876 		ret = ptrace_request(child, request, addr, data);
877 		break;
878 	}
879 
880 	return ret;
881 }
882 
883 #ifdef CONFIG_IA32_EMULATION
884 
885 #include <linux/compat.h>
886 #include <linux/syscalls.h>
887 #include <asm/ia32.h>
888 #include <asm/user32.h>
889 
890 #define R32(l,q)							\
891 	case offsetof(struct user32, regs.l):				\
892 		regs->q = value; break
893 
894 #define SEG32(rs)							\
895 	case offsetof(struct user32, regs.rs):				\
896 		return set_segment_reg(child,				\
897 				       offsetof(struct user_regs_struct, rs), \
898 				       value);				\
899 		break
900 
901 static int putreg32(struct task_struct *child, unsigned regno, u32 value)
902 {
903 	struct pt_regs *regs = task_pt_regs(child);
904 
905 	switch (regno) {
906 
907 	SEG32(cs);
908 	SEG32(ds);
909 	SEG32(es);
910 	SEG32(fs);
911 	SEG32(gs);
912 	SEG32(ss);
913 
914 	R32(ebx, bx);
915 	R32(ecx, cx);
916 	R32(edx, dx);
917 	R32(edi, di);
918 	R32(esi, si);
919 	R32(ebp, bp);
920 	R32(eax, ax);
921 	R32(eip, ip);
922 	R32(esp, sp);
923 
924 	case offsetof(struct user32, regs.orig_eax):
925 		/*
926 		 * Warning: bizarre corner case fixup here.  A 32-bit
927 		 * debugger setting orig_eax to -1 wants to disable
928 		 * syscall restart.  Make sure that the syscall
929 		 * restart code sign-extends orig_ax.  Also make sure
930 		 * we interpret the -ERESTART* codes correctly if
931 		 * loaded into regs->ax in case the task is not
932 		 * actually still sitting at the exit from a 32-bit
933 		 * syscall with TS_COMPAT still set.
934 		 */
935 		regs->orig_ax = value;
936 		if (syscall_get_nr(child, regs) >= 0)
937 			child->thread.status |= TS_I386_REGS_POKED;
938 		break;
939 
940 	case offsetof(struct user32, regs.eflags):
941 		return set_flags(child, value);
942 
943 	case offsetof(struct user32, u_debugreg[0]) ...
944 		offsetof(struct user32, u_debugreg[7]):
945 		regno -= offsetof(struct user32, u_debugreg[0]);
946 		return ptrace_set_debugreg(child, regno / 4, value);
947 
948 	default:
949 		if (regno > sizeof(struct user32) || (regno & 3))
950 			return -EIO;
951 
952 		/*
953 		 * Other dummy fields in the virtual user structure
954 		 * are ignored
955 		 */
956 		break;
957 	}
958 	return 0;
959 }
960 
961 #undef R32
962 #undef SEG32
963 
964 #define R32(l,q)							\
965 	case offsetof(struct user32, regs.l):				\
966 		*val = regs->q; break
967 
968 #define SEG32(rs)							\
969 	case offsetof(struct user32, regs.rs):				\
970 		*val = get_segment_reg(child,				\
971 				       offsetof(struct user_regs_struct, rs)); \
972 		break
973 
974 static int getreg32(struct task_struct *child, unsigned regno, u32 *val)
975 {
976 	struct pt_regs *regs = task_pt_regs(child);
977 
978 	switch (regno) {
979 
980 	SEG32(ds);
981 	SEG32(es);
982 	SEG32(fs);
983 	SEG32(gs);
984 
985 	R32(cs, cs);
986 	R32(ss, ss);
987 	R32(ebx, bx);
988 	R32(ecx, cx);
989 	R32(edx, dx);
990 	R32(edi, di);
991 	R32(esi, si);
992 	R32(ebp, bp);
993 	R32(eax, ax);
994 	R32(orig_eax, orig_ax);
995 	R32(eip, ip);
996 	R32(esp, sp);
997 
998 	case offsetof(struct user32, regs.eflags):
999 		*val = get_flags(child);
1000 		break;
1001 
1002 	case offsetof(struct user32, u_debugreg[0]) ...
1003 		offsetof(struct user32, u_debugreg[7]):
1004 		regno -= offsetof(struct user32, u_debugreg[0]);
1005 		*val = ptrace_get_debugreg(child, regno / 4);
1006 		break;
1007 
1008 	default:
1009 		if (regno > sizeof(struct user32) || (regno & 3))
1010 			return -EIO;
1011 
1012 		/*
1013 		 * Other dummy fields in the virtual user structure
1014 		 * are ignored
1015 		 */
1016 		*val = 0;
1017 		break;
1018 	}
1019 	return 0;
1020 }
1021 
1022 #undef R32
1023 #undef SEG32
1024 
1025 static int genregs32_get(struct task_struct *target,
1026 			 const struct user_regset *regset,
1027 			 unsigned int pos, unsigned int count,
1028 			 void *kbuf, void __user *ubuf)
1029 {
1030 	if (kbuf) {
1031 		compat_ulong_t *k = kbuf;
1032 		while (count >= sizeof(*k)) {
1033 			getreg32(target, pos, k++);
1034 			count -= sizeof(*k);
1035 			pos += sizeof(*k);
1036 		}
1037 	} else {
1038 		compat_ulong_t __user *u = ubuf;
1039 		while (count >= sizeof(*u)) {
1040 			compat_ulong_t word;
1041 			getreg32(target, pos, &word);
1042 			if (__put_user(word, u++))
1043 				return -EFAULT;
1044 			count -= sizeof(*u);
1045 			pos += sizeof(*u);
1046 		}
1047 	}
1048 
1049 	return 0;
1050 }
1051 
1052 static int genregs32_set(struct task_struct *target,
1053 			 const struct user_regset *regset,
1054 			 unsigned int pos, unsigned int count,
1055 			 const void *kbuf, const void __user *ubuf)
1056 {
1057 	int ret = 0;
1058 	if (kbuf) {
1059 		const compat_ulong_t *k = kbuf;
1060 		while (count >= sizeof(*k) && !ret) {
1061 			ret = putreg32(target, pos, *k++);
1062 			count -= sizeof(*k);
1063 			pos += sizeof(*k);
1064 		}
1065 	} else {
1066 		const compat_ulong_t __user *u = ubuf;
1067 		while (count >= sizeof(*u) && !ret) {
1068 			compat_ulong_t word;
1069 			ret = __get_user(word, u++);
1070 			if (ret)
1071 				break;
1072 			ret = putreg32(target, pos, word);
1073 			count -= sizeof(*u);
1074 			pos += sizeof(*u);
1075 		}
1076 	}
1077 	return ret;
1078 }
1079 
1080 static long ia32_arch_ptrace(struct task_struct *child, compat_long_t request,
1081 			     compat_ulong_t caddr, compat_ulong_t cdata)
1082 {
1083 	unsigned long addr = caddr;
1084 	unsigned long data = cdata;
1085 	void __user *datap = compat_ptr(data);
1086 	int ret;
1087 	__u32 val;
1088 
1089 	switch (request) {
1090 	case PTRACE_PEEKUSR:
1091 		ret = getreg32(child, addr, &val);
1092 		if (ret == 0)
1093 			ret = put_user(val, (__u32 __user *)datap);
1094 		break;
1095 
1096 	case PTRACE_POKEUSR:
1097 		ret = putreg32(child, addr, data);
1098 		break;
1099 
1100 	case PTRACE_GETREGS:	/* Get all gp regs from the child. */
1101 		return copy_regset_to_user(child, &user_x86_32_view,
1102 					   REGSET_GENERAL,
1103 					   0, sizeof(struct user_regs_struct32),
1104 					   datap);
1105 
1106 	case PTRACE_SETREGS:	/* Set all gp regs in the child. */
1107 		return copy_regset_from_user(child, &user_x86_32_view,
1108 					     REGSET_GENERAL, 0,
1109 					     sizeof(struct user_regs_struct32),
1110 					     datap);
1111 
1112 	case PTRACE_GETFPREGS:	/* Get the child FPU state. */
1113 		return copy_regset_to_user(child, &user_x86_32_view,
1114 					   REGSET_FP, 0,
1115 					   sizeof(struct user_i387_ia32_struct),
1116 					   datap);
1117 
1118 	case PTRACE_SETFPREGS:	/* Set the child FPU state. */
1119 		return copy_regset_from_user(
1120 			child, &user_x86_32_view, REGSET_FP,
1121 			0, sizeof(struct user_i387_ia32_struct), datap);
1122 
1123 	case PTRACE_GETFPXREGS:	/* Get the child extended FPU state. */
1124 		return copy_regset_to_user(child, &user_x86_32_view,
1125 					   REGSET_XFP, 0,
1126 					   sizeof(struct user32_fxsr_struct),
1127 					   datap);
1128 
1129 	case PTRACE_SETFPXREGS:	/* Set the child extended FPU state. */
1130 		return copy_regset_from_user(child, &user_x86_32_view,
1131 					     REGSET_XFP, 0,
1132 					     sizeof(struct user32_fxsr_struct),
1133 					     datap);
1134 
1135 	case PTRACE_GET_THREAD_AREA:
1136 	case PTRACE_SET_THREAD_AREA:
1137 		return arch_ptrace(child, request, addr, data);
1138 
1139 	default:
1140 		return compat_ptrace_request(child, request, addr, data);
1141 	}
1142 
1143 	return ret;
1144 }
1145 #endif /* CONFIG_IA32_EMULATION */
1146 
1147 #ifdef CONFIG_X86_X32_ABI
1148 static long x32_arch_ptrace(struct task_struct *child,
1149 			    compat_long_t request, compat_ulong_t caddr,
1150 			    compat_ulong_t cdata)
1151 {
1152 	unsigned long addr = caddr;
1153 	unsigned long data = cdata;
1154 	void __user *datap = compat_ptr(data);
1155 	int ret;
1156 
1157 	switch (request) {
1158 	/* Read 32bits at location addr in the USER area.  Only allow
1159 	   to return the lower 32bits of segment and debug registers.  */
1160 	case PTRACE_PEEKUSR: {
1161 		u32 tmp;
1162 
1163 		ret = -EIO;
1164 		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user) ||
1165 		    addr < offsetof(struct user_regs_struct, cs))
1166 			break;
1167 
1168 		tmp = 0;  /* Default return condition */
1169 		if (addr < sizeof(struct user_regs_struct))
1170 			tmp = getreg(child, addr);
1171 		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
1172 			 addr <= offsetof(struct user, u_debugreg[7])) {
1173 			addr -= offsetof(struct user, u_debugreg[0]);
1174 			tmp = ptrace_get_debugreg(child, addr / sizeof(data));
1175 		}
1176 		ret = put_user(tmp, (__u32 __user *)datap);
1177 		break;
1178 	}
1179 
1180 	/* Write the word at location addr in the USER area.  Only allow
1181 	   to update segment and debug registers with the upper 32bits
1182 	   zero-extended. */
1183 	case PTRACE_POKEUSR:
1184 		ret = -EIO;
1185 		if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user) ||
1186 		    addr < offsetof(struct user_regs_struct, cs))
1187 			break;
1188 
1189 		if (addr < sizeof(struct user_regs_struct))
1190 			ret = putreg(child, addr, data);
1191 		else if (addr >= offsetof(struct user, u_debugreg[0]) &&
1192 			 addr <= offsetof(struct user, u_debugreg[7])) {
1193 			addr -= offsetof(struct user, u_debugreg[0]);
1194 			ret = ptrace_set_debugreg(child,
1195 						  addr / sizeof(data), data);
1196 		}
1197 		break;
1198 
1199 	case PTRACE_GETREGS:	/* Get all gp regs from the child. */
1200 		return copy_regset_to_user(child,
1201 					   task_user_regset_view(current),
1202 					   REGSET_GENERAL,
1203 					   0, sizeof(struct user_regs_struct),
1204 					   datap);
1205 
1206 	case PTRACE_SETREGS:	/* Set all gp regs in the child. */
1207 		return copy_regset_from_user(child,
1208 					     task_user_regset_view(current),
1209 					     REGSET_GENERAL,
1210 					     0, sizeof(struct user_regs_struct),
1211 					     datap);
1212 
1213 	case PTRACE_GETFPREGS:	/* Get the child FPU state. */
1214 		return copy_regset_to_user(child,
1215 					   task_user_regset_view(current),
1216 					   REGSET_FP,
1217 					   0, sizeof(struct user_i387_struct),
1218 					   datap);
1219 
1220 	case PTRACE_SETFPREGS:	/* Set the child FPU state. */
1221 		return copy_regset_from_user(child,
1222 					     task_user_regset_view(current),
1223 					     REGSET_FP,
1224 					     0, sizeof(struct user_i387_struct),
1225 					     datap);
1226 
1227 	default:
1228 		return compat_ptrace_request(child, request, addr, data);
1229 	}
1230 
1231 	return ret;
1232 }
1233 #endif
1234 
1235 #ifdef CONFIG_COMPAT
1236 long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
1237 			compat_ulong_t caddr, compat_ulong_t cdata)
1238 {
1239 #ifdef CONFIG_X86_X32_ABI
1240 	if (!in_ia32_syscall())
1241 		return x32_arch_ptrace(child, request, caddr, cdata);
1242 #endif
1243 #ifdef CONFIG_IA32_EMULATION
1244 	return ia32_arch_ptrace(child, request, caddr, cdata);
1245 #else
1246 	return 0;
1247 #endif
1248 }
1249 #endif	/* CONFIG_COMPAT */
1250 
1251 #ifdef CONFIG_X86_64
1252 
1253 static struct user_regset x86_64_regsets[] __ro_after_init = {
1254 	[REGSET_GENERAL] = {
1255 		.core_note_type = NT_PRSTATUS,
1256 		.n = sizeof(struct user_regs_struct) / sizeof(long),
1257 		.size = sizeof(long), .align = sizeof(long),
1258 		.get = genregs_get, .set = genregs_set
1259 	},
1260 	[REGSET_FP] = {
1261 		.core_note_type = NT_PRFPREG,
1262 		.n = sizeof(struct user_i387_struct) / sizeof(long),
1263 		.size = sizeof(long), .align = sizeof(long),
1264 		.active = regset_xregset_fpregs_active, .get = xfpregs_get, .set = xfpregs_set
1265 	},
1266 	[REGSET_XSTATE] = {
1267 		.core_note_type = NT_X86_XSTATE,
1268 		.size = sizeof(u64), .align = sizeof(u64),
1269 		.active = xstateregs_active, .get = xstateregs_get,
1270 		.set = xstateregs_set
1271 	},
1272 	[REGSET_IOPERM64] = {
1273 		.core_note_type = NT_386_IOPERM,
1274 		.n = IO_BITMAP_LONGS,
1275 		.size = sizeof(long), .align = sizeof(long),
1276 		.active = ioperm_active, .get = ioperm_get
1277 	},
1278 };
1279 
1280 static const struct user_regset_view user_x86_64_view = {
1281 	.name = "x86_64", .e_machine = EM_X86_64,
1282 	.regsets = x86_64_regsets, .n = ARRAY_SIZE(x86_64_regsets)
1283 };
1284 
1285 #else  /* CONFIG_X86_32 */
1286 
1287 #define user_regs_struct32	user_regs_struct
1288 #define genregs32_get		genregs_get
1289 #define genregs32_set		genregs_set
1290 
1291 #endif	/* CONFIG_X86_64 */
1292 
1293 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
1294 static struct user_regset x86_32_regsets[] __ro_after_init = {
1295 	[REGSET_GENERAL] = {
1296 		.core_note_type = NT_PRSTATUS,
1297 		.n = sizeof(struct user_regs_struct32) / sizeof(u32),
1298 		.size = sizeof(u32), .align = sizeof(u32),
1299 		.get = genregs32_get, .set = genregs32_set
1300 	},
1301 	[REGSET_FP] = {
1302 		.core_note_type = NT_PRFPREG,
1303 		.n = sizeof(struct user_i387_ia32_struct) / sizeof(u32),
1304 		.size = sizeof(u32), .align = sizeof(u32),
1305 		.active = regset_fpregs_active, .get = fpregs_get, .set = fpregs_set
1306 	},
1307 	[REGSET_XFP] = {
1308 		.core_note_type = NT_PRXFPREG,
1309 		.n = sizeof(struct user32_fxsr_struct) / sizeof(u32),
1310 		.size = sizeof(u32), .align = sizeof(u32),
1311 		.active = regset_xregset_fpregs_active, .get = xfpregs_get, .set = xfpregs_set
1312 	},
1313 	[REGSET_XSTATE] = {
1314 		.core_note_type = NT_X86_XSTATE,
1315 		.size = sizeof(u64), .align = sizeof(u64),
1316 		.active = xstateregs_active, .get = xstateregs_get,
1317 		.set = xstateregs_set
1318 	},
1319 	[REGSET_TLS] = {
1320 		.core_note_type = NT_386_TLS,
1321 		.n = GDT_ENTRY_TLS_ENTRIES, .bias = GDT_ENTRY_TLS_MIN,
1322 		.size = sizeof(struct user_desc),
1323 		.align = sizeof(struct user_desc),
1324 		.active = regset_tls_active,
1325 		.get = regset_tls_get, .set = regset_tls_set
1326 	},
1327 	[REGSET_IOPERM32] = {
1328 		.core_note_type = NT_386_IOPERM,
1329 		.n = IO_BITMAP_BYTES / sizeof(u32),
1330 		.size = sizeof(u32), .align = sizeof(u32),
1331 		.active = ioperm_active, .get = ioperm_get
1332 	},
1333 };
1334 
1335 static const struct user_regset_view user_x86_32_view = {
1336 	.name = "i386", .e_machine = EM_386,
1337 	.regsets = x86_32_regsets, .n = ARRAY_SIZE(x86_32_regsets)
1338 };
1339 #endif
1340 
1341 /*
1342  * This represents bytes 464..511 in the memory layout exported through
1343  * the REGSET_XSTATE interface.
1344  */
1345 u64 xstate_fx_sw_bytes[USER_XSTATE_FX_SW_WORDS];
1346 
1347 void __init update_regset_xstate_info(unsigned int size, u64 xstate_mask)
1348 {
1349 #ifdef CONFIG_X86_64
1350 	x86_64_regsets[REGSET_XSTATE].n = size / sizeof(u64);
1351 #endif
1352 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
1353 	x86_32_regsets[REGSET_XSTATE].n = size / sizeof(u64);
1354 #endif
1355 	xstate_fx_sw_bytes[USER_XSTATE_XCR0_WORD] = xstate_mask;
1356 }
1357 
1358 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
1359 {
1360 #ifdef CONFIG_IA32_EMULATION
1361 	if (!user_64bit_mode(task_pt_regs(task)))
1362 #endif
1363 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
1364 		return &user_x86_32_view;
1365 #endif
1366 #ifdef CONFIG_X86_64
1367 	return &user_x86_64_view;
1368 #endif
1369 }
1370 
1371 static void fill_sigtrap_info(struct task_struct *tsk,
1372 				struct pt_regs *regs,
1373 				int error_code, int si_code,
1374 				struct siginfo *info)
1375 {
1376 	tsk->thread.trap_nr = X86_TRAP_DB;
1377 	tsk->thread.error_code = error_code;
1378 
1379 	memset(info, 0, sizeof(*info));
1380 	info->si_signo = SIGTRAP;
1381 	info->si_code = si_code;
1382 	info->si_addr = user_mode(regs) ? (void __user *)regs->ip : NULL;
1383 }
1384 
1385 void user_single_step_siginfo(struct task_struct *tsk,
1386 				struct pt_regs *regs,
1387 				struct siginfo *info)
1388 {
1389 	fill_sigtrap_info(tsk, regs, 0, TRAP_BRKPT, info);
1390 }
1391 
1392 void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,
1393 					 int error_code, int si_code)
1394 {
1395 	struct siginfo info;
1396 
1397 	fill_sigtrap_info(tsk, regs, error_code, si_code, &info);
1398 	/* Send us the fake SIGTRAP */
1399 	force_sig_info(SIGTRAP, &info, tsk);
1400 }
1401