blob: ea7416c901d1ef8923adb2417b236cf8633a09f0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_PTRACE_H
2#define _LINUX_PTRACE_H
3/* ptrace.h */
4/* structs and defines to help the user use the ptrace system call. */
5
6/* has the defines to get at the registers. */
7
8#define PTRACE_TRACEME 0
9#define PTRACE_PEEKTEXT 1
10#define PTRACE_PEEKDATA 2
11#define PTRACE_PEEKUSR 3
12#define PTRACE_POKETEXT 4
13#define PTRACE_POKEDATA 5
14#define PTRACE_POKEUSR 6
15#define PTRACE_CONT 7
16#define PTRACE_KILL 8
17#define PTRACE_SINGLESTEP 9
18
Roland McGrath416bc512006-09-29 02:00:45 -070019#define PTRACE_ATTACH 16
20#define PTRACE_DETACH 17
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#define PTRACE_SYSCALL 24
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24/* 0x4200-0x4300 are reserved for architecture-independent additions. */
25#define PTRACE_SETOPTIONS 0x4200
26#define PTRACE_GETEVENTMSG 0x4201
27#define PTRACE_GETSIGINFO 0x4202
28#define PTRACE_SETSIGINFO 0x4203
29
30/* options set using PTRACE_SETOPTIONS */
31#define PTRACE_O_TRACESYSGOOD 0x00000001
32#define PTRACE_O_TRACEFORK 0x00000002
33#define PTRACE_O_TRACEVFORK 0x00000004
34#define PTRACE_O_TRACECLONE 0x00000008
35#define PTRACE_O_TRACEEXEC 0x00000010
36#define PTRACE_O_TRACEVFORKDONE 0x00000020
37#define PTRACE_O_TRACEEXIT 0x00000040
38
39#define PTRACE_O_MASK 0x0000007f
40
41/* Wait extended result codes for the above trace options. */
42#define PTRACE_EVENT_FORK 1
43#define PTRACE_EVENT_VFORK 2
44#define PTRACE_EVENT_CLONE 3
45#define PTRACE_EVENT_EXEC 4
46#define PTRACE_EVENT_VFORK_DONE 5
47#define PTRACE_EVENT_EXIT 6
48
49#include <asm/ptrace.h>
50
51#ifdef __KERNEL__
52/*
53 * Ptrace flags
Eric W. Biederman260ea102006-06-23 02:05:18 -070054 *
55 * The owner ship rules for task->ptrace which holds the ptrace
56 * flags is simple. When a task is running it owns it's task->ptrace
57 * flags. When the a task is stopped the ptracer owns task->ptrace.
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 */
59
60#define PT_PTRACED 0x00000001
61#define PT_DTRACE 0x00000002 /* delayed trace (used on m68k, i386) */
62#define PT_TRACESYSGOOD 0x00000004
63#define PT_PTRACE_CAP 0x00000008 /* ptracer can follow suid-exec */
64#define PT_TRACE_FORK 0x00000010
65#define PT_TRACE_VFORK 0x00000020
66#define PT_TRACE_CLONE 0x00000040
67#define PT_TRACE_EXEC 0x00000080
68#define PT_TRACE_VFORK_DONE 0x00000100
69#define PT_TRACE_EXIT 0x00000200
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71#define PT_TRACE_MASK 0x000003f4
72
73/* single stepping state bits (used on ARM and PA-RISC) */
74#define PT_SINGLESTEP_BIT 31
75#define PT_SINGLESTEP (1<<PT_SINGLESTEP_BIT)
76#define PT_BLOCKSTEP_BIT 30
77#define PT_BLOCKSTEP (1<<PT_BLOCKSTEP_BIT)
78
79#include <linux/compiler.h> /* For unlikely. */
80#include <linux/sched.h> /* For struct task_struct. */
81
Christoph Hellwig481bed42005-11-07 00:59:47 -080082
83extern long arch_ptrace(struct task_struct *child, long request, long addr, long data);
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -080084extern struct task_struct *ptrace_get_task_struct(pid_t pid);
85extern int ptrace_traceme(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
87extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
88extern int ptrace_attach(struct task_struct *tsk);
89extern int ptrace_detach(struct task_struct *, unsigned int);
90extern void ptrace_disable(struct task_struct *);
91extern int ptrace_check_attach(struct task_struct *task, int kill);
92extern int ptrace_request(struct task_struct *child, long request, long addr, long data);
93extern void ptrace_notify(int exit_code);
94extern void __ptrace_link(struct task_struct *child,
95 struct task_struct *new_parent);
96extern void __ptrace_unlink(struct task_struct *child);
97extern void ptrace_untrace(struct task_struct *child);
Stephen Smalley006ebb42008-05-19 08:32:49 -040098#define PTRACE_MODE_READ 1
99#define PTRACE_MODE_ATTACH 2
100/* Returns 0 on success, -errno on denial. */
101extern int __ptrace_may_access(struct task_struct *task, unsigned int mode);
102/* Returns true on success, false on denial. */
103extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Oleg Nesterov53b6f9f2008-04-30 00:53:13 -0700105static inline int ptrace_reparented(struct task_struct *child)
106{
107 return child->real_parent != child->parent;
108}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109static inline void ptrace_link(struct task_struct *child,
110 struct task_struct *new_parent)
111{
112 if (unlikely(child->ptrace))
113 __ptrace_link(child, new_parent);
114}
115static inline void ptrace_unlink(struct task_struct *child)
116{
117 if (unlikely(child->ptrace))
118 __ptrace_unlink(child);
119}
120
Alexey Dobriyan76647322007-07-17 04:03:43 -0700121int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data);
Alexey Dobriyanf284ce72007-07-17 04:03:44 -0700122int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
Roland McGrath88ac2922008-07-25 19:45:43 -0700124/**
125 * task_ptrace - return %PT_* flags that apply to a task
126 * @task: pointer to &task_struct in question
127 *
128 * Returns the %PT_* flags that apply to @task.
129 */
130static inline int task_ptrace(struct task_struct *task)
131{
132 return task->ptrace;
133}
134
135/**
136 * ptrace_event - possibly stop for a ptrace event notification
137 * @mask: %PT_* bit to check in @current->ptrace
138 * @event: %PTRACE_EVENT_* value to report if @mask is set
139 * @message: value for %PTRACE_GETEVENTMSG to return
140 *
141 * This checks the @mask bit to see if ptrace wants stops for this event.
142 * If so we stop, reporting @event and @message to the ptrace parent.
143 *
144 * Returns nonzero if we did a ptrace notification, zero if not.
145 *
146 * Called without locks.
147 */
148static inline int ptrace_event(int mask, int event, unsigned long message)
149{
150 if (mask && likely(!(current->ptrace & mask)))
151 return 0;
152 current->ptrace_message = message;
153 ptrace_notify((event << 8) | SIGTRAP);
154 return 1;
155}
156
Roland McGrath09a05392008-07-25 19:45:47 -0700157/**
158 * ptrace_init_task - initialize ptrace state for a new child
159 * @child: new child task
160 * @ptrace: true if child should be ptrace'd by parent's tracer
161 *
162 * This is called immediately after adding @child to its parent's children
163 * list. @ptrace is false in the normal case, and true to ptrace @child.
164 *
165 * Called with current's siglock and write_lock_irq(&tasklist_lock) held.
166 */
167static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
168{
169 INIT_LIST_HEAD(&child->ptrace_entry);
170 INIT_LIST_HEAD(&child->ptraced);
171 child->parent = child->real_parent;
172 child->ptrace = 0;
173 if (unlikely(ptrace)) {
174 child->ptrace = current->ptrace;
Roland McGrath5861bbf2008-08-07 16:55:03 -0700175 ptrace_link(child, current->parent);
Roland McGrath09a05392008-07-25 19:45:47 -0700176 }
177}
178
Roland McGrathdae33572008-07-25 19:45:48 -0700179/**
180 * ptrace_release_task - final ptrace-related cleanup of a zombie being reaped
181 * @task: task in %EXIT_DEAD state
182 *
183 * Called with write_lock(&tasklist_lock) held.
184 */
185static inline void ptrace_release_task(struct task_struct *task)
186{
187 BUG_ON(!list_empty(&task->ptraced));
188 ptrace_unlink(task);
189 BUG_ON(!list_empty(&task->ptrace_entry));
190}
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192#ifndef force_successful_syscall_return
193/*
194 * System call handlers that, upon successful completion, need to return a
195 * negative value should call force_successful_syscall_return() right before
196 * returning. On architectures where the syscall convention provides for a
197 * separate error flag (e.g., alpha, ia64, ppc{,64}, sparc{,64}, possibly
198 * others), this macro can be used to ensure that the error flag will not get
199 * set. On architectures which do not support a separate error flag, the macro
200 * is a no-op and the spurious error condition needs to be filtered out by some
201 * other means (e.g., in user-level, by passing an extra argument to the
202 * syscall handler, or something along those lines).
203 */
204#define force_successful_syscall_return() do { } while (0)
205#endif
206
Roland McGrathfb7fa8f2008-01-30 13:30:47 +0100207/*
208 * <asm/ptrace.h> should define the following things inside #ifdef __KERNEL__.
209 *
210 * These do-nothing inlines are used when the arch does not
211 * implement single-step. The kerneldoc comments are here
212 * to document the interface for all arch definitions.
213 */
214
215#ifndef arch_has_single_step
216/**
217 * arch_has_single_step - does this CPU support user-mode single-step?
218 *
219 * If this is defined, then there must be function declarations or
220 * inlines for user_enable_single_step() and user_disable_single_step().
221 * arch_has_single_step() should evaluate to nonzero iff the machine
222 * supports instruction single-step for user mode.
223 * It can be a constant or it can test a CPU feature bit.
224 */
225#define arch_has_single_step() (0)
226
227/**
228 * user_enable_single_step - single-step in user-mode task
229 * @task: either current or a task stopped in %TASK_TRACED
230 *
231 * This can only be called when arch_has_single_step() has returned nonzero.
232 * Set @task so that when it returns to user mode, it will trap after the
Roland McGrathdc802c22008-01-30 13:30:53 +0100233 * next single instruction executes. If arch_has_block_step() is defined,
234 * this must clear the effects of user_enable_block_step() too.
Roland McGrathfb7fa8f2008-01-30 13:30:47 +0100235 */
236static inline void user_enable_single_step(struct task_struct *task)
237{
238 BUG(); /* This can never be called. */
239}
240
241/**
242 * user_disable_single_step - cancel user-mode single-step
243 * @task: either current or a task stopped in %TASK_TRACED
244 *
Roland McGrathdc802c22008-01-30 13:30:53 +0100245 * Clear @task of the effects of user_enable_single_step() and
246 * user_enable_block_step(). This can be called whether or not either
247 * of those was ever called on @task, and even if arch_has_single_step()
248 * returned zero.
Roland McGrathfb7fa8f2008-01-30 13:30:47 +0100249 */
250static inline void user_disable_single_step(struct task_struct *task)
251{
252}
253#endif /* arch_has_single_step */
254
Roland McGrathdc802c22008-01-30 13:30:53 +0100255#ifndef arch_has_block_step
256/**
257 * arch_has_block_step - does this CPU support user-mode block-step?
258 *
259 * If this is defined, then there must be a function declaration or inline
260 * for user_enable_block_step(), and arch_has_single_step() must be defined
261 * too. arch_has_block_step() should evaluate to nonzero iff the machine
262 * supports step-until-branch for user mode. It can be a constant or it
263 * can test a CPU feature bit.
264 */
Roland McGrath5b88abb2008-01-30 13:30:53 +0100265#define arch_has_block_step() (0)
Roland McGrathdc802c22008-01-30 13:30:53 +0100266
267/**
268 * user_enable_block_step - step until branch in user-mode task
269 * @task: either current or a task stopped in %TASK_TRACED
270 *
271 * This can only be called when arch_has_block_step() has returned nonzero,
272 * and will never be called when single-instruction stepping is being used.
273 * Set @task so that when it returns to user mode, it will trap after the
274 * next branch or trap taken.
275 */
276static inline void user_enable_block_step(struct task_struct *task)
277{
278 BUG(); /* This can never be called. */
279}
280#endif /* arch_has_block_step */
281
Roland McGrath1a669c22008-02-06 01:37:37 -0800282#ifndef arch_ptrace_stop_needed
283/**
284 * arch_ptrace_stop_needed - Decide whether arch_ptrace_stop() should be called
285 * @code: current->exit_code value ptrace will stop with
286 * @info: siginfo_t pointer (or %NULL) for signal ptrace will stop with
287 *
288 * This is called with the siglock held, to decide whether or not it's
289 * necessary to release the siglock and call arch_ptrace_stop() with the
290 * same @code and @info arguments. It can be defined to a constant if
291 * arch_ptrace_stop() is never required, or always is. On machines where
292 * this makes sense, it should be defined to a quick test to optimize out
293 * calling arch_ptrace_stop() when it would be superfluous. For example,
294 * if the thread has not been back to user mode since the last stop, the
295 * thread state might indicate that nothing needs to be done.
296 */
297#define arch_ptrace_stop_needed(code, info) (0)
298#endif
299
300#ifndef arch_ptrace_stop
301/**
302 * arch_ptrace_stop - Do machine-specific work before stopping for ptrace
303 * @code: current->exit_code value ptrace will stop with
304 * @info: siginfo_t pointer (or %NULL) for signal ptrace will stop with
305 *
306 * This is called with no locks held when arch_ptrace_stop_needed() has
307 * just returned nonzero. It is allowed to block, e.g. for user memory
308 * access. The arch can have machine-specific work to be done before
309 * ptrace stops. On ia64, register backing store gets written back to user
310 * memory here. Since this can be costly (requires dropping the siglock),
311 * we only do it when the arch requires it for this particular stop, as
312 * indicated by arch_ptrace_stop_needed().
313 */
314#define arch_ptrace_stop(code, info) do { } while (0)
315#endif
316
Roland McGrathbbc69862008-07-25 19:45:59 -0700317extern int task_current_syscall(struct task_struct *target, long *callno,
318 unsigned long args[6], unsigned int maxargs,
319 unsigned long *sp, unsigned long *pc);
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321#endif
322
323#endif