]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - arch/i386/kernel/ptrace.c
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
:
370 ret
= generic_ptrace_peekdata(child
, addr
, data
);
373 /* read the word at location addr in the USER area. */
374 case PTRACE_PEEKUSR
: {
378 if ((addr
& 3) || addr
< 0 ||
379 addr
> sizeof(struct user
) - 3)
382 tmp
= 0; /* Default return condition */
383 if(addr
< FRAME_SIZE
*sizeof(long))
384 tmp
= getreg(child
, addr
);
385 if(addr
>= (long) &dummy
->u_debugreg
[0] &&
386 addr
<= (long) &dummy
->u_debugreg
[7]){
387 addr
-= (long) &dummy
->u_debugreg
[0];
389 tmp
= child
->thread
.debugreg
[addr
];
391 ret
= put_user(tmp
, datap
);
395 /* when I and D space are separate, this will have to be fixed. */
396 case PTRACE_POKETEXT
: /* write the word at location addr. */
397 case PTRACE_POKEDATA
:
398 ret
= generic_ptrace_pokedata(child
, addr
, data
);
401 case PTRACE_POKEUSR
: /* write the word at location addr in the USER area */
403 if ((addr
& 3) || addr
< 0 ||
404 addr
> sizeof(struct user
) - 3)
407 if (addr
< FRAME_SIZE
*sizeof(long)) {
408 ret
= putreg(child
, addr
, data
);
411 /* We need to be very careful here. We implicitly
412 want to modify a portion of the task_struct, and we
413 have to be selective about what portions we allow someone
417 if(addr
>= (long) &dummy
->u_debugreg
[0] &&
418 addr
<= (long) &dummy
->u_debugreg
[7]){
420 if(addr
== (long) &dummy
->u_debugreg
[4]) break;
421 if(addr
== (long) &dummy
->u_debugreg
[5]) break;
422 if(addr
< (long) &dummy
->u_debugreg
[4] &&
423 ((unsigned long) data
) >= TASK_SIZE
-3) break;
425 /* Sanity-check data. Take one half-byte at once with
426 * check = (val >> (16 + 4*i)) & 0xf. It contains the
427 * R/Wi and LENi bits; bits 0 and 1 are R/Wi, and bits
428 * 2 and 3 are LENi. Given a list of invalid values,
429 * we do mask |= 1 << invalid_value, so that
430 * (mask >> check) & 1 is a correct test for invalid
433 * R/Wi contains the type of the breakpoint /
434 * watchpoint, LENi contains the length of the watched
435 * data in the watchpoint case.
437 * The invalid values are:
438 * - LENi == 0x10 (undefined), so mask |= 0x0f00.
439 * - R/Wi == 0x10 (break on I/O reads or writes), so
441 * - R/Wi == 0x00 && LENi != 0x00, so we have mask |=
444 * Finally, mask = 0x0f00 | 0x4444 | 0x1110 == 0x5f54.
446 * See the Intel Manual "System Programming Guide",
449 * Note that LENi == 0x10 is defined on x86_64 in long
450 * mode (i.e. even for 32-bit userspace software, but
451 * 64-bit kernel), so the x86_64 mask value is 0x5454.
452 * See the AMD manual no. 24593 (AMD64 System
455 if(addr
== (long) &dummy
->u_debugreg
[7]) {
456 data
&= ~DR_CONTROL_RESERVED
;
458 if ((0x5f54 >> ((data
>> (16 + 4*i
)) & 0xf)) & 1)
461 set_tsk_thread_flag(child
, TIF_DEBUG
);
463 clear_tsk_thread_flag(child
, TIF_DEBUG
);
465 addr
-= (long) &dummy
->u_debugreg
;
467 child
->thread
.debugreg
[addr
] = data
;
472 case PTRACE_SYSEMU
: /* continue and stop at next syscall, which will not be executed */
473 case PTRACE_SYSCALL
: /* continue and stop at next (return from) syscall */
474 case PTRACE_CONT
: /* restart after signal. */
476 if (!valid_signal(data
))
478 if (request
== PTRACE_SYSEMU
) {
479 set_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
480 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
481 } else if (request
== PTRACE_SYSCALL
) {
482 set_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
483 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
485 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
486 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
488 child
->exit_code
= data
;
489 /* make sure the single step bit is not set. */
490 clear_singlestep(child
);
491 wake_up_process(child
);
496 * make the child exit. Best I can do is send it a sigkill.
497 * perhaps it should be put in the status that it wants to
502 if (child
->exit_state
== EXIT_ZOMBIE
) /* already dead */
504 child
->exit_code
= SIGKILL
;
505 /* make sure the single step bit is not set. */
506 clear_singlestep(child
);
507 wake_up_process(child
);
510 case PTRACE_SYSEMU_SINGLESTEP
: /* Same as SYSEMU, but singlestep if not syscall */
511 case PTRACE_SINGLESTEP
: /* set the trap flag. */
513 if (!valid_signal(data
))
516 if (request
== PTRACE_SYSEMU_SINGLESTEP
)
517 set_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
519 clear_tsk_thread_flag(child
, TIF_SYSCALL_EMU
);
521 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
522 set_singlestep(child
);
523 child
->exit_code
= data
;
524 /* give it a chance to run. */
525 wake_up_process(child
);
530 /* detach a process that was attached. */
531 ret
= ptrace_detach(child
, data
);
534 case PTRACE_GETREGS
: { /* Get all gp regs from the child. */
535 if (!access_ok(VERIFY_WRITE
, datap
, FRAME_SIZE
*sizeof(long))) {
539 for ( i
= 0; i
< FRAME_SIZE
*sizeof(long); i
+= sizeof(long) ) {
540 __put_user(getreg(child
, i
), datap
);
547 case PTRACE_SETREGS
: { /* Set all gp regs in the child. */
549 if (!access_ok(VERIFY_READ
, datap
, FRAME_SIZE
*sizeof(long))) {
553 for ( i
= 0; i
< FRAME_SIZE
*sizeof(long); i
+= sizeof(long) ) {
554 __get_user(tmp
, datap
);
555 putreg(child
, i
, tmp
);
562 case PTRACE_GETFPREGS
: { /* Get the child FPU state. */
563 if (!access_ok(VERIFY_WRITE
, datap
,
564 sizeof(struct user_i387_struct
))) {
569 if (!tsk_used_math(child
))
571 get_fpregs((struct user_i387_struct __user
*)data
, child
);
575 case PTRACE_SETFPREGS
: { /* Set the child FPU state. */
576 if (!access_ok(VERIFY_READ
, datap
,
577 sizeof(struct user_i387_struct
))) {
581 set_stopped_child_used_math(child
);
582 set_fpregs(child
, (struct user_i387_struct __user
*)data
);
587 case PTRACE_GETFPXREGS
: { /* Get the child extended FPU state. */
588 if (!access_ok(VERIFY_WRITE
, datap
,
589 sizeof(struct user_fxsr_struct
))) {
593 if (!tsk_used_math(child
))
595 ret
= get_fpxregs((struct user_fxsr_struct __user
*)data
, child
);
599 case PTRACE_SETFPXREGS
: { /* Set the child extended FPU state. */
600 if (!access_ok(VERIFY_READ
, datap
,
601 sizeof(struct user_fxsr_struct
))) {
605 set_stopped_child_used_math(child
);
606 ret
= set_fpxregs(child
, (struct user_fxsr_struct __user
*)data
);
610 case PTRACE_GET_THREAD_AREA
:
611 ret
= ptrace_get_thread_area(child
, addr
,
612 (struct user_desc __user
*) data
);
615 case PTRACE_SET_THREAD_AREA
:
616 ret
= ptrace_set_thread_area(child
, addr
,
617 (struct user_desc __user
*) data
);
621 ret
= ptrace_request(child
, request
, addr
, data
);
628 void send_sigtrap(struct task_struct
*tsk
, struct pt_regs
*regs
, int error_code
)
632 tsk
->thread
.trap_no
= 1;
633 tsk
->thread
.error_code
= error_code
;
635 memset(&info
, 0, sizeof(info
));
636 info
.si_signo
= SIGTRAP
;
637 info
.si_code
= TRAP_BRKPT
;
640 info
.si_addr
= user_mode_vm(regs
) ? (void __user
*) regs
->eip
: NULL
;
642 /* Send us the fakey SIGTRAP */
643 force_sig_info(SIGTRAP
, &info
, tsk
);
646 /* notification of system call entry/exit
647 * - triggered by current->work.syscall_trace
649 __attribute__((regparm(3)))
650 int do_syscall_trace(struct pt_regs
*regs
, int entryexit
)
652 int is_sysemu
= test_thread_flag(TIF_SYSCALL_EMU
);
654 * With TIF_SYSCALL_EMU set we want to ignore TIF_SINGLESTEP for syscall
657 int is_singlestep
= !is_sysemu
&& test_thread_flag(TIF_SINGLESTEP
);
660 /* do the secure computing check first */
662 secure_computing(regs
->orig_eax
);
664 if (unlikely(current
->audit_context
)) {
666 audit_syscall_exit(AUDITSC_RESULT(regs
->eax
),
668 /* Debug traps, when using PTRACE_SINGLESTEP, must be sent only
669 * on the syscall exit path. Normally, when TIF_SYSCALL_AUDIT is
670 * not used, entry.S will call us only on syscall exit, not
671 * entry; so when TIF_SYSCALL_AUDIT is used we must avoid
672 * calling send_sigtrap() on syscall entry.
674 * Note that when PTRACE_SYSEMU_SINGLESTEP is used,
675 * is_singlestep is false, despite his name, so we will still do
678 else if (is_singlestep
)
682 if (!(current
->ptrace
& PT_PTRACED
))
685 /* If a process stops on the 1st tracepoint with SYSCALL_TRACE
686 * and then is resumed with SYSEMU_SINGLESTEP, it will come in
687 * here. We have to check this and return */
688 if (is_sysemu
&& entryexit
)
691 /* Fake a debug trap */
693 send_sigtrap(current
, regs
, 0);
695 if (!test_thread_flag(TIF_SYSCALL_TRACE
) && !is_sysemu
)
698 /* the 0x80 provides a way for the tracing parent to distinguish
699 between a syscall stop and SIGTRAP delivery */
700 /* Note that the debugger could change the result of test_thread_flag!*/
701 ptrace_notify(SIGTRAP
| ((current
->ptrace
& PT_TRACESYSGOOD
) ? 0x80:0));
704 * this isn't the same as continuing with a signal, but it will do
705 * for normal use. strace only continues with a signal if the
706 * stopping signal is not SIGTRAP. -brl
708 if (current
->exit_code
) {
709 send_sig(current
->exit_code
, current
, 1);
710 current
->exit_code
= 0;
714 if (unlikely(current
->audit_context
) && !entryexit
)
715 audit_syscall_entry(AUDIT_ARCH_I386
, regs
->orig_eax
,
716 regs
->ebx
, regs
->ecx
, regs
->edx
, regs
->esi
);
720 regs
->orig_eax
= -1; /* force skip of syscall restarting */
721 if (unlikely(current
->audit_context
))
722 audit_syscall_exit(AUDITSC_RESULT(regs
->eax
), regs
->eax
);