1 #ifndef _LINUX_PTRACE_H
2 #define _LINUX_PTRACE_H
4 /* structs and defines to help the user use the ptrace system call. */
6 /* has the defines to get at the registers. */
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
17 #define PTRACE_SINGLESTEP 9
19 #define PTRACE_ATTACH 16
20 #define PTRACE_DETACH 17
22 #define PTRACE_SYSCALL 24
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
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
39 #define PTRACE_O_MASK 0x0000007f
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
49 #include <asm/ptrace.h>
52 #include <linux/compiler.h> /* For unlikely. */
53 #include <linux/sched.h> /* For struct task_struct. */
54 #include <linux/types.h>
55 #include <linux/errno.h>
60 extern int ptrace_may_attach(struct task_struct *task);
64 #include <asm/tracehook.h>
65 struct utrace_attached_engine;
66 struct utrace_regset_view;
69 * These must be defined by arch code to handle machine-specific ptrace
70 * requests such as PTRACE_PEEKUSR and PTRACE_GETREGS. Returns -ENOSYS for
71 * any request it does not handle, then handled by machine-independent code.
72 * This can change *request and then return -ENOSYS to handle a
73 * machine-specific alias for a generic request.
75 * This code should NOT access task machine state directly. Instead it
76 * should use the utrace_regset accessors. The functions below make this easy.
78 * Any nonzero return value should be for an error. If the return value of
79 * the ptrace syscall should be a nonzero success value, this returns zero
80 * and sets *retval to the value--which might have any bit pattern at all,
81 * including one that looks like -ENOSYS or another error code.
83 extern int arch_ptrace(long *request, struct task_struct *child,
84 struct utrace_attached_engine *engine,
85 unsigned long addr, unsigned long data,
88 #include <linux/compat.h>
90 extern int arch_compat_ptrace(compat_long_t *request,
91 struct task_struct *child,
92 struct utrace_attached_engine *engine,
93 compat_ulong_t a, compat_ulong_t d,
94 compat_long_t *retval);
98 * Convenience function doing access to a single utrace_regset for ptrace.
99 * The offset and size are in bytes, giving the location in the regset data.
101 extern int ptrace_regset_access(struct task_struct *child,
102 struct utrace_attached_engine *engine,
103 const struct utrace_regset_view *view,
104 int setno, unsigned long offset,
105 unsigned int size, void __user *data,
109 * Convenience wrapper for doing access to a whole utrace_regset for ptrace.
111 static inline int ptrace_whole_regset(struct task_struct *child,
112 struct utrace_attached_engine *engine,
113 long data, int setno, int write)
115 return ptrace_regset_access(child, engine, utrace_native_view(current),
116 setno, 0, -1, (void __user *)data, write);
120 * Convenience function doing access to a single slot in a utrace_regset.
121 * The regno value gives a slot number plus regset->bias.
122 * The value accessed is regset->size bytes long.
124 extern int ptrace_onereg_access(struct task_struct *child,
125 struct utrace_attached_engine *engine,
126 const struct utrace_regset_view *view,
127 int setno, unsigned long regno,
128 void __user *data, int write);
132 * An array of these describes the layout of the virtual struct user
133 * accessed by PEEKUSR/POKEUSR, or the structure used by GETREGS et al.
134 * The array is terminated by an element with .end of zero.
135 * An element describes the range [.start, .end) of struct user offsets,
136 * measured in bytes; it maps to the regset in the view's regsets array
137 * at the index given by .regset, at .offset bytes into that regset's data.
138 * If .regset is -1, then the [.start, .end) range reads as zero
139 * if .offset is zero, and is skipped on read (user's buffer unchanged)
142 struct ptrace_layout_segment {
143 unsigned int start, end, regset, offset;
147 * Convenience function for doing access to a ptrace compatibility layout.
148 * The offset and size are in bytes.
150 extern int ptrace_layout_access(struct task_struct *child,
151 struct utrace_attached_engine *engine,
152 const struct utrace_regset_view *view,
153 const struct ptrace_layout_segment layout[],
154 unsigned long offset, unsigned int size,
155 void __user *data, void *kdata, int write);
158 /* Convenience wrapper for the common PTRACE_PEEKUSR implementation. */
159 static inline int ptrace_peekusr(struct task_struct *child,
160 struct utrace_attached_engine *engine,
161 const struct ptrace_layout_segment layout[],
162 unsigned long addr, long data)
164 return ptrace_layout_access(child, engine, utrace_native_view(current),
165 layout, addr, sizeof(long),
166 (unsigned long __user *)data, NULL, 0);
169 /* Convenience wrapper for the common PTRACE_PEEKUSR implementation. */
170 static inline int ptrace_pokeusr(struct task_struct *child,
171 struct utrace_attached_engine *engine,
172 const struct ptrace_layout_segment layout[],
173 unsigned long addr, long data)
175 return ptrace_layout_access(child, engine, utrace_native_view(current),
176 layout, addr, sizeof(long),
181 /* Convenience wrapper for the common PTRACE_PEEKUSR implementation. */
182 static inline int ptrace_compat_peekusr(
183 struct task_struct *child, struct utrace_attached_engine *engine,
184 const struct ptrace_layout_segment layout[],
185 compat_ulong_t addr, compat_ulong_t data)
187 compat_ulong_t *udata = (compat_ulong_t __user *) (unsigned long) data;
188 return ptrace_layout_access(child, engine, utrace_native_view(current),
189 layout, addr, sizeof(compat_ulong_t),
193 /* Convenience wrapper for the common PTRACE_PEEKUSR implementation. */
194 static inline int ptrace_compat_pokeusr(
195 struct task_struct *child, struct utrace_attached_engine *engine,
196 const struct ptrace_layout_segment layout[],
197 compat_ulong_t addr, compat_ulong_t data)
199 return ptrace_layout_access(child, engine, utrace_native_view(current),
200 layout, addr, sizeof(compat_ulong_t),
207 * Called in copy_process.
209 static inline void ptrace_init_task(struct task_struct *tsk)
211 INIT_LIST_HEAD(&tsk->ptracees);
215 * Called in do_exit, after setting PF_EXITING, no locks are held.
217 void ptrace_exit(struct task_struct *tsk);
220 * Called in do_wait, with tasklist_lock held for reading.
221 * This reports any ptrace-child that is ready as do_wait would a normal child.
222 * If there are no ptrace children, returns -ECHILD.
223 * If there are some ptrace children but none reporting now, returns 0.
224 * In those cases the tasklist_lock is still held so next_thread(tsk) works.
225 * For any other return value, tasklist_lock is released before return.
227 int ptrace_do_wait(struct task_struct *tsk,
228 pid_t pid, int options, struct siginfo __user *infop,
229 int __user *stat_addr, struct rusage __user *rusagep);
231 static inline void ptrace_init_task(struct task_struct *tsk) { }
232 static inline void ptrace_exit(struct task_struct *tsk) { }
233 static inline int ptrace_do_wait(struct task_struct *tsk,
234 pid_t pid, int options,
235 struct siginfo __user *infop,
236 int __user *stat_addr,
237 struct rusage __user *rusagep)
244 #ifndef force_successful_syscall_return
246 * System call handlers that, upon successful completion, need to return a
247 * negative value should call force_successful_syscall_return() right before
248 * returning. On architectures where the syscall convention provides for a
249 * separate error flag (e.g., alpha, ia64, ppc{,64}, sparc{,64}, possibly
250 * others), this macro can be used to ensure that the error flag will not get
251 * set. On architectures which do not support a separate error flag, the macro
252 * is a no-op and the spurious error condition needs to be filtered out by some
253 * other means (e.g., in user-level, by passing an extra argument to the
254 * syscall handler, or something along those lines).
256 #define force_successful_syscall_return() do { } while (0)