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/ptrace.h>
13 #include <linux/user.h>
14 #include <linux/security.h>
15 #include <linux/audit.h>
16 #include <linux/seccomp.h>
17 #include <linux/signal.h>
19 #include <asm/uaccess.h>
20 #include <asm/pgtable.h>
21 #include <asm/system.h>
22 #include <asm/processor.h>
24 #include <asm/debugreg.h>
29 * does not yet catch signals sent when the child dies.
30 * in exit.c or in signal.c.
34 * Determines which flags the user has access to [1 = access, 0 = no access].
35 * Prohibits changing ID(21), VIP(20), VIF(19), VM(17), NT(14), IOPL(12-13), IF(9).
36 * Also masks reserved bits (31-22, 15, 5, 3, 1).
38 #define FLAG_MASK 0x00050dd5
40 static long *pt_regs_access(struct pt_regs
*regs
, unsigned long regno
)
42 BUILD_BUG_ON(offsetof(struct pt_regs
, bx
) != 0);
45 return ®s
->bx
+ regno
;
48 static int putreg(struct task_struct
*child
,
49 unsigned long regno
, unsigned long value
)
51 struct pt_regs
*regs
= task_pt_regs(child
);
55 if (value
&& (value
& 3) != 3)
57 child
->thread
.gs
= value
;
62 if (value
&& (value
& 3) != 3)
75 * If the user value contains TF, mark that
76 * it was not "us" (the debugger) that set it.
77 * If not, make sure it stays set if we had.
79 if (value
& X86_EFLAGS_TF
)
80 clear_tsk_thread_flag(child
, TIF_FORCED_TF
);
81 else if (test_tsk_thread_flag(child
, TIF_FORCED_TF
))
82 value
|= X86_EFLAGS_TF
;
83 value
|= regs
->flags
& ~FLAG_MASK
;
86 *pt_regs_access(regs
, regno
) = value
;
90 static unsigned long getreg(struct task_struct
*child
, unsigned long regno
)
92 struct pt_regs
*regs
= task_pt_regs(child
);
93 unsigned long retval
= ~0UL;
99 * If the debugger set TF, hide it from the readout.
101 retval
= regs
->flags
;
102 if (test_tsk_thread_flag(child
, TIF_FORCED_TF
))
103 retval
&= ~X86_EFLAGS_TF
;
106 retval
= child
->thread
.gs
;
116 retval
&= *pt_regs_access(regs
, regno
);
122 * This function is trivial and will be inlined by the compiler.
123 * Having it separates the implementation details of debug
124 * registers from the interface details of ptrace.
126 static unsigned long ptrace_get_debugreg(struct task_struct
*child
, int n
)
128 return child
->thread
.debugreg
[n
];
131 static int ptrace_set_debugreg(struct task_struct
*child
,
132 int n
, unsigned long data
)
134 if (unlikely(n
== 4 || n
== 5))
137 if (n
< 4 && unlikely(data
>= TASK_SIZE
- 3))
142 * Sanity-check data. Take one half-byte at once with
143 * check = (val >> (16 + 4*i)) & 0xf. It contains the
144 * R/Wi and LENi bits; bits 0 and 1 are R/Wi, and bits
145 * 2 and 3 are LENi. Given a list of invalid values,
146 * we do mask |= 1 << invalid_value, so that
147 * (mask >> check) & 1 is a correct test for invalid
150 * R/Wi contains the type of the breakpoint /
151 * watchpoint, LENi contains the length of the watched
152 * data in the watchpoint case.
154 * The invalid values are:
155 * - LENi == 0x10 (undefined), so mask |= 0x0f00.
156 * - R/Wi == 0x10 (break on I/O reads or writes), so
158 * - R/Wi == 0x00 && LENi != 0x00, so we have mask |=
161 * Finally, mask = 0x0f00 | 0x4444 | 0x1110 == 0x5f54.
163 * See the Intel Manual "System Programming Guide",
166 * Note that LENi == 0x10 is defined on x86_64 in long
167 * mode (i.e. even for 32-bit userspace software, but
168 * 64-bit kernel), so the x86_64 mask value is 0x5454.
169 * See the AMD manual no. 24593 (AMD64 System Programming)
172 data
&= ~DR_CONTROL_RESERVED
;
173 for (i
= 0; i
< 4; i
++)
174 if ((0x5f54 >> ((data
>> (16 + 4*i
)) & 0xf)) & 1)
177 set_tsk_thread_flag(child
, TIF_DEBUG
);
179 clear_tsk_thread_flag(child
, TIF_DEBUG
);
182 child
->thread
.debugreg
[n
] = data
;
188 * Called by kernel/ptrace.c when detaching..
190 * Make sure the single step bit is not set.
192 void ptrace_disable(struct task_struct
*child
)
194 user_disable_single_step(child
);
195 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
198 long arch_ptrace(struct task_struct
*child
, long request
, long addr
, long data
)
200 struct user
* dummy
= NULL
;
202 unsigned long __user
*datap
= (unsigned long __user
*)data
;
205 /* when I and D space are separate, these will need to be fixed. */
206 case PTRACE_PEEKTEXT
: /* read word at location addr. */
207 case PTRACE_PEEKDATA
:
208 ret
= generic_ptrace_peekdata(child
, addr
, data
);
211 /* read the word at location addr in the USER area. */
212 case PTRACE_PEEKUSR
: {
216 if ((addr
& 3) || addr
< 0 ||
217 addr
> sizeof(struct user
) - 3)
220 tmp
= 0; /* Default return condition */
221 if(addr
< FRAME_SIZE
*sizeof(long))
222 tmp
= getreg(child
, addr
);
223 if(addr
>= (long) &dummy
->u_debugreg
[0] &&
224 addr
<= (long) &dummy
->u_debugreg
[7]){
225 addr
-= (long) &dummy
->u_debugreg
[0];
227 tmp
= ptrace_get_debugreg(child
, addr
);
229 ret
= put_user(tmp
, datap
);
233 /* when I and D space are separate, this will have to be fixed. */
234 case PTRACE_POKETEXT
: /* write the word at location addr. */
235 case PTRACE_POKEDATA
:
236 ret
= generic_ptrace_pokedata(child
, addr
, data
);
239 case PTRACE_POKEUSR
: /* write the word at location addr in the USER area */
241 if ((addr
& 3) || addr
< 0 ||
242 addr
> sizeof(struct user
) - 3)
245 if (addr
< FRAME_SIZE
*sizeof(long)) {
246 ret
= putreg(child
, addr
, data
);
249 /* We need to be very careful here. We implicitly
250 want to modify a portion of the task_struct, and we
251 have to be selective about what portions we allow someone
255 if(addr
>= (long) &dummy
->u_debugreg
[0] &&
256 addr
<= (long) &dummy
->u_debugreg
[7]){
257 addr
-= (long) &dummy
->u_debugreg
;
259 ret
= ptrace_set_debugreg(child
, addr
, data
);
263 case PTRACE_GETREGS
: { /* Get all gp regs from the child. */
264 if (!access_ok(VERIFY_WRITE
, datap
, FRAME_SIZE
*sizeof(long))) {
268 for ( i
= 0; i
< FRAME_SIZE
*sizeof(long); i
+= sizeof(long) ) {
269 __put_user(getreg(child
, i
), datap
);
276 case PTRACE_SETREGS
: { /* Set all gp regs in the child. */
278 if (!access_ok(VERIFY_READ
, datap
, FRAME_SIZE
*sizeof(long))) {
282 for ( i
= 0; i
< FRAME_SIZE
*sizeof(long); i
+= sizeof(long) ) {
283 __get_user(tmp
, datap
);
284 putreg(child
, i
, tmp
);
291 case PTRACE_GETFPREGS
: { /* Get the child FPU state. */
292 if (!access_ok(VERIFY_WRITE
, datap
,
293 sizeof(struct user_i387_struct
))) {
298 if (!tsk_used_math(child
))
300 get_fpregs((struct user_i387_struct __user
*)data
, child
);
304 case PTRACE_SETFPREGS
: { /* Set the child FPU state. */
305 if (!access_ok(VERIFY_READ
, datap
,
306 sizeof(struct user_i387_struct
))) {
310 set_stopped_child_used_math(child
);
311 set_fpregs(child
, (struct user_i387_struct __user
*)data
);
316 case PTRACE_GETFPXREGS
: { /* Get the child extended FPU state. */
317 if (!access_ok(VERIFY_WRITE
, datap
,
318 sizeof(struct user_fxsr_struct
))) {
322 if (!tsk_used_math(child
))
324 ret
= get_fpxregs((struct user_fxsr_struct __user
*)data
, child
);
328 case PTRACE_SETFPXREGS
: { /* Set the child extended FPU state. */
329 if (!access_ok(VERIFY_READ
, datap
,
330 sizeof(struct user_fxsr_struct
))) {
334 set_stopped_child_used_math(child
);
335 ret
= set_fpxregs(child
, (struct user_fxsr_struct __user
*)data
);
339 case PTRACE_GET_THREAD_AREA
:
342 ret
= do_get_thread_area(child
, addr
,
343 (struct user_desc __user
*) data
);
346 case PTRACE_SET_THREAD_AREA
:
349 ret
= do_set_thread_area(child
, addr
,
350 (struct user_desc __user
*) data
, 0);
354 ret
= ptrace_request(child
, request
, addr
, data
);
361 void send_sigtrap(struct task_struct
*tsk
, struct pt_regs
*regs
, int error_code
)
365 tsk
->thread
.trap_no
= 1;
366 tsk
->thread
.error_code
= error_code
;
368 memset(&info
, 0, sizeof(info
));
369 info
.si_signo
= SIGTRAP
;
370 info
.si_code
= TRAP_BRKPT
;
373 info
.si_addr
= user_mode_vm(regs
) ? (void __user
*) regs
->ip
: NULL
;
375 /* Send us the fake SIGTRAP */
376 force_sig_info(SIGTRAP
, &info
, tsk
);
379 /* notification of system call entry/exit
380 * - triggered by current->work.syscall_trace
382 __attribute__((regparm(3)))
383 int do_syscall_trace(struct pt_regs
*regs
, int entryexit
)
385 int is_sysemu
= test_thread_flag(TIF_SYSCALL_EMU
);
387 * With TIF_SYSCALL_EMU set we want to ignore TIF_SINGLESTEP for syscall
390 int is_singlestep
= !is_sysemu
&& test_thread_flag(TIF_SINGLESTEP
);
393 /* do the secure computing check first */
395 secure_computing(regs
->orig_ax
);
397 if (unlikely(current
->audit_context
)) {
399 audit_syscall_exit(AUDITSC_RESULT(regs
->ax
),
401 /* Debug traps, when using PTRACE_SINGLESTEP, must be sent only
402 * on the syscall exit path. Normally, when TIF_SYSCALL_AUDIT is
403 * not used, entry.S will call us only on syscall exit, not
404 * entry; so when TIF_SYSCALL_AUDIT is used we must avoid
405 * calling send_sigtrap() on syscall entry.
407 * Note that when PTRACE_SYSEMU_SINGLESTEP is used,
408 * is_singlestep is false, despite his name, so we will still do
411 else if (is_singlestep
)
415 if (!(current
->ptrace
& PT_PTRACED
))
418 /* If a process stops on the 1st tracepoint with SYSCALL_TRACE
419 * and then is resumed with SYSEMU_SINGLESTEP, it will come in
420 * here. We have to check this and return */
421 if (is_sysemu
&& entryexit
)
424 /* Fake a debug trap */
426 send_sigtrap(current
, regs
, 0);
428 if (!test_thread_flag(TIF_SYSCALL_TRACE
) && !is_sysemu
)
431 /* the 0x80 provides a way for the tracing parent to distinguish
432 between a syscall stop and SIGTRAP delivery */
433 /* Note that the debugger could change the result of test_thread_flag!*/
434 ptrace_notify(SIGTRAP
| ((current
->ptrace
& PT_TRACESYSGOOD
) ? 0x80:0));
437 * this isn't the same as continuing with a signal, but it will do
438 * for normal use. strace only continues with a signal if the
439 * stopping signal is not SIGTRAP. -brl
441 if (current
->exit_code
) {
442 send_sig(current
->exit_code
, current
, 1);
443 current
->exit_code
= 0;
447 if (unlikely(current
->audit_context
) && !entryexit
)
448 audit_syscall_entry(AUDIT_ARCH_I386
, regs
->orig_ax
,
449 regs
->bx
, regs
->cx
, regs
->dx
, regs
->si
);
453 regs
->orig_ax
= -1; /* force skip of syscall restarting */
454 if (unlikely(current
->audit_context
))
455 audit_syscall_exit(AUDITSC_RESULT(regs
->ax
), regs
->ax
);