2 * linux/arch/sh/kernel/ptrace.c
4 * Original x86 implementation:
6 * edited by Linus Torvalds
8 * SuperH version: Copyright (C) 1999, 2000 Kaz Kojima & Niibe Yutaka
11 #include <linux/kernel.h>
12 #include <linux/sched.h>
14 #include <linux/smp.h>
15 #include <linux/errno.h>
16 #include <linux/ptrace.h>
17 #include <linux/user.h>
18 #include <linux/slab.h>
19 #include <linux/security.h>
20 #include <linux/signal.h>
22 #include <asm/uaccess.h>
23 #include <asm/pgtable.h>
24 #include <asm/system.h>
25 #include <asm/processor.h>
26 #include <asm/mmu_context.h>
29 * does not yet catch signals sent when the child dies.
30 * in exit.c or in signal.c.
34 * This routine will get a word off of the process kernel stack.
36 static inline int get_stack_long(struct task_struct
*task
, int offset
)
40 stack
= (unsigned char *)task_pt_regs(task
);
42 return (*((int *)stack
));
46 * This routine will put a word on the process kernel stack.
48 static inline int put_stack_long(struct task_struct
*task
, int offset
,
53 stack
= (unsigned char *)task_pt_regs(task
);
55 *(unsigned long *) stack
= data
;
59 static void ptrace_disable_singlestep(struct task_struct
*child
)
61 clear_tsk_thread_flag(child
, TIF_SINGLESTEP
);
64 * Ensure the UBC is not programmed at the next context switch.
66 * Normally this is not needed but there are sequences such as
67 * singlestep, signal delivery, and continue that leave the
68 * ubc_pc non-zero leading to spurious SIGTRAPs.
70 if (child
->thread
.ubc_pc
!= 0) {
72 child
->thread
.ubc_pc
= 0;
77 * Called by kernel/ptrace.c when detaching..
79 * Make sure single step bits etc are not set.
81 void ptrace_disable(struct task_struct
*child
)
83 ptrace_disable_singlestep(child
);
86 long arch_ptrace(struct task_struct
*child
, long request
, long addr
, long data
)
88 struct user
* dummy
= NULL
;
92 /* when I and D space are separate, these will need to be fixed. */
93 case PTRACE_PEEKTEXT
: /* read word at location addr. */
95 ret
= generic_ptrace_peekdata(child
, addr
, data
);
97 /* read the word at location addr in the USER area. */
98 case PTRACE_PEEKUSR
: {
102 if ((addr
& 3) || addr
< 0 ||
103 addr
> sizeof(struct user
) - 3)
106 if (addr
< sizeof(struct pt_regs
))
107 tmp
= get_stack_long(child
, addr
);
108 else if (addr
>= (long) &dummy
->fpu
&&
109 addr
< (long) &dummy
->u_fpvalid
) {
110 if (!tsk_used_math(child
)) {
111 if (addr
== (long)&dummy
->fpu
.fpscr
)
116 tmp
= ((long *)&child
->thread
.fpu
)
117 [(addr
- (long)&dummy
->fpu
) >> 2];
118 } else if (addr
== (long) &dummy
->u_fpvalid
)
119 tmp
= !!tsk_used_math(child
);
122 ret
= put_user(tmp
, (unsigned long __user
*)data
);
126 /* when I and D space are separate, this will have to be fixed. */
127 case PTRACE_POKETEXT
: /* write the word at location addr. */
128 case PTRACE_POKEDATA
:
130 if (access_process_vm(child
, addr
, &data
, sizeof(data
), 1) == sizeof(data
))
135 case PTRACE_POKEUSR
: /* write the word at location addr in the USER area */
137 if ((addr
& 3) || addr
< 0 ||
138 addr
> sizeof(struct user
) - 3)
141 if (addr
< sizeof(struct pt_regs
))
142 ret
= put_stack_long(child
, addr
, data
);
143 else if (addr
>= (long) &dummy
->fpu
&&
144 addr
< (long) &dummy
->u_fpvalid
) {
145 set_stopped_child_used_math(child
);
146 ((long *)&child
->thread
.fpu
)
147 [(addr
- (long)&dummy
->fpu
) >> 2] = data
;
149 } else if (addr
== (long) &dummy
->u_fpvalid
) {
150 conditional_stopped_child_used_math(data
, child
);
155 case PTRACE_SYSCALL
: /* continue and stop at next (return from) syscall */
156 case PTRACE_CONT
: { /* restart after signal. */
158 if (!valid_signal(data
))
160 if (request
== PTRACE_SYSCALL
)
161 set_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
163 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
165 ptrace_disable_singlestep(child
);
167 child
->exit_code
= data
;
168 wake_up_process(child
);
174 * make the child exit. Best I can do is send it a sigkill.
175 * perhaps it should be put in the status that it wants to
180 if (child
->exit_state
== EXIT_ZOMBIE
) /* already dead */
182 ptrace_disable_singlestep(child
);
183 child
->exit_code
= SIGKILL
;
184 wake_up_process(child
);
188 case PTRACE_SINGLESTEP
: { /* set the trap flag. */
190 struct pt_regs
*regs
= NULL
;
193 if (!valid_signal(data
))
195 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
196 if ((child
->ptrace
& PT_DTRACE
) == 0) {
197 /* Spurious delayed TF traps may occur */
198 child
->ptrace
|= PT_DTRACE
;
201 pc
= get_stack_long(child
, (long)®s
->pc
);
203 /* Next scheduling will set up UBC */
204 if (child
->thread
.ubc_pc
== 0)
206 child
->thread
.ubc_pc
= pc
;
208 set_tsk_thread_flag(child
, TIF_SINGLESTEP
);
209 child
->exit_code
= data
;
210 /* give it a chance to run. */
211 wake_up_process(child
);
216 case PTRACE_DETACH
: /* detach a process that was attached. */
217 ret
= ptrace_detach(child
, data
);
221 case PTRACE_GETDSPREGS
: {
225 dp
= ((unsigned long) child
) + THREAD_SIZE
-
226 sizeof(struct pt_dspregs
);
227 if (*((int *) (dp
- 4)) == SR_FD
) {
228 copy_to_user(addr
, (void *) dp
,
229 sizeof(struct pt_dspregs
));
235 case PTRACE_SETDSPREGS
: {
239 dp
= ((unsigned long) child
) + THREAD_SIZE
-
240 sizeof(struct pt_dspregs
);
241 if (*((int *) (dp
- 4)) == SR_FD
) {
242 copy_from_user((void *) dp
, addr
,
243 sizeof(struct pt_dspregs
));
250 ret
= ptrace_request(child
, request
, addr
, data
);
257 asmlinkage
void do_syscall_trace(void)
259 struct task_struct
*tsk
= current
;
261 if (!test_thread_flag(TIF_SYSCALL_TRACE
) &&
262 !test_thread_flag(TIF_SINGLESTEP
))
264 if (!(tsk
->ptrace
& PT_PTRACED
))
266 /* the 0x80 provides a way for the tracing parent to distinguish
267 between a syscall stop and SIGTRAP delivery */
268 ptrace_notify(SIGTRAP
| ((current
->ptrace
& PT_TRACESYSGOOD
) &&
269 !test_thread_flag(TIF_SINGLESTEP
) ? 0x80 : 0));
272 * this isn't the same as continuing with a signal, but it will do
273 * for normal use. strace only continues with a signal if the
274 * stopping signal is not SIGTRAP. -brl
276 if (tsk
->exit_code
) {
277 send_sig(tsk
->exit_code
, tsk
, 1);
This page took 0.046947 seconds and 5 git commands to generate.