2 /* By Ross Biro 1/23/92 */
4 * Pentium III FXSR, SSE support
5 * Gareth Hughes <gareth@valinux.com>, May 2000
8 #include <linux/kernel.h>
9 #include <linux/sched.h>
11 #include <linux/smp.h>
12 #include <linux/errno.h>
13 #include <linux/ptrace.h>
14 #include <linux/user.h>
15 #include <linux/security.h>
16 #include <linux/audit.h>
17 #include <linux/seccomp.h>
18 #include <linux/signal.h>
20 #include <asm/uaccess.h>
21 #include <asm/pgtable.h>
22 #include <asm/system.h>
23 #include <asm/processor.h>
25 #include <asm/debugreg.h>
30 * does not yet catch signals sent when the child dies.
31 * in exit.c or in signal.c.
35 * Determines which flags the user has access to [1 = access, 0 = no access].
36 * Prohibits changing ID(21), VIP(20), VIF(19), VM(17), NT(14), IOPL(12-13), IF(9).
37 * Also masks reserved bits (31-22, 15, 5, 3, 1).
39 #define FLAG_MASK 0x00050dd5
41 /* set's the trap flag. */
42 #define TRAP_FLAG 0x100
45 * Offset of eflags on child stack..
47 #define EFL_OFFSET offsetof(struct pt_regs, eflags)
49 static inline struct pt_regs
*get_child_regs(struct task_struct
*task
)
51 void *stack_top
= (void *)task
->thread
.esp0
;
52 return stack_top
- sizeof(struct pt_regs
);
56 * This routine will get a word off of the processes privileged stack.
57 * the offset is bytes into the pt_regs structure on the stack.
58 * This routine assumes that all the privileged stacks are in our
61 static inline int get_stack_long(struct task_struct
*task
, int offset
)
65 stack
= (unsigned char *)task
->thread
.esp0
- sizeof(struct pt_regs
);
67 return (*((int *)stack
));
71 * This routine will put a word on the processes privileged stack.
72 * the offset is bytes into the pt_regs structure on the stack.
73 * This routine assumes that all the privileged stacks are in our
76 static inline int put_stack_long(struct task_struct
*task
, int offset
,
79 unsigned char * stack
;
81 stack
= (unsigned char *)task
->thread
.esp0
- sizeof(struct pt_regs
);
83 *(unsigned long *) stack
= data
;
87 static int putreg(struct task_struct
*child
,
88 unsigned long regno
, unsigned long value
)
92 if (value
&& (value
& 3) != 3)
94 child
->thread
.gs
= value
;
99 if (value
&& (value
& 3) != 3)
105 if ((value
& 3) != 3)
111 value
|= get_stack_long(child
, EFL_OFFSET
) & ~FLAG_MASK
;
116 put_stack_long(child
, regno
, value
);
120 static unsigned long getreg(struct task_struct
*child
,
123 unsigned long retval
= ~0UL;
125 switch (regno
>> 2) {
127 retval
= child
->thread
.gs
;
139 retval
&= get_stack_long(child
, regno
);
144 #define LDT_SEGMENT 4
146 static unsigned long convert_eip_to_linear(struct task_struct
*child
, struct pt_regs
*regs
)
148 unsigned long addr
, seg
;
151 seg
= regs
->xcs
& 0xffff;
152 if (regs
->eflags
& VM_MASK
) {
153 addr
= (addr
& 0xffff) + (seg
<< 4);
158 * We'll assume that the code segments in the GDT
159 * are all zero-based. That is largely true: the
160 * TLS segments are used for data, and the PNPBIOS
161 * and APM bios ones we just ignore here.
163 if (seg
& LDT_SEGMENT
) {
169 down(&child
->mm
->context
.sem
);
170 if (unlikely((seg
>> 3) >= child
->mm
->context
.size
))
171 addr
= -1L; /* bogus selector, access would fault */
173 desc
= child
->mm
->context
.ldt
+ seg
;
174 base
= ((desc
[0] >> 16) |
175 ((desc
[1] & 0xff) << 16) |
176 (desc
[1] & 0xff000000));
178 /* 16-bit code segment? */
179 if (!((desc
[1] >> 22) & 1))
183 up(&child
->mm
->context
.sem
);
188 static inline int is_setting_trap_flag(struct task_struct
*child
, struct pt_regs
*regs
)
191 unsigned char opcode
[15];
192 unsigned long addr
= convert_eip_to_linear(child
, regs
);
194 copied
= access_process_vm(child
, addr
, opcode
, sizeof(opcode
), 0);
195 for (i
= 0; i
< copied
; i
++) {
198 case 0x9d: case 0xcf:
200 /* opcode and address size prefixes */
201 case 0x66: case 0x67:
203 /* irrelevant prefixes (segment overrides and repeats) */
204 case 0x26: case 0x2e:
205 case 0x36: case 0x3e:
206 case 0x64: case 0x65:
207 case 0xf0: case 0xf2: case 0xf3:
211 * pushf: NOTE! We should probably not let
212 * the user see the TF bit being set. But
213 * it's more pain than it's worth to avoid
214 * it, and a debugger could emulate this
215 * all in user space if it _really_ cares.
225 static void set_singlestep(struct task_struct
*child
)
227 struct pt_regs
*regs
= get_child_regs(child
);
230 * Always set TIF_SINGLESTEP - this guarantees that
231 * we single-step system calls etc.. This will also
232 * cause us to set TF when returning to user mode.
234 set_tsk_thread_flag(child
, TIF_SINGLESTEP
);
237 * If TF was already set, don't do anything else
239 if (regs
->eflags
& TRAP_FLAG
)
242 /* Set TF on the kernel stack.. */
243 regs
->eflags
|= TRAP_FLAG
;
246 * ..but if TF is changed by the instruction we will trace,
247 * don't mark it as being "us" that set it, so that we
248 * won't clear it by hand later.
250 if (is_setting_trap_flag(child
, regs
))
253 child
->ptrace
|= PT_DTRACE
;
256 static void clear_singlestep(struct task_struct
*child
)
258 /* Always clear TIF_SINGLESTEP... */
259 clear_tsk_thread_flag(child
, TIF_SINGLESTEP
);
261 /* But touch TF only if it was set by us.. */
262 if (child
->ptrace
& PT_DTRACE
) {
263 struct pt_regs
*regs
= get_child_regs(child
);
264 regs
->eflags
&= ~TRAP_FLAG
;
265 child
->ptrace
&= ~PT_DTRACE
;
270 * Called by kernel/ptrace.c when detaching..
272 * Make sure the single step bit is not set.
274 void ptrace_disable(struct task_struct
*child
)
276 clear_singlestep(child
);
277 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
278 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
282 * Perform get_thread_area on behalf of the traced child.
285 ptrace_get_thread_area(struct task_struct
*child
,
286 int idx
, struct user_desc __user
*user_desc
)
288 struct user_desc info
;
289 struct desc_struct
*desc
;
292 * Get the current Thread-Local Storage area:
295 #define GET_BASE(desc) ( \
296 (((desc)->a >> 16) & 0x0000ffff) | \
297 (((desc)->b << 16) & 0x00ff0000) | \
298 ( (desc)->b & 0xff000000) )
300 #define GET_LIMIT(desc) ( \
301 ((desc)->a & 0x0ffff) | \
302 ((desc)->b & 0xf0000) )
304 #define GET_32BIT(desc) (((desc)->b >> 22) & 1)
305 #define GET_CONTENTS(desc) (((desc)->b >> 10) & 3)
306 #define GET_WRITABLE(desc) (((desc)->b >> 9) & 1)
307 #define GET_LIMIT_PAGES(desc) (((desc)->b >> 23) & 1)
308 #define GET_PRESENT(desc) (((desc)->b >> 15) & 1)
309 #define GET_USEABLE(desc) (((desc)->b >> 20) & 1)
311 if (idx
< GDT_ENTRY_TLS_MIN
|| idx
> GDT_ENTRY_TLS_MAX
)
314 desc
= child
->thread
.tls_array
+ idx
- GDT_ENTRY_TLS_MIN
;
316 info
.entry_number
= idx
;
317 info
.base_addr
= GET_BASE(desc
);
318 info
.limit
= GET_LIMIT(desc
);
319 info
.seg_32bit
= GET_32BIT(desc
);
320 info
.contents
= GET_CONTENTS(desc
);
321 info
.read_exec_only
= !GET_WRITABLE(desc
);
322 info
.limit_in_pages
= GET_LIMIT_PAGES(desc
);
323 info
.seg_not_present
= !GET_PRESENT(desc
);
324 info
.useable
= GET_USEABLE(desc
);
326 if (copy_to_user(user_desc
, &info
, sizeof(info
)))
333 * Perform set_thread_area on behalf of the traced child.
336 ptrace_set_thread_area(struct task_struct
*child
,
337 int idx
, struct user_desc __user
*user_desc
)
339 struct user_desc info
;
340 struct desc_struct
*desc
;
342 if (copy_from_user(&info
, user_desc
, sizeof(info
)))
345 if (idx
< GDT_ENTRY_TLS_MIN
|| idx
> GDT_ENTRY_TLS_MAX
)
348 desc
= child
->thread
.tls_array
+ idx
- GDT_ENTRY_TLS_MIN
;
349 if (LDT_empty(&info
)) {
353 desc
->a
= LDT_entry_a(&info
);
354 desc
->b
= LDT_entry_b(&info
);
360 long arch_ptrace(struct task_struct
*child
, long request
, long addr
, long data
)
362 struct user
* dummy
= NULL
;
364 unsigned long __user
*datap
= (unsigned long __user
*)data
;
367 /* when I and D space are separate, these will need to be fixed. */
368 case PTRACE_PEEKTEXT
: /* read word at location addr. */
369 case PTRACE_PEEKDATA
: {
373 copied
= access_process_vm(child
, addr
, &tmp
, sizeof(tmp
), 0);
375 if (copied
!= sizeof(tmp
))
377 ret
= put_user(tmp
, datap
);
381 /* read the word at location addr in the USER area. */
382 case PTRACE_PEEKUSR
: {
386 if ((addr
& 3) || addr
< 0 ||
387 addr
> sizeof(struct user
) - 3)
390 tmp
= 0; /* Default return condition */
391 if(addr
< FRAME_SIZE
*sizeof(long))
392 tmp
= getreg(child
, addr
);
393 if(addr
>= (long) &dummy
->u_debugreg
[0] &&
394 addr
<= (long) &dummy
->u_debugreg
[7]){
395 addr
-= (long) &dummy
->u_debugreg
[0];
397 tmp
= child
->thread
.debugreg
[addr
];
399 ret
= put_user(tmp
, datap
);
403 /* when I and D space are separate, this will have to be fixed. */
404 case PTRACE_POKETEXT
: /* write the word at location addr. */
405 case PTRACE_POKEDATA
:
407 if (access_process_vm(child
, addr
, &data
, sizeof(data
), 1) == sizeof(data
))
412 case PTRACE_POKEUSR
: /* write the word at location addr in the USER area */
414 if ((addr
& 3) || addr
< 0 ||
415 addr
> sizeof(struct user
) - 3)
418 if (addr
< FRAME_SIZE
*sizeof(long)) {
419 ret
= putreg(child
, addr
, data
);
422 /* We need to be very careful here. We implicitly
423 want to modify a portion of the task_struct, and we
424 have to be selective about what portions we allow someone
428 if(addr
>= (long) &dummy
->u_debugreg
[0] &&
429 addr
<= (long) &dummy
->u_debugreg
[7]){
431 if(addr
== (long) &dummy
->u_debugreg
[4]) break;
432 if(addr
== (long) &dummy
->u_debugreg
[5]) break;
433 if(addr
< (long) &dummy
->u_debugreg
[4] &&
434 ((unsigned long) data
) >= TASK_SIZE
-3) break;
436 /* Sanity-check data. Take one half-byte at once with
437 * check = (val >> (16 + 4*i)) & 0xf. It contains the
438 * R/Wi and LENi bits; bits 0 and 1 are R/Wi, and bits
439 * 2 and 3 are LENi. Given a list of invalid values,
440 * we do mask |= 1 << invalid_value, so that
441 * (mask >> check) & 1 is a correct test for invalid
444 * R/Wi contains the type of the breakpoint /
445 * watchpoint, LENi contains the length of the watched
446 * data in the watchpoint case.
448 * The invalid values are:
449 * - LENi == 0x10 (undefined), so mask |= 0x0f00.
450 * - R/Wi == 0x10 (break on I/O reads or writes), so
452 * - R/Wi == 0x00 && LENi != 0x00, so we have mask |=
455 * Finally, mask = 0x0f00 | 0x4444 | 0x1110 == 0x5f54.
457 * See the Intel Manual "System Programming Guide",
460 * Note that LENi == 0x10 is defined on x86_64 in long
461 * mode (i.e. even for 32-bit userspace software, but
462 * 64-bit kernel), so the x86_64 mask value is 0x5454.
463 * See the AMD manual no. 24593 (AMD64 System
466 if(addr
== (long) &dummy
->u_debugreg
[7]) {
467 data
&= ~DR_CONTROL_RESERVED
;
469 if ((0x5f54 >> ((data
>> (16 + 4*i
)) & 0xf)) & 1)
472 set_tsk_thread_flag(child
, TIF_DEBUG
);
474 clear_tsk_thread_flag(child
, TIF_DEBUG
);
476 addr
-= (long) &dummy
->u_debugreg
;
478 child
->thread
.debugreg
[addr
] = data
;
483 case PTRACE_SYSEMU
: /* continue and stop at next syscall, which will not be executed */
484 case PTRACE_SYSCALL
: /* continue and stop at next (return from) syscall */
485 case PTRACE_CONT
: /* restart after signal. */
487 if (!valid_signal(data
))
489 if (request
== PTRACE_SYSEMU
) {
490 set_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
491 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
492 } else if (request
== PTRACE_SYSCALL
) {
493 set_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
494 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
496 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
497 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
499 child
->exit_code
= data
;
500 /* make sure the single step bit is not set. */
501 clear_singlestep(child
);
502 wake_up_process(child
);
507 * make the child exit. Best I can do is send it a sigkill.
508 * perhaps it should be put in the status that it wants to
513 if (child
->exit_state
== EXIT_ZOMBIE
) /* already dead */
515 child
->exit_code
= SIGKILL
;
516 /* make sure the single step bit is not set. */
517 clear_singlestep(child
);
518 wake_up_process(child
);
521 case PTRACE_SYSEMU_SINGLESTEP
: /* Same as SYSEMU, but singlestep if not syscall */
522 case PTRACE_SINGLESTEP
: /* set the trap flag. */
524 if (!valid_signal(data
))
527 if (request
== PTRACE_SYSEMU_SINGLESTEP
)
528 set_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
530 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
532 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
533 set_singlestep(child
);
534 child
->exit_code
= data
;
535 /* give it a chance to run. */
536 wake_up_process(child
);
541 /* detach a process that was attached. */
542 ret
= ptrace_detach(child
, data
);
545 case PTRACE_GETREGS
: { /* Get all gp regs from the child. */
546 if (!access_ok(VERIFY_WRITE
, datap
, FRAME_SIZE
*sizeof(long))) {
550 for ( i
= 0; i
< FRAME_SIZE
*sizeof(long); i
+= sizeof(long) ) {
551 __put_user(getreg(child
, i
), datap
);
558 case PTRACE_SETREGS
: { /* Set all gp regs in the child. */
560 if (!access_ok(VERIFY_READ
, datap
, FRAME_SIZE
*sizeof(long))) {
564 for ( i
= 0; i
< FRAME_SIZE
*sizeof(long); i
+= sizeof(long) ) {
565 __get_user(tmp
, datap
);
566 putreg(child
, i
, tmp
);
573 case PTRACE_GETFPREGS
: { /* Get the child FPU state. */
574 if (!access_ok(VERIFY_WRITE
, datap
,
575 sizeof(struct user_i387_struct
))) {
580 if (!tsk_used_math(child
))
582 get_fpregs((struct user_i387_struct __user
*)data
, child
);
586 case PTRACE_SETFPREGS
: { /* Set the child FPU state. */
587 if (!access_ok(VERIFY_READ
, datap
,
588 sizeof(struct user_i387_struct
))) {
592 set_stopped_child_used_math(child
);
593 set_fpregs(child
, (struct user_i387_struct __user
*)data
);
598 case PTRACE_GETFPXREGS
: { /* Get the child extended FPU state. */
599 if (!access_ok(VERIFY_WRITE
, datap
,
600 sizeof(struct user_fxsr_struct
))) {
604 if (!tsk_used_math(child
))
606 ret
= get_fpxregs((struct user_fxsr_struct __user
*)data
, child
);
610 case PTRACE_SETFPXREGS
: { /* Set the child extended FPU state. */
611 if (!access_ok(VERIFY_READ
, datap
,
612 sizeof(struct user_fxsr_struct
))) {
616 set_stopped_child_used_math(child
);
617 ret
= set_fpxregs(child
, (struct user_fxsr_struct __user
*)data
);
621 case PTRACE_GET_THREAD_AREA
:
622 ret
= ptrace_get_thread_area(child
, addr
,
623 (struct user_desc __user
*) data
);
626 case PTRACE_SET_THREAD_AREA
:
627 ret
= ptrace_set_thread_area(child
, addr
,
628 (struct user_desc __user
*) data
);
632 ret
= ptrace_request(child
, request
, addr
, data
);
639 void send_sigtrap(struct task_struct
*tsk
, struct pt_regs
*regs
, int error_code
)
643 tsk
->thread
.trap_no
= 1;
644 tsk
->thread
.error_code
= error_code
;
646 memset(&info
, 0, sizeof(info
));
647 info
.si_signo
= SIGTRAP
;
648 info
.si_code
= TRAP_BRKPT
;
651 info
.si_addr
= user_mode_vm(regs
) ? (void __user
*) regs
->eip
: NULL
;
653 /* Send us the fakey SIGTRAP */
654 force_sig_info(SIGTRAP
, &info
, tsk
);
657 /* notification of system call entry/exit
658 * - triggered by current->work.syscall_trace
660 __attribute__((regparm(3)))
661 int do_syscall_trace(struct pt_regs
*regs
, int entryexit
)
663 int is_sysemu
= test_thread_flag(TIF_SYSCALL_EMU
);
665 * With TIF_SYSCALL_EMU set we want to ignore TIF_SINGLESTEP for syscall
668 int is_singlestep
= !is_sysemu
&& test_thread_flag(TIF_SINGLESTEP
);
671 /* do the secure computing check first */
673 secure_computing(regs
->orig_eax
);
675 if (unlikely(current
->audit_context
)) {
677 audit_syscall_exit(AUDITSC_RESULT(regs
->eax
),
679 /* Debug traps, when using PTRACE_SINGLESTEP, must be sent only
680 * on the syscall exit path. Normally, when TIF_SYSCALL_AUDIT is
681 * not used, entry.S will call us only on syscall exit, not
682 * entry; so when TIF_SYSCALL_AUDIT is used we must avoid
683 * calling send_sigtrap() on syscall entry.
685 * Note that when PTRACE_SYSEMU_SINGLESTEP is used,
686 * is_singlestep is false, despite his name, so we will still do
689 else if (is_singlestep
)
693 if (!(current
->ptrace
& PT_PTRACED
))
696 /* If a process stops on the 1st tracepoint with SYSCALL_TRACE
697 * and then is resumed with SYSEMU_SINGLESTEP, it will come in
698 * here. We have to check this and return */
699 if (is_sysemu
&& entryexit
)
702 /* Fake a debug trap */
704 send_sigtrap(current
, regs
, 0);
706 if (!test_thread_flag(TIF_SYSCALL_TRACE
) && !is_sysemu
)
709 /* the 0x80 provides a way for the tracing parent to distinguish
710 between a syscall stop and SIGTRAP delivery */
711 /* Note that the debugger could change the result of test_thread_flag!*/
712 ptrace_notify(SIGTRAP
| ((current
->ptrace
& PT_TRACESYSGOOD
) ? 0x80:0));
715 * this isn't the same as continuing with a signal, but it will do
716 * for normal use. strace only continues with a signal if the
717 * stopping signal is not SIGTRAP. -brl
719 if (current
->exit_code
) {
720 send_sig(current
->exit_code
, current
, 1);
721 current
->exit_code
= 0;
725 if (unlikely(current
->audit_context
) && !entryexit
)
726 audit_syscall_entry(AUDIT_ARCH_I386
, regs
->orig_eax
,
727 regs
->ebx
, regs
->ecx
, regs
->edx
, regs
->esi
);
731 regs
->orig_eax
= -1; /* force skip of syscall restarting */
732 if (unlikely(current
->audit_context
))
733 audit_syscall_exit(AUDITSC_RESULT(regs
->eax
), regs
->eax
);