1 /* By Ross Biro 1/23/92 */
3 * Pentium III FXSR, SSE support
4 * Gareth Hughes <gareth@valinux.com>, May 2000
7 #include <linux/kernel.h>
8 #include <linux/sched.h>
10 #include <linux/smp.h>
11 #include <linux/errno.h>
12 #include <linux/slab.h>
13 #include <linux/ptrace.h>
14 #include <linux/regset.h>
15 #include <linux/tracehook.h>
16 #include <linux/user.h>
17 #include <linux/elf.h>
18 #include <linux/security.h>
19 #include <linux/audit.h>
20 #include <linux/seccomp.h>
21 #include <linux/signal.h>
22 #include <linux/perf_event.h>
23 #include <linux/hw_breakpoint.h>
24 #include <linux/rcupdate.h>
25 #include <linux/export.h>
26 #include <linux/context_tracking.h>
28 #include <asm/uaccess.h>
29 #include <asm/pgtable.h>
30 #include <asm/processor.h>
31 #include <asm/fpu-internal.h>
32 #include <asm/debugreg.h>
35 #include <asm/prctl.h>
36 #include <asm/proto.h>
37 #include <asm/hw_breakpoint.h>
38 #include <asm/traps.h>
42 #define CREATE_TRACE_POINTS
43 #include <trace/events/syscalls.h>
49 REGSET_IOPERM64
= REGSET_XFP
,
55 struct pt_regs_offset
{
60 #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
61 #define REG_OFFSET_END {.name = NULL, .offset = 0}
63 static const struct pt_regs_offset regoffset_table
[] = {
87 REG_OFFSET_NAME(orig_ax
),
90 REG_OFFSET_NAME(flags
),
97 * regs_query_register_offset() - query register offset from its name
98 * @name: the name of a register
100 * regs_query_register_offset() returns the offset of a register in struct
101 * pt_regs from its name. If the name is invalid, this returns -EINVAL;
103 int regs_query_register_offset(const char *name
)
105 const struct pt_regs_offset
*roff
;
106 for (roff
= regoffset_table
; roff
->name
!= NULL
; roff
++)
107 if (!strcmp(roff
->name
, name
))
113 * regs_query_register_name() - query register name from its offset
114 * @offset: the offset of a register in struct pt_regs.
116 * regs_query_register_name() returns the name of a register from its
117 * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
119 const char *regs_query_register_name(unsigned int offset
)
121 const struct pt_regs_offset
*roff
;
122 for (roff
= regoffset_table
; roff
->name
!= NULL
; roff
++)
123 if (roff
->offset
== offset
)
128 static const int arg_offs_table
[] = {
130 [0] = offsetof(struct pt_regs
, ax
),
131 [1] = offsetof(struct pt_regs
, dx
),
132 [2] = offsetof(struct pt_regs
, cx
)
133 #else /* CONFIG_X86_64 */
134 [0] = offsetof(struct pt_regs
, di
),
135 [1] = offsetof(struct pt_regs
, si
),
136 [2] = offsetof(struct pt_regs
, dx
),
137 [3] = offsetof(struct pt_regs
, cx
),
138 [4] = offsetof(struct pt_regs
, r8
),
139 [5] = offsetof(struct pt_regs
, r9
)
144 * does not yet catch signals sent when the child dies.
145 * in exit.c or in signal.c.
149 * Determines which flags the user has access to [1 = access, 0 = no access].
151 #define FLAG_MASK_32 ((unsigned long) \
152 (X86_EFLAGS_CF | X86_EFLAGS_PF | \
153 X86_EFLAGS_AF | X86_EFLAGS_ZF | \
154 X86_EFLAGS_SF | X86_EFLAGS_TF | \
155 X86_EFLAGS_DF | X86_EFLAGS_OF | \
156 X86_EFLAGS_RF | X86_EFLAGS_AC))
159 * Determines whether a value may be installed in a segment register.
161 static inline bool invalid_selector(u16 value
)
163 return unlikely(value
!= 0 && (value
& SEGMENT_RPL_MASK
) != USER_RPL
);
168 #define FLAG_MASK FLAG_MASK_32
171 * X86_32 CPUs don't save ss and esp if the CPU is already in kernel mode
172 * when it traps. The previous stack will be directly underneath the saved
173 * registers, and 'sp/ss' won't even have been saved. Thus the '®s->sp'.
175 * Now, if the stack is empty, '®s->sp' is out of range. In this
176 * case we try to take the previous stack. To always return a non-null
177 * stack pointer we fall back to regs as stack if no previous stack
180 * This is valid only for kernel mode traps.
182 unsigned long kernel_stack_pointer(struct pt_regs
*regs
)
184 unsigned long context
= (unsigned long)regs
& ~(THREAD_SIZE
- 1);
185 unsigned long sp
= (unsigned long)®s
->sp
;
188 if (context
== (sp
& ~(THREAD_SIZE
- 1)))
191 prev_esp
= (u32
*)(context
);
193 return (unsigned long)prev_esp
;
195 return (unsigned long)regs
;
197 EXPORT_SYMBOL_GPL(kernel_stack_pointer
);
199 static unsigned long *pt_regs_access(struct pt_regs
*regs
, unsigned long regno
)
201 BUILD_BUG_ON(offsetof(struct pt_regs
, bx
) != 0);
202 return ®s
->bx
+ (regno
>> 2);
205 static u16
get_segment_reg(struct task_struct
*task
, unsigned long offset
)
208 * Returning the value truncates it to 16 bits.
211 if (offset
!= offsetof(struct user_regs_struct
, gs
))
212 retval
= *pt_regs_access(task_pt_regs(task
), offset
);
215 retval
= get_user_gs(task_pt_regs(task
));
217 retval
= task_user_gs(task
);
222 static int set_segment_reg(struct task_struct
*task
,
223 unsigned long offset
, u16 value
)
226 * The value argument was already truncated to 16 bits.
228 if (invalid_selector(value
))
232 * For %cs and %ss we cannot permit a null selector.
233 * We can permit a bogus selector as long as it has USER_RPL.
234 * Null selectors are fine for other segment registers, but
235 * we will never get back to user mode with invalid %cs or %ss
236 * and will take the trap in iret instead. Much code relies
237 * on user_mode() to distinguish a user trap frame (which can
238 * safely use invalid selectors) from a kernel trap frame.
241 case offsetof(struct user_regs_struct
, cs
):
242 case offsetof(struct user_regs_struct
, ss
):
243 if (unlikely(value
== 0))
247 *pt_regs_access(task_pt_regs(task
), offset
) = value
;
250 case offsetof(struct user_regs_struct
, gs
):
252 set_user_gs(task_pt_regs(task
), value
);
254 task_user_gs(task
) = value
;
260 #else /* CONFIG_X86_64 */
262 #define FLAG_MASK (FLAG_MASK_32 | X86_EFLAGS_NT)
264 static unsigned long *pt_regs_access(struct pt_regs
*regs
, unsigned long offset
)
266 BUILD_BUG_ON(offsetof(struct pt_regs
, r15
) != 0);
267 return ®s
->r15
+ (offset
/ sizeof(regs
->r15
));
270 static u16
get_segment_reg(struct task_struct
*task
, unsigned long offset
)
273 * Returning the value truncates it to 16 bits.
278 case offsetof(struct user_regs_struct
, fs
):
279 if (task
== current
) {
280 /* Older gas can't assemble movq %?s,%r?? */
281 asm("movl %%fs,%0" : "=r" (seg
));
284 return task
->thread
.fsindex
;
285 case offsetof(struct user_regs_struct
, gs
):
286 if (task
== current
) {
287 asm("movl %%gs,%0" : "=r" (seg
));
290 return task
->thread
.gsindex
;
291 case offsetof(struct user_regs_struct
, ds
):
292 if (task
== current
) {
293 asm("movl %%ds,%0" : "=r" (seg
));
296 return task
->thread
.ds
;
297 case offsetof(struct user_regs_struct
, es
):
298 if (task
== current
) {
299 asm("movl %%es,%0" : "=r" (seg
));
302 return task
->thread
.es
;
304 case offsetof(struct user_regs_struct
, cs
):
305 case offsetof(struct user_regs_struct
, ss
):
308 return *pt_regs_access(task_pt_regs(task
), offset
);
311 static int set_segment_reg(struct task_struct
*task
,
312 unsigned long offset
, u16 value
)
315 * The value argument was already truncated to 16 bits.
317 if (invalid_selector(value
))
321 case offsetof(struct user_regs_struct
,fs
):
323 * If this is setting fs as for normal 64-bit use but
324 * setting fs_base has implicitly changed it, leave it.
326 if ((value
== FS_TLS_SEL
&& task
->thread
.fsindex
== 0 &&
327 task
->thread
.fs
!= 0) ||
328 (value
== 0 && task
->thread
.fsindex
== FS_TLS_SEL
&&
329 task
->thread
.fs
== 0))
331 task
->thread
.fsindex
= value
;
333 loadsegment(fs
, task
->thread
.fsindex
);
335 case offsetof(struct user_regs_struct
,gs
):
337 * If this is setting gs as for normal 64-bit use but
338 * setting gs_base has implicitly changed it, leave it.
340 if ((value
== GS_TLS_SEL
&& task
->thread
.gsindex
== 0 &&
341 task
->thread
.gs
!= 0) ||
342 (value
== 0 && task
->thread
.gsindex
== GS_TLS_SEL
&&
343 task
->thread
.gs
== 0))
345 task
->thread
.gsindex
= value
;
347 load_gs_index(task
->thread
.gsindex
);
349 case offsetof(struct user_regs_struct
,ds
):
350 task
->thread
.ds
= value
;
352 loadsegment(ds
, task
->thread
.ds
);
354 case offsetof(struct user_regs_struct
,es
):
355 task
->thread
.es
= value
;
357 loadsegment(es
, task
->thread
.es
);
361 * Can't actually change these in 64-bit mode.
363 case offsetof(struct user_regs_struct
,cs
):
364 if (unlikely(value
== 0))
366 task_pt_regs(task
)->cs
= value
;
368 case offsetof(struct user_regs_struct
,ss
):
369 if (unlikely(value
== 0))
371 task_pt_regs(task
)->ss
= value
;
378 #endif /* CONFIG_X86_32 */
380 static unsigned long get_flags(struct task_struct
*task
)
382 unsigned long retval
= task_pt_regs(task
)->flags
;
385 * If the debugger set TF, hide it from the readout.
387 if (test_tsk_thread_flag(task
, TIF_FORCED_TF
))
388 retval
&= ~X86_EFLAGS_TF
;
393 static int set_flags(struct task_struct
*task
, unsigned long value
)
395 struct pt_regs
*regs
= task_pt_regs(task
);
398 * If the user value contains TF, mark that
399 * it was not "us" (the debugger) that set it.
400 * If not, make sure it stays set if we had.
402 if (value
& X86_EFLAGS_TF
)
403 clear_tsk_thread_flag(task
, TIF_FORCED_TF
);
404 else if (test_tsk_thread_flag(task
, TIF_FORCED_TF
))
405 value
|= X86_EFLAGS_TF
;
407 regs
->flags
= (regs
->flags
& ~FLAG_MASK
) | (value
& FLAG_MASK
);
412 static int putreg(struct task_struct
*child
,
413 unsigned long offset
, unsigned long value
)
416 case offsetof(struct user_regs_struct
, cs
):
417 case offsetof(struct user_regs_struct
, ds
):
418 case offsetof(struct user_regs_struct
, es
):
419 case offsetof(struct user_regs_struct
, fs
):
420 case offsetof(struct user_regs_struct
, gs
):
421 case offsetof(struct user_regs_struct
, ss
):
422 return set_segment_reg(child
, offset
, value
);
424 case offsetof(struct user_regs_struct
, flags
):
425 return set_flags(child
, value
);
428 case offsetof(struct user_regs_struct
,fs_base
):
429 if (value
>= TASK_SIZE_OF(child
))
432 * When changing the segment base, use do_arch_prctl
433 * to set either thread.fs or thread.fsindex and the
434 * corresponding GDT slot.
436 if (child
->thread
.fs
!= value
)
437 return do_arch_prctl(child
, ARCH_SET_FS
, value
);
439 case offsetof(struct user_regs_struct
,gs_base
):
441 * Exactly the same here as the %fs handling above.
443 if (value
>= TASK_SIZE_OF(child
))
445 if (child
->thread
.gs
!= value
)
446 return do_arch_prctl(child
, ARCH_SET_GS
, value
);
451 *pt_regs_access(task_pt_regs(child
), offset
) = value
;
455 static unsigned long getreg(struct task_struct
*task
, unsigned long offset
)
458 case offsetof(struct user_regs_struct
, cs
):
459 case offsetof(struct user_regs_struct
, ds
):
460 case offsetof(struct user_regs_struct
, es
):
461 case offsetof(struct user_regs_struct
, fs
):
462 case offsetof(struct user_regs_struct
, gs
):
463 case offsetof(struct user_regs_struct
, ss
):
464 return get_segment_reg(task
, offset
);
466 case offsetof(struct user_regs_struct
, flags
):
467 return get_flags(task
);
470 case offsetof(struct user_regs_struct
, fs_base
): {
472 * do_arch_prctl may have used a GDT slot instead of
473 * the MSR. To userland, it appears the same either
474 * way, except the %fs segment selector might not be 0.
476 unsigned int seg
= task
->thread
.fsindex
;
477 if (task
->thread
.fs
!= 0)
478 return task
->thread
.fs
;
480 asm("movl %%fs,%0" : "=r" (seg
));
481 if (seg
!= FS_TLS_SEL
)
483 return get_desc_base(&task
->thread
.tls_array
[FS_TLS
]);
485 case offsetof(struct user_regs_struct
, gs_base
): {
487 * Exactly the same here as the %fs handling above.
489 unsigned int seg
= task
->thread
.gsindex
;
490 if (task
->thread
.gs
!= 0)
491 return task
->thread
.gs
;
493 asm("movl %%gs,%0" : "=r" (seg
));
494 if (seg
!= GS_TLS_SEL
)
496 return get_desc_base(&task
->thread
.tls_array
[GS_TLS
]);
501 return *pt_regs_access(task_pt_regs(task
), offset
);
504 static int genregs_get(struct task_struct
*target
,
505 const struct user_regset
*regset
,
506 unsigned int pos
, unsigned int count
,
507 void *kbuf
, void __user
*ubuf
)
510 unsigned long *k
= kbuf
;
511 while (count
>= sizeof(*k
)) {
512 *k
++ = getreg(target
, pos
);
517 unsigned long __user
*u
= ubuf
;
518 while (count
>= sizeof(*u
)) {
519 if (__put_user(getreg(target
, pos
), u
++))
529 static int genregs_set(struct task_struct
*target
,
530 const struct user_regset
*regset
,
531 unsigned int pos
, unsigned int count
,
532 const void *kbuf
, const void __user
*ubuf
)
536 const unsigned long *k
= kbuf
;
537 while (count
>= sizeof(*k
) && !ret
) {
538 ret
= putreg(target
, pos
, *k
++);
543 const unsigned long __user
*u
= ubuf
;
544 while (count
>= sizeof(*u
) && !ret
) {
546 ret
= __get_user(word
, u
++);
549 ret
= putreg(target
, pos
, word
);
557 static void ptrace_triggered(struct perf_event
*bp
,
558 struct perf_sample_data
*data
,
559 struct pt_regs
*regs
)
562 struct thread_struct
*thread
= &(current
->thread
);
565 * Store in the virtual DR6 register the fact that the breakpoint
566 * was hit so the thread's debugger will see it.
568 for (i
= 0; i
< HBP_NUM
; i
++) {
569 if (thread
->ptrace_bps
[i
] == bp
)
573 thread
->debugreg6
|= (DR_TRAP0
<< i
);
577 * Walk through every ptrace breakpoints for this thread and
578 * build the dr7 value on top of their attributes.
581 static unsigned long ptrace_get_dr7(struct perf_event
*bp
[])
585 struct arch_hw_breakpoint
*info
;
587 for (i
= 0; i
< HBP_NUM
; i
++) {
588 if (bp
[i
] && !bp
[i
]->attr
.disabled
) {
589 info
= counter_arch_bp(bp
[i
]);
590 dr7
|= encode_dr7(i
, info
->len
, info
->type
);
597 static int ptrace_fill_bp_fields(struct perf_event_attr
*attr
,
598 int len
, int type
, bool disabled
)
600 int err
, bp_len
, bp_type
;
602 err
= arch_bp_generic_fields(len
, type
, &bp_len
, &bp_type
);
604 attr
->bp_len
= bp_len
;
605 attr
->bp_type
= bp_type
;
606 attr
->disabled
= disabled
;
612 static struct perf_event
*
613 ptrace_register_breakpoint(struct task_struct
*tsk
, int len
, int type
,
614 unsigned long addr
, bool disabled
)
616 struct perf_event_attr attr
;
619 ptrace_breakpoint_init(&attr
);
622 err
= ptrace_fill_bp_fields(&attr
, len
, type
, disabled
);
626 return register_user_hw_breakpoint(&attr
, ptrace_triggered
,
630 static int ptrace_modify_breakpoint(struct perf_event
*bp
, int len
, int type
,
633 struct perf_event_attr attr
= bp
->attr
;
636 err
= ptrace_fill_bp_fields(&attr
, len
, type
, disabled
);
640 return modify_user_hw_breakpoint(bp
, &attr
);
644 * Handle ptrace writes to debug register 7.
646 static int ptrace_write_dr7(struct task_struct
*tsk
, unsigned long data
)
648 struct thread_struct
*thread
= &tsk
->thread
;
649 unsigned long old_dr7
;
650 bool second_pass
= false;
653 data
&= ~DR_CONTROL_RESERVED
;
654 old_dr7
= ptrace_get_dr7(thread
->ptrace_bps
);
658 for (i
= 0; i
< HBP_NUM
; i
++) {
660 bool disabled
= !decode_dr7(data
, i
, &len
, &type
);
661 struct perf_event
*bp
= thread
->ptrace_bps
[i
];
667 bp
= ptrace_register_breakpoint(tsk
,
668 len
, type
, 0, disabled
);
674 thread
->ptrace_bps
[i
] = bp
;
678 rc
= ptrace_modify_breakpoint(bp
, len
, type
, disabled
);
683 /* Restore if the first pass failed, second_pass shouldn't fail. */
684 if (rc
&& !WARN_ON(second_pass
)) {
695 * Handle PTRACE_PEEKUSR calls for the debug register area.
697 static unsigned long ptrace_get_debugreg(struct task_struct
*tsk
, int n
)
699 struct thread_struct
*thread
= &tsk
->thread
;
700 unsigned long val
= 0;
703 struct perf_event
*bp
= thread
->ptrace_bps
[n
];
706 val
= bp
->hw
.info
.address
;
708 val
= thread
->debugreg6
;
710 val
= thread
->ptrace_dr7
;
715 static int ptrace_set_breakpoint_addr(struct task_struct
*tsk
, int nr
,
718 struct thread_struct
*t
= &tsk
->thread
;
719 struct perf_event
*bp
= t
->ptrace_bps
[nr
];
724 * Put stub len and type to create an inactive but correct bp.
726 * CHECKME: the previous code returned -EIO if the addr wasn't
727 * a valid task virtual addr. The new one will return -EINVAL in
729 * -EINVAL may be what we want for in-kernel breakpoints users,
730 * but -EIO looks better for ptrace, since we refuse a register
731 * writing for the user. And anyway this is the previous
734 bp
= ptrace_register_breakpoint(tsk
,
735 X86_BREAKPOINT_LEN_1
, X86_BREAKPOINT_WRITE
,
740 t
->ptrace_bps
[nr
] = bp
;
742 struct perf_event_attr attr
= bp
->attr
;
745 err
= modify_user_hw_breakpoint(bp
, &attr
);
752 * Handle PTRACE_POKEUSR calls for the debug register area.
754 static int ptrace_set_debugreg(struct task_struct
*tsk
, int n
,
757 struct thread_struct
*thread
= &tsk
->thread
;
758 /* There are no DR4 or DR5 registers */
762 rc
= ptrace_set_breakpoint_addr(tsk
, n
, val
);
764 thread
->debugreg6
= val
;
767 rc
= ptrace_write_dr7(tsk
, val
);
769 thread
->ptrace_dr7
= val
;
775 * These access the current or another (stopped) task's io permission
776 * bitmap for debugging or core dump.
778 static int ioperm_active(struct task_struct
*target
,
779 const struct user_regset
*regset
)
781 return target
->thread
.io_bitmap_max
/ regset
->size
;
784 static int ioperm_get(struct task_struct
*target
,
785 const struct user_regset
*regset
,
786 unsigned int pos
, unsigned int count
,
787 void *kbuf
, void __user
*ubuf
)
789 if (!target
->thread
.io_bitmap_ptr
)
792 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
793 target
->thread
.io_bitmap_ptr
,
798 * Called by kernel/ptrace.c when detaching..
800 * Make sure the single step bit is not set.
802 void ptrace_disable(struct task_struct
*child
)
804 user_disable_single_step(child
);
805 #ifdef TIF_SYSCALL_EMU
806 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
810 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
811 static const struct user_regset_view user_x86_32_view
; /* Initialized below. */
814 long arch_ptrace(struct task_struct
*child
, long request
,
815 unsigned long addr
, unsigned long data
)
818 unsigned long __user
*datap
= (unsigned long __user
*)data
;
821 /* read the word at location addr in the USER area. */
822 case PTRACE_PEEKUSR
: {
826 if ((addr
& (sizeof(data
) - 1)) || addr
>= sizeof(struct user
))
829 tmp
= 0; /* Default return condition */
830 if (addr
< sizeof(struct user_regs_struct
))
831 tmp
= getreg(child
, addr
);
832 else if (addr
>= offsetof(struct user
, u_debugreg
[0]) &&
833 addr
<= offsetof(struct user
, u_debugreg
[7])) {
834 addr
-= offsetof(struct user
, u_debugreg
[0]);
835 tmp
= ptrace_get_debugreg(child
, addr
/ sizeof(data
));
837 ret
= put_user(tmp
, datap
);
841 case PTRACE_POKEUSR
: /* write the word at location addr in the USER area */
843 if ((addr
& (sizeof(data
) - 1)) || addr
>= sizeof(struct user
))
846 if (addr
< sizeof(struct user_regs_struct
))
847 ret
= putreg(child
, addr
, data
);
848 else if (addr
>= offsetof(struct user
, u_debugreg
[0]) &&
849 addr
<= offsetof(struct user
, u_debugreg
[7])) {
850 addr
-= offsetof(struct user
, u_debugreg
[0]);
851 ret
= ptrace_set_debugreg(child
,
852 addr
/ sizeof(data
), data
);
856 case PTRACE_GETREGS
: /* Get all gp regs from the child. */
857 return copy_regset_to_user(child
,
858 task_user_regset_view(current
),
860 0, sizeof(struct user_regs_struct
),
863 case PTRACE_SETREGS
: /* Set all gp regs in the child. */
864 return copy_regset_from_user(child
,
865 task_user_regset_view(current
),
867 0, sizeof(struct user_regs_struct
),
870 case PTRACE_GETFPREGS
: /* Get the child FPU state. */
871 return copy_regset_to_user(child
,
872 task_user_regset_view(current
),
874 0, sizeof(struct user_i387_struct
),
877 case PTRACE_SETFPREGS
: /* Set the child FPU state. */
878 return copy_regset_from_user(child
,
879 task_user_regset_view(current
),
881 0, sizeof(struct user_i387_struct
),
885 case PTRACE_GETFPXREGS
: /* Get the child extended FPU state. */
886 return copy_regset_to_user(child
, &user_x86_32_view
,
888 0, sizeof(struct user_fxsr_struct
),
891 case PTRACE_SETFPXREGS
: /* Set the child extended FPU state. */
892 return copy_regset_from_user(child
, &user_x86_32_view
,
894 0, sizeof(struct user_fxsr_struct
),
898 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
899 case PTRACE_GET_THREAD_AREA
:
902 ret
= do_get_thread_area(child
, addr
,
903 (struct user_desc __user
*)data
);
906 case PTRACE_SET_THREAD_AREA
:
909 ret
= do_set_thread_area(child
, addr
,
910 (struct user_desc __user
*)data
, 0);
915 /* normal 64bit interface to access TLS data.
916 Works just like arch_prctl, except that the arguments
918 case PTRACE_ARCH_PRCTL
:
919 ret
= do_arch_prctl(child
, data
, addr
);
924 ret
= ptrace_request(child
, request
, addr
, data
);
931 #ifdef CONFIG_IA32_EMULATION
933 #include <linux/compat.h>
934 #include <linux/syscalls.h>
935 #include <asm/ia32.h>
936 #include <asm/user32.h>
939 case offsetof(struct user32, regs.l): \
940 regs->q = value; break
943 case offsetof(struct user32, regs.rs): \
944 return set_segment_reg(child, \
945 offsetof(struct user_regs_struct, rs), \
949 static int putreg32(struct task_struct
*child
, unsigned regno
, u32 value
)
951 struct pt_regs
*regs
= task_pt_regs(child
);
972 case offsetof(struct user32
, regs
.orig_eax
):
974 * A 32-bit debugger setting orig_eax means to restore
975 * the state of the task restarting a 32-bit syscall.
976 * Make sure we interpret the -ERESTART* codes correctly
977 * in case the task is not actually still sitting at the
978 * exit from a 32-bit syscall with TS_COMPAT still set.
980 regs
->orig_ax
= value
;
981 if (syscall_get_nr(child
, regs
) >= 0)
982 task_thread_info(child
)->status
|= TS_COMPAT
;
985 case offsetof(struct user32
, regs
.eflags
):
986 return set_flags(child
, value
);
988 case offsetof(struct user32
, u_debugreg
[0]) ...
989 offsetof(struct user32
, u_debugreg
[7]):
990 regno
-= offsetof(struct user32
, u_debugreg
[0]);
991 return ptrace_set_debugreg(child
, regno
/ 4, value
);
994 if (regno
> sizeof(struct user32
) || (regno
& 3))
998 * Other dummy fields in the virtual user structure
1010 case offsetof(struct user32, regs.l): \
1011 *val = regs->q; break
1014 case offsetof(struct user32, regs.rs): \
1015 *val = get_segment_reg(child, \
1016 offsetof(struct user_regs_struct, rs)); \
1019 static int getreg32(struct task_struct
*child
, unsigned regno
, u32
*val
)
1021 struct pt_regs
*regs
= task_pt_regs(child
);
1039 R32(orig_eax
, orig_ax
);
1043 case offsetof(struct user32
, regs
.eflags
):
1044 *val
= get_flags(child
);
1047 case offsetof(struct user32
, u_debugreg
[0]) ...
1048 offsetof(struct user32
, u_debugreg
[7]):
1049 regno
-= offsetof(struct user32
, u_debugreg
[0]);
1050 *val
= ptrace_get_debugreg(child
, regno
/ 4);
1054 if (regno
> sizeof(struct user32
) || (regno
& 3))
1058 * Other dummy fields in the virtual user structure
1070 static int genregs32_get(struct task_struct
*target
,
1071 const struct user_regset
*regset
,
1072 unsigned int pos
, unsigned int count
,
1073 void *kbuf
, void __user
*ubuf
)
1076 compat_ulong_t
*k
= kbuf
;
1077 while (count
>= sizeof(*k
)) {
1078 getreg32(target
, pos
, k
++);
1079 count
-= sizeof(*k
);
1083 compat_ulong_t __user
*u
= ubuf
;
1084 while (count
>= sizeof(*u
)) {
1085 compat_ulong_t word
;
1086 getreg32(target
, pos
, &word
);
1087 if (__put_user(word
, u
++))
1089 count
-= sizeof(*u
);
1097 static int genregs32_set(struct task_struct
*target
,
1098 const struct user_regset
*regset
,
1099 unsigned int pos
, unsigned int count
,
1100 const void *kbuf
, const void __user
*ubuf
)
1104 const compat_ulong_t
*k
= kbuf
;
1105 while (count
>= sizeof(*k
) && !ret
) {
1106 ret
= putreg32(target
, pos
, *k
++);
1107 count
-= sizeof(*k
);
1111 const compat_ulong_t __user
*u
= ubuf
;
1112 while (count
>= sizeof(*u
) && !ret
) {
1113 compat_ulong_t word
;
1114 ret
= __get_user(word
, u
++);
1117 ret
= putreg32(target
, pos
, word
);
1118 count
-= sizeof(*u
);
1125 #ifdef CONFIG_X86_X32_ABI
1126 static long x32_arch_ptrace(struct task_struct
*child
,
1127 compat_long_t request
, compat_ulong_t caddr
,
1128 compat_ulong_t cdata
)
1130 unsigned long addr
= caddr
;
1131 unsigned long data
= cdata
;
1132 void __user
*datap
= compat_ptr(data
);
1136 /* Read 32bits at location addr in the USER area. Only allow
1137 to return the lower 32bits of segment and debug registers. */
1138 case PTRACE_PEEKUSR
: {
1142 if ((addr
& (sizeof(data
) - 1)) || addr
>= sizeof(struct user
) ||
1143 addr
< offsetof(struct user_regs_struct
, cs
))
1146 tmp
= 0; /* Default return condition */
1147 if (addr
< sizeof(struct user_regs_struct
))
1148 tmp
= getreg(child
, addr
);
1149 else if (addr
>= offsetof(struct user
, u_debugreg
[0]) &&
1150 addr
<= offsetof(struct user
, u_debugreg
[7])) {
1151 addr
-= offsetof(struct user
, u_debugreg
[0]);
1152 tmp
= ptrace_get_debugreg(child
, addr
/ sizeof(data
));
1154 ret
= put_user(tmp
, (__u32 __user
*)datap
);
1158 /* Write the word at location addr in the USER area. Only allow
1159 to update segment and debug registers with the upper 32bits
1161 case PTRACE_POKEUSR
:
1163 if ((addr
& (sizeof(data
) - 1)) || addr
>= sizeof(struct user
) ||
1164 addr
< offsetof(struct user_regs_struct
, cs
))
1167 if (addr
< sizeof(struct user_regs_struct
))
1168 ret
= putreg(child
, addr
, data
);
1169 else if (addr
>= offsetof(struct user
, u_debugreg
[0]) &&
1170 addr
<= offsetof(struct user
, u_debugreg
[7])) {
1171 addr
-= offsetof(struct user
, u_debugreg
[0]);
1172 ret
= ptrace_set_debugreg(child
,
1173 addr
/ sizeof(data
), data
);
1177 case PTRACE_GETREGS
: /* Get all gp regs from the child. */
1178 return copy_regset_to_user(child
,
1179 task_user_regset_view(current
),
1181 0, sizeof(struct user_regs_struct
),
1184 case PTRACE_SETREGS
: /* Set all gp regs in the child. */
1185 return copy_regset_from_user(child
,
1186 task_user_regset_view(current
),
1188 0, sizeof(struct user_regs_struct
),
1191 case PTRACE_GETFPREGS
: /* Get the child FPU state. */
1192 return copy_regset_to_user(child
,
1193 task_user_regset_view(current
),
1195 0, sizeof(struct user_i387_struct
),
1198 case PTRACE_SETFPREGS
: /* Set the child FPU state. */
1199 return copy_regset_from_user(child
,
1200 task_user_regset_view(current
),
1202 0, sizeof(struct user_i387_struct
),
1206 return compat_ptrace_request(child
, request
, addr
, data
);
1213 long compat_arch_ptrace(struct task_struct
*child
, compat_long_t request
,
1214 compat_ulong_t caddr
, compat_ulong_t cdata
)
1216 unsigned long addr
= caddr
;
1217 unsigned long data
= cdata
;
1218 void __user
*datap
= compat_ptr(data
);
1222 #ifdef CONFIG_X86_X32_ABI
1223 if (!is_ia32_task())
1224 return x32_arch_ptrace(child
, request
, caddr
, cdata
);
1228 case PTRACE_PEEKUSR
:
1229 ret
= getreg32(child
, addr
, &val
);
1231 ret
= put_user(val
, (__u32 __user
*)datap
);
1234 case PTRACE_POKEUSR
:
1235 ret
= putreg32(child
, addr
, data
);
1238 case PTRACE_GETREGS
: /* Get all gp regs from the child. */
1239 return copy_regset_to_user(child
, &user_x86_32_view
,
1241 0, sizeof(struct user_regs_struct32
),
1244 case PTRACE_SETREGS
: /* Set all gp regs in the child. */
1245 return copy_regset_from_user(child
, &user_x86_32_view
,
1247 sizeof(struct user_regs_struct32
),
1250 case PTRACE_GETFPREGS
: /* Get the child FPU state. */
1251 return copy_regset_to_user(child
, &user_x86_32_view
,
1253 sizeof(struct user_i387_ia32_struct
),
1256 case PTRACE_SETFPREGS
: /* Set the child FPU state. */
1257 return copy_regset_from_user(
1258 child
, &user_x86_32_view
, REGSET_FP
,
1259 0, sizeof(struct user_i387_ia32_struct
), datap
);
1261 case PTRACE_GETFPXREGS
: /* Get the child extended FPU state. */
1262 return copy_regset_to_user(child
, &user_x86_32_view
,
1264 sizeof(struct user32_fxsr_struct
),
1267 case PTRACE_SETFPXREGS
: /* Set the child extended FPU state. */
1268 return copy_regset_from_user(child
, &user_x86_32_view
,
1270 sizeof(struct user32_fxsr_struct
),
1273 case PTRACE_GET_THREAD_AREA
:
1274 case PTRACE_SET_THREAD_AREA
:
1275 return arch_ptrace(child
, request
, addr
, data
);
1278 return compat_ptrace_request(child
, request
, addr
, data
);
1284 #endif /* CONFIG_IA32_EMULATION */
1286 #ifdef CONFIG_X86_64
1288 static struct user_regset x86_64_regsets
[] __read_mostly
= {
1289 [REGSET_GENERAL
] = {
1290 .core_note_type
= NT_PRSTATUS
,
1291 .n
= sizeof(struct user_regs_struct
) / sizeof(long),
1292 .size
= sizeof(long), .align
= sizeof(long),
1293 .get
= genregs_get
, .set
= genregs_set
1296 .core_note_type
= NT_PRFPREG
,
1297 .n
= sizeof(struct user_i387_struct
) / sizeof(long),
1298 .size
= sizeof(long), .align
= sizeof(long),
1299 .active
= xfpregs_active
, .get
= xfpregs_get
, .set
= xfpregs_set
1302 .core_note_type
= NT_X86_XSTATE
,
1303 .size
= sizeof(u64
), .align
= sizeof(u64
),
1304 .active
= xstateregs_active
, .get
= xstateregs_get
,
1305 .set
= xstateregs_set
1307 [REGSET_IOPERM64
] = {
1308 .core_note_type
= NT_386_IOPERM
,
1309 .n
= IO_BITMAP_LONGS
,
1310 .size
= sizeof(long), .align
= sizeof(long),
1311 .active
= ioperm_active
, .get
= ioperm_get
1315 static const struct user_regset_view user_x86_64_view
= {
1316 .name
= "x86_64", .e_machine
= EM_X86_64
,
1317 .regsets
= x86_64_regsets
, .n
= ARRAY_SIZE(x86_64_regsets
)
1320 #else /* CONFIG_X86_32 */
1322 #define user_regs_struct32 user_regs_struct
1323 #define genregs32_get genregs_get
1324 #define genregs32_set genregs_set
1326 #endif /* CONFIG_X86_64 */
1328 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
1329 static struct user_regset x86_32_regsets
[] __read_mostly
= {
1330 [REGSET_GENERAL
] = {
1331 .core_note_type
= NT_PRSTATUS
,
1332 .n
= sizeof(struct user_regs_struct32
) / sizeof(u32
),
1333 .size
= sizeof(u32
), .align
= sizeof(u32
),
1334 .get
= genregs32_get
, .set
= genregs32_set
1337 .core_note_type
= NT_PRFPREG
,
1338 .n
= sizeof(struct user_i387_ia32_struct
) / sizeof(u32
),
1339 .size
= sizeof(u32
), .align
= sizeof(u32
),
1340 .active
= fpregs_active
, .get
= fpregs_get
, .set
= fpregs_set
1343 .core_note_type
= NT_PRXFPREG
,
1344 .n
= sizeof(struct user32_fxsr_struct
) / sizeof(u32
),
1345 .size
= sizeof(u32
), .align
= sizeof(u32
),
1346 .active
= xfpregs_active
, .get
= xfpregs_get
, .set
= xfpregs_set
1349 .core_note_type
= NT_X86_XSTATE
,
1350 .size
= sizeof(u64
), .align
= sizeof(u64
),
1351 .active
= xstateregs_active
, .get
= xstateregs_get
,
1352 .set
= xstateregs_set
1355 .core_note_type
= NT_386_TLS
,
1356 .n
= GDT_ENTRY_TLS_ENTRIES
, .bias
= GDT_ENTRY_TLS_MIN
,
1357 .size
= sizeof(struct user_desc
),
1358 .align
= sizeof(struct user_desc
),
1359 .active
= regset_tls_active
,
1360 .get
= regset_tls_get
, .set
= regset_tls_set
1362 [REGSET_IOPERM32
] = {
1363 .core_note_type
= NT_386_IOPERM
,
1364 .n
= IO_BITMAP_BYTES
/ sizeof(u32
),
1365 .size
= sizeof(u32
), .align
= sizeof(u32
),
1366 .active
= ioperm_active
, .get
= ioperm_get
1370 static const struct user_regset_view user_x86_32_view
= {
1371 .name
= "i386", .e_machine
= EM_386
,
1372 .regsets
= x86_32_regsets
, .n
= ARRAY_SIZE(x86_32_regsets
)
1377 * This represents bytes 464..511 in the memory layout exported through
1378 * the REGSET_XSTATE interface.
1380 u64 xstate_fx_sw_bytes
[USER_XSTATE_FX_SW_WORDS
];
1382 void update_regset_xstate_info(unsigned int size
, u64 xstate_mask
)
1384 #ifdef CONFIG_X86_64
1385 x86_64_regsets
[REGSET_XSTATE
].n
= size
/ sizeof(u64
);
1387 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
1388 x86_32_regsets
[REGSET_XSTATE
].n
= size
/ sizeof(u64
);
1390 xstate_fx_sw_bytes
[USER_XSTATE_XCR0_WORD
] = xstate_mask
;
1393 const struct user_regset_view
*task_user_regset_view(struct task_struct
*task
)
1395 #ifdef CONFIG_IA32_EMULATION
1396 if (test_tsk_thread_flag(task
, TIF_IA32
))
1398 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
1399 return &user_x86_32_view
;
1401 #ifdef CONFIG_X86_64
1402 return &user_x86_64_view
;
1406 static void fill_sigtrap_info(struct task_struct
*tsk
,
1407 struct pt_regs
*regs
,
1408 int error_code
, int si_code
,
1409 struct siginfo
*info
)
1411 tsk
->thread
.trap_nr
= X86_TRAP_DB
;
1412 tsk
->thread
.error_code
= error_code
;
1414 memset(info
, 0, sizeof(*info
));
1415 info
->si_signo
= SIGTRAP
;
1416 info
->si_code
= si_code
;
1417 info
->si_addr
= user_mode(regs
) ? (void __user
*)regs
->ip
: NULL
;
1420 void user_single_step_siginfo(struct task_struct
*tsk
,
1421 struct pt_regs
*regs
,
1422 struct siginfo
*info
)
1424 fill_sigtrap_info(tsk
, regs
, 0, TRAP_BRKPT
, info
);
1427 void send_sigtrap(struct task_struct
*tsk
, struct pt_regs
*regs
,
1428 int error_code
, int si_code
)
1430 struct siginfo info
;
1432 fill_sigtrap_info(tsk
, regs
, error_code
, si_code
, &info
);
1433 /* Send us the fake SIGTRAP */
1434 force_sig_info(SIGTRAP
, &info
, tsk
);
1437 static void do_audit_syscall_entry(struct pt_regs
*regs
, u32 arch
)
1439 #ifdef CONFIG_X86_64
1440 if (arch
== AUDIT_ARCH_X86_64
) {
1441 audit_syscall_entry(regs
->orig_ax
, regs
->di
,
1442 regs
->si
, regs
->dx
, regs
->r10
);
1446 audit_syscall_entry(regs
->orig_ax
, regs
->bx
,
1447 regs
->cx
, regs
->dx
, regs
->si
);
1452 * We can return 0 to resume the syscall or anything else to go to phase
1453 * 2. If we resume the syscall, we need to put something appropriate in
1456 * NB: We don't have full pt_regs here, but regs->orig_ax and regs->ax
1457 * are fully functional.
1459 * For phase 2's benefit, our return value is:
1460 * 0: resume the syscall
1461 * 1: go to phase 2; no seccomp phase 2 needed
1462 * anything else: go to phase 2; pass return value to seccomp
1464 unsigned long syscall_trace_enter_phase1(struct pt_regs
*regs
, u32 arch
)
1466 unsigned long ret
= 0;
1469 BUG_ON(regs
!= task_pt_regs(current
));
1471 work
= ACCESS_ONCE(current_thread_info()->flags
) &
1472 _TIF_WORK_SYSCALL_ENTRY
;
1475 * If TIF_NOHZ is set, we are required to call user_exit() before
1476 * doing anything that could touch RCU.
1478 if (work
& _TIF_NOHZ
) {
1483 #ifdef CONFIG_SECCOMP
1485 * Do seccomp first -- it should minimize exposure of other
1486 * code, and keeping seccomp fast is probably more valuable
1487 * than the rest of this.
1489 if (work
& _TIF_SECCOMP
) {
1490 struct seccomp_data sd
;
1493 sd
.nr
= regs
->orig_ax
;
1494 sd
.instruction_pointer
= regs
->ip
;
1495 #ifdef CONFIG_X86_64
1496 if (arch
== AUDIT_ARCH_X86_64
) {
1497 sd
.args
[0] = regs
->di
;
1498 sd
.args
[1] = regs
->si
;
1499 sd
.args
[2] = regs
->dx
;
1500 sd
.args
[3] = regs
->r10
;
1501 sd
.args
[4] = regs
->r8
;
1502 sd
.args
[5] = regs
->r9
;
1506 sd
.args
[0] = regs
->bx
;
1507 sd
.args
[1] = regs
->cx
;
1508 sd
.args
[2] = regs
->dx
;
1509 sd
.args
[3] = regs
->si
;
1510 sd
.args
[4] = regs
->di
;
1511 sd
.args
[5] = regs
->bp
;
1514 BUILD_BUG_ON(SECCOMP_PHASE1_OK
!= 0);
1515 BUILD_BUG_ON(SECCOMP_PHASE1_SKIP
!= 1);
1517 ret
= seccomp_phase1(&sd
);
1518 if (ret
== SECCOMP_PHASE1_SKIP
) {
1521 } else if (ret
!= SECCOMP_PHASE1_OK
) {
1522 return ret
; /* Go directly to phase 2 */
1525 work
&= ~_TIF_SECCOMP
;
1529 /* Do our best to finish without phase 2. */
1531 return ret
; /* seccomp and/or nohz only (ret == 0 here) */
1533 #ifdef CONFIG_AUDITSYSCALL
1534 if (work
== _TIF_SYSCALL_AUDIT
) {
1536 * If there is no more work to be done except auditing,
1537 * then audit in phase 1. Phase 2 always audits, so, if
1538 * we audit here, then we can't go on to phase 2.
1540 do_audit_syscall_entry(regs
, arch
);
1545 return 1; /* Something is enabled that we can't handle in phase 1 */
1548 /* Returns the syscall nr to run (which should match regs->orig_ax). */
1549 long syscall_trace_enter_phase2(struct pt_regs
*regs
, u32 arch
,
1550 unsigned long phase1_result
)
1553 u32 work
= ACCESS_ONCE(current_thread_info()->flags
) &
1554 _TIF_WORK_SYSCALL_ENTRY
;
1556 BUG_ON(regs
!= task_pt_regs(current
));
1559 * If we stepped into a sysenter/syscall insn, it trapped in
1560 * kernel mode; do_debug() cleared TF and set TIF_SINGLESTEP.
1561 * If user-mode had set TF itself, then it's still clear from
1562 * do_debug() and we need to set it again to restore the user
1563 * state. If we entered on the slow path, TF was already set.
1565 if (work
& _TIF_SINGLESTEP
)
1566 regs
->flags
|= X86_EFLAGS_TF
;
1568 #ifdef CONFIG_SECCOMP
1570 * Call seccomp_phase2 before running the other hooks so that
1571 * they can see any changes made by a seccomp tracer.
1573 if (phase1_result
> 1 && seccomp_phase2(phase1_result
)) {
1574 /* seccomp failures shouldn't expose any additional code. */
1579 if (unlikely(work
& _TIF_SYSCALL_EMU
))
1582 if ((ret
|| test_thread_flag(TIF_SYSCALL_TRACE
)) &&
1583 tracehook_report_syscall_entry(regs
))
1586 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
1587 trace_sys_enter(regs
, regs
->orig_ax
);
1589 do_audit_syscall_entry(regs
, arch
);
1591 return ret
?: regs
->orig_ax
;
1594 long syscall_trace_enter(struct pt_regs
*regs
)
1596 u32 arch
= is_ia32_task() ? AUDIT_ARCH_I386
: AUDIT_ARCH_X86_64
;
1597 unsigned long phase1_result
= syscall_trace_enter_phase1(regs
, arch
);
1599 if (phase1_result
== 0)
1600 return regs
->orig_ax
;
1602 return syscall_trace_enter_phase2(regs
, arch
, phase1_result
);
1605 void syscall_trace_leave(struct pt_regs
*regs
)
1610 * We may come here right after calling schedule_user()
1611 * or do_notify_resume(), in which case we can be in RCU
1616 audit_syscall_exit(regs
);
1618 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
1619 trace_sys_exit(regs
, regs
->ax
);
1622 * If TIF_SYSCALL_EMU is set, we only get here because of
1623 * TIF_SINGLESTEP (i.e. this is PTRACE_SYSEMU_SINGLESTEP).
1624 * We already reported this syscall instruction in
1625 * syscall_trace_enter().
1627 step
= unlikely(test_thread_flag(TIF_SINGLESTEP
)) &&
1628 !test_thread_flag(TIF_SYSCALL_EMU
);
1629 if (step
|| test_thread_flag(TIF_SYSCALL_TRACE
))
1630 tracehook_report_syscall_exit(regs
, step
);