blob: bb980ae6d9d3601524b1270c9f27880766e6d722 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_PTRACE_H
2#define _LINUX_PTRACE_H
Linus Torvalds1da177e2005-04-16 15:20:36 -07003
David Howells607ca462012-10-13 10:46:48 +01004#include <linux/compiler.h> /* For unlikely. */
5#include <linux/sched.h> /* For struct task_struct. */
6#include <linux/err.h> /* for IS_ERR_VALUE */
7#include <linux/bug.h> /* For BUG_ON. */
Matthew Dempsky1a2d9732014-06-06 14:36:42 -07008#include <linux/pid_namespace.h> /* For task_active_pid_ns. */
David Howells607ca462012-10-13 10:46:48 +01009#include <uapi/linux/ptrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
Linus Torvalds1da177e2005-04-16 15:20:36 -070011/*
12 * Ptrace flags
Eric W. Biederman260ea102006-06-23 02:05:18 -070013 *
14 * The owner ship rules for task->ptrace which holds the ptrace
15 * flags is simple. When a task is running it owns it's task->ptrace
16 * flags. When the a task is stopped the ptracer owns task->ptrace.
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
18
Tejun Heo3544d722011-06-14 11:20:15 +020019#define PT_SEIZED 0x00010000 /* SEIZE used, enable new behavior */
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#define PT_PTRACED 0x00000001
21#define PT_DTRACE 0x00000002 /* delayed trace (used on m68k, i386) */
Denys Vlasenko86b6c1f2012-03-23 15:02:41 -070022#define PT_PTRACE_CAP 0x00000004 /* ptracer can follow suid-exec */
Tejun Heo643ad832011-06-17 16:50:35 +020023
Denys Vlasenko86b6c1f2012-03-23 15:02:41 -070024#define PT_OPT_FLAG_SHIFT 3
Tejun Heo643ad832011-06-17 16:50:35 +020025/* PT_TRACE_* event enable flags */
Denys Vlasenko86b6c1f2012-03-23 15:02:41 -070026#define PT_EVENT_FLAG(event) (1 << (PT_OPT_FLAG_SHIFT + (event)))
27#define PT_TRACESYSGOOD PT_EVENT_FLAG(0)
Tejun Heo643ad832011-06-17 16:50:35 +020028#define PT_TRACE_FORK PT_EVENT_FLAG(PTRACE_EVENT_FORK)
29#define PT_TRACE_VFORK PT_EVENT_FLAG(PTRACE_EVENT_VFORK)
30#define PT_TRACE_CLONE PT_EVENT_FLAG(PTRACE_EVENT_CLONE)
31#define PT_TRACE_EXEC PT_EVENT_FLAG(PTRACE_EVENT_EXEC)
32#define PT_TRACE_VFORK_DONE PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE)
33#define PT_TRACE_EXIT PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
Will Drewryfb0fadf2012-04-12 16:48:02 -050034#define PT_TRACE_SECCOMP PT_EVENT_FLAG(PTRACE_EVENT_SECCOMP)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Oleg Nesterov992fb6e2012-12-17 16:03:07 -080036#define PT_EXITKILL (PTRACE_O_EXITKILL << PT_OPT_FLAG_SHIFT)
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038/* single stepping state bits (used on ARM and PA-RISC) */
39#define PT_SINGLESTEP_BIT 31
40#define PT_SINGLESTEP (1<<PT_SINGLESTEP_BIT)
41#define PT_BLOCKSTEP_BIT 30
42#define PT_BLOCKSTEP (1<<PT_BLOCKSTEP_BIT)
43
Namhyung Kim9b05a692010-10-27 15:33:47 -070044extern long arch_ptrace(struct task_struct *child, long request,
45 unsigned long addr, unsigned long data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
47extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048extern void ptrace_disable(struct task_struct *);
Namhyung Kim4abf9862010-10-27 15:33:45 -070049extern int ptrace_request(struct task_struct *child, long request,
50 unsigned long addr, unsigned long data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051extern void ptrace_notify(int exit_code);
52extern void __ptrace_link(struct task_struct *child,
53 struct task_struct *new_parent);
54extern void __ptrace_unlink(struct task_struct *child);
Oleg Nesterov39c626a2009-04-02 16:58:18 -070055extern void exit_ptrace(struct task_struct *tracer);
Eric Paris69f594a2012-01-03 12:25:15 -050056#define PTRACE_MODE_READ 0x01
57#define PTRACE_MODE_ATTACH 0x02
58#define PTRACE_MODE_NOAUDIT 0x04
Stephen Smalley006ebb42008-05-19 08:32:49 -040059/* Returns true on success, false on denial. */
60extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Oleg Nesterov53b6f9f2008-04-30 00:53:13 -070062static inline int ptrace_reparented(struct task_struct *child)
63{
Oleg Nesterov0347e172011-06-24 17:34:06 +020064 return !same_thread_group(child->real_parent, child->parent);
Oleg Nesterov53b6f9f2008-04-30 00:53:13 -070065}
Oleg Nesterovc6a47cc2009-12-15 16:47:15 -080066
Linus Torvalds1da177e2005-04-16 15:20:36 -070067static inline void ptrace_unlink(struct task_struct *child)
68{
69 if (unlikely(child->ptrace))
70 __ptrace_unlink(child);
71}
72
Namhyung Kim4abf9862010-10-27 15:33:45 -070073int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr,
74 unsigned long data);
75int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
76 unsigned long data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Roland McGrath88ac2922008-07-25 19:45:43 -070078/**
Tejun Heo06d98472011-06-17 16:50:40 +020079 * ptrace_parent - return the task that is tracing the given task
80 * @task: task to consider
81 *
82 * Returns %NULL if no one is tracing @task, or the &struct task_struct
83 * pointer to its tracer.
84 *
85 * Must called under rcu_read_lock(). The pointer returned might be kept
86 * live only by RCU. During exec, this may be called with task_lock() held
87 * on @task, still held from when check_unsafe_exec() was called.
88 */
89static inline struct task_struct *ptrace_parent(struct task_struct *task)
90{
91 if (unlikely(task->ptrace))
92 return rcu_dereference(task->parent);
93 return NULL;
94}
95
96/**
Tejun Heo643ad832011-06-17 16:50:35 +020097 * ptrace_event_enabled - test whether a ptrace event is enabled
98 * @task: ptracee of interest
99 * @event: %PTRACE_EVENT_* to test
100 *
101 * Test whether @event is enabled for ptracee @task.
102 *
103 * Returns %true if @event is enabled, %false otherwise.
104 */
105static inline bool ptrace_event_enabled(struct task_struct *task, int event)
106{
107 return task->ptrace & PT_EVENT_FLAG(event);
108}
109
110/**
Roland McGrath88ac2922008-07-25 19:45:43 -0700111 * ptrace_event - possibly stop for a ptrace event notification
Tejun Heo643ad832011-06-17 16:50:35 +0200112 * @event: %PTRACE_EVENT_* value to report
Roland McGrath88ac2922008-07-25 19:45:43 -0700113 * @message: value for %PTRACE_GETEVENTMSG to return
114 *
Tejun Heo643ad832011-06-17 16:50:35 +0200115 * Check whether @event is enabled and, if so, report @event and @message
116 * to the ptrace parent.
Roland McGrath88ac2922008-07-25 19:45:43 -0700117 *
Roland McGrath88ac2922008-07-25 19:45:43 -0700118 * Called without locks.
119 */
Tejun Heof3c04b92011-06-17 16:50:36 +0200120static inline void ptrace_event(int event, unsigned long message)
Roland McGrath88ac2922008-07-25 19:45:43 -0700121{
Tejun Heof3c04b92011-06-17 16:50:36 +0200122 if (unlikely(ptrace_event_enabled(current, event))) {
123 current->ptrace_message = message;
124 ptrace_notify((event << 8) | SIGTRAP);
Oleg Nesterovb1845ff2012-03-23 15:02:40 -0700125 } else if (event == PTRACE_EVENT_EXEC) {
Tejun Heof3c04b92011-06-17 16:50:36 +0200126 /* legacy EXEC report via SIGTRAP */
Oleg Nesterovb1845ff2012-03-23 15:02:40 -0700127 if ((current->ptrace & (PT_PTRACED|PT_SEIZED)) == PT_PTRACED)
128 send_sig(SIGTRAP, current, 0);
Tejun Heof3c04b92011-06-17 16:50:36 +0200129 }
Roland McGrath88ac2922008-07-25 19:45:43 -0700130}
131
Roland McGrath09a05392008-07-25 19:45:47 -0700132/**
Matthew Dempsky1a2d9732014-06-06 14:36:42 -0700133 * ptrace_event_pid - possibly stop for a ptrace event notification
134 * @event: %PTRACE_EVENT_* value to report
135 * @pid: process identifier for %PTRACE_GETEVENTMSG to return
136 *
137 * Check whether @event is enabled and, if so, report @event and @pid
138 * to the ptrace parent. @pid is reported as the pid_t seen from the
139 * the ptrace parent's pid namespace.
140 *
141 * Called without locks.
142 */
143static inline void ptrace_event_pid(int event, struct pid *pid)
144{
145 /*
146 * FIXME: There's a potential race if a ptracer in a different pid
147 * namespace than parent attaches between computing message below and
148 * when we acquire tasklist_lock in ptrace_stop(). If this happens,
149 * the ptracer will get a bogus pid from PTRACE_GETEVENTMSG.
150 */
151 unsigned long message = 0;
152 struct pid_namespace *ns;
153
154 rcu_read_lock();
155 ns = task_active_pid_ns(rcu_dereference(current->parent));
156 if (ns)
157 message = pid_nr_ns(pid, ns);
158 rcu_read_unlock();
159
160 ptrace_event(event, message);
161}
162
163/**
Roland McGrath09a05392008-07-25 19:45:47 -0700164 * ptrace_init_task - initialize ptrace state for a new child
165 * @child: new child task
166 * @ptrace: true if child should be ptrace'd by parent's tracer
167 *
168 * This is called immediately after adding @child to its parent's children
169 * list. @ptrace is false in the normal case, and true to ptrace @child.
170 *
171 * Called with current's siglock and write_lock_irq(&tasklist_lock) held.
172 */
173static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
174{
175 INIT_LIST_HEAD(&child->ptrace_entry);
176 INIT_LIST_HEAD(&child->ptraced);
Frederic Weisbeckerbf26c012011-04-07 16:53:20 +0200177#ifdef CONFIG_HAVE_HW_BREAKPOINT
178 atomic_set(&child->ptrace_bp_refcnt, 1);
179#endif
Oleg Nesterov6634ae12011-07-08 19:13:39 +0200180 child->jobctl = 0;
181 child->ptrace = 0;
182 child->parent = child->real_parent;
183
184 if (unlikely(ptrace) && current->ptrace) {
185 child->ptrace = current->ptrace;
186 __ptrace_link(child, current->parent);
Oleg Nesterovdcace062011-07-08 19:13:54 +0200187
Oleg Nesterovd184d6e2011-07-08 19:14:17 +0200188 if (child->ptrace & PT_SEIZED)
189 task_set_jobctl_pending(child, JOBCTL_TRAP_STOP);
190 else
191 sigaddset(&child->pending.signal, SIGSTOP);
192
Oleg Nesterovdcace062011-07-08 19:13:54 +0200193 set_tsk_thread_flag(child, TIF_SIGPENDING);
Oleg Nesterov6634ae12011-07-08 19:13:39 +0200194 }
Roland McGrath09a05392008-07-25 19:45:47 -0700195}
196
Roland McGrathdae33572008-07-25 19:45:48 -0700197/**
198 * ptrace_release_task - final ptrace-related cleanup of a zombie being reaped
199 * @task: task in %EXIT_DEAD state
200 *
201 * Called with write_lock(&tasklist_lock) held.
202 */
203static inline void ptrace_release_task(struct task_struct *task)
204{
205 BUG_ON(!list_empty(&task->ptraced));
206 ptrace_unlink(task);
207 BUG_ON(!list_empty(&task->ptrace_entry));
208}
209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210#ifndef force_successful_syscall_return
211/*
212 * System call handlers that, upon successful completion, need to return a
213 * negative value should call force_successful_syscall_return() right before
214 * returning. On architectures where the syscall convention provides for a
215 * separate error flag (e.g., alpha, ia64, ppc{,64}, sparc{,64}, possibly
216 * others), this macro can be used to ensure that the error flag will not get
217 * set. On architectures which do not support a separate error flag, the macro
218 * is a no-op and the spurious error condition needs to be filtered out by some
219 * other means (e.g., in user-level, by passing an extra argument to the
220 * syscall handler, or something along those lines).
221 */
222#define force_successful_syscall_return() do { } while (0)
223#endif
224
Eric Parisd7e75282012-01-03 14:23:06 -0500225#ifndef is_syscall_success
226/*
227 * On most systems we can tell if a syscall is a success based on if the retval
228 * is an error value. On some systems like ia64 and powerpc they have different
229 * indicators of success/failure and must define their own.
230 */
231#define is_syscall_success(regs) (!IS_ERR_VALUE((unsigned long)(regs_return_value(regs))))
232#endif
233
Roland McGrathfb7fa8f2008-01-30 13:30:47 +0100234/*
235 * <asm/ptrace.h> should define the following things inside #ifdef __KERNEL__.
236 *
237 * These do-nothing inlines are used when the arch does not
238 * implement single-step. The kerneldoc comments are here
239 * to document the interface for all arch definitions.
240 */
241
242#ifndef arch_has_single_step
243/**
244 * arch_has_single_step - does this CPU support user-mode single-step?
245 *
246 * If this is defined, then there must be function declarations or
247 * inlines for user_enable_single_step() and user_disable_single_step().
248 * arch_has_single_step() should evaluate to nonzero iff the machine
249 * supports instruction single-step for user mode.
250 * It can be a constant or it can test a CPU feature bit.
251 */
252#define arch_has_single_step() (0)
253
254/**
255 * user_enable_single_step - single-step in user-mode task
256 * @task: either current or a task stopped in %TASK_TRACED
257 *
258 * This can only be called when arch_has_single_step() has returned nonzero.
259 * Set @task so that when it returns to user mode, it will trap after the
Roland McGrathdc802c22008-01-30 13:30:53 +0100260 * next single instruction executes. If arch_has_block_step() is defined,
261 * this must clear the effects of user_enable_block_step() too.
Roland McGrathfb7fa8f2008-01-30 13:30:47 +0100262 */
263static inline void user_enable_single_step(struct task_struct *task)
264{
265 BUG(); /* This can never be called. */
266}
267
268/**
269 * user_disable_single_step - cancel user-mode single-step
270 * @task: either current or a task stopped in %TASK_TRACED
271 *
Roland McGrathdc802c22008-01-30 13:30:53 +0100272 * Clear @task of the effects of user_enable_single_step() and
273 * user_enable_block_step(). This can be called whether or not either
274 * of those was ever called on @task, and even if arch_has_single_step()
275 * returned zero.
Roland McGrathfb7fa8f2008-01-30 13:30:47 +0100276 */
277static inline void user_disable_single_step(struct task_struct *task)
278{
279}
Christoph Hellwigdacbe412010-03-10 15:22:46 -0800280#else
281extern void user_enable_single_step(struct task_struct *);
282extern void user_disable_single_step(struct task_struct *);
Roland McGrathfb7fa8f2008-01-30 13:30:47 +0100283#endif /* arch_has_single_step */
284
Roland McGrathdc802c22008-01-30 13:30:53 +0100285#ifndef arch_has_block_step
286/**
287 * arch_has_block_step - does this CPU support user-mode block-step?
288 *
289 * If this is defined, then there must be a function declaration or inline
290 * for user_enable_block_step(), and arch_has_single_step() must be defined
291 * too. arch_has_block_step() should evaluate to nonzero iff the machine
292 * supports step-until-branch for user mode. It can be a constant or it
293 * can test a CPU feature bit.
294 */
Roland McGrath5b88abb2008-01-30 13:30:53 +0100295#define arch_has_block_step() (0)
Roland McGrathdc802c22008-01-30 13:30:53 +0100296
297/**
298 * user_enable_block_step - step until branch in user-mode task
299 * @task: either current or a task stopped in %TASK_TRACED
300 *
301 * This can only be called when arch_has_block_step() has returned nonzero,
302 * and will never be called when single-instruction stepping is being used.
303 * Set @task so that when it returns to user mode, it will trap after the
304 * next branch or trap taken.
305 */
306static inline void user_enable_block_step(struct task_struct *task)
307{
308 BUG(); /* This can never be called. */
309}
Christoph Hellwigdacbe412010-03-10 15:22:46 -0800310#else
311extern void user_enable_block_step(struct task_struct *);
Roland McGrathdc802c22008-01-30 13:30:53 +0100312#endif /* arch_has_block_step */
313
Oleg Nesterov85ec7fd2009-12-15 16:47:17 -0800314#ifdef ARCH_HAS_USER_SINGLE_STEP_INFO
315extern void user_single_step_siginfo(struct task_struct *tsk,
316 struct pt_regs *regs, siginfo_t *info);
317#else
318static inline void user_single_step_siginfo(struct task_struct *tsk,
319 struct pt_regs *regs, siginfo_t *info)
320{
321 memset(info, 0, sizeof(*info));
322 info->si_signo = SIGTRAP;
323}
324#endif
325
Roland McGrath1a669c22008-02-06 01:37:37 -0800326#ifndef arch_ptrace_stop_needed
327/**
328 * arch_ptrace_stop_needed - Decide whether arch_ptrace_stop() should be called
329 * @code: current->exit_code value ptrace will stop with
330 * @info: siginfo_t pointer (or %NULL) for signal ptrace will stop with
331 *
332 * This is called with the siglock held, to decide whether or not it's
333 * necessary to release the siglock and call arch_ptrace_stop() with the
334 * same @code and @info arguments. It can be defined to a constant if
335 * arch_ptrace_stop() is never required, or always is. On machines where
336 * this makes sense, it should be defined to a quick test to optimize out
337 * calling arch_ptrace_stop() when it would be superfluous. For example,
338 * if the thread has not been back to user mode since the last stop, the
339 * thread state might indicate that nothing needs to be done.
Tejun Heo8c6fa0a2014-07-03 15:43:15 -0400340 *
341 * This is guaranteed to be invoked once before a task stops for ptrace and
342 * may include arch-specific operations necessary prior to a ptrace stop.
Roland McGrath1a669c22008-02-06 01:37:37 -0800343 */
344#define arch_ptrace_stop_needed(code, info) (0)
345#endif
346
347#ifndef arch_ptrace_stop
348/**
349 * arch_ptrace_stop - Do machine-specific work before stopping for ptrace
350 * @code: current->exit_code value ptrace will stop with
351 * @info: siginfo_t pointer (or %NULL) for signal ptrace will stop with
352 *
353 * This is called with no locks held when arch_ptrace_stop_needed() has
354 * just returned nonzero. It is allowed to block, e.g. for user memory
355 * access. The arch can have machine-specific work to be done before
356 * ptrace stops. On ia64, register backing store gets written back to user
357 * memory here. Since this can be costly (requires dropping the siglock),
358 * we only do it when the arch requires it for this particular stop, as
359 * indicated by arch_ptrace_stop_needed().
360 */
361#define arch_ptrace_stop(code, info) do { } while (0)
362#endif
363
Al Viroa3460a52012-09-30 13:12:36 -0400364#ifndef current_pt_regs
365#define current_pt_regs() task_pt_regs(current)
366#endif
367
Al Viro4f4202f2012-11-05 12:59:15 -0500368#ifndef ptrace_signal_deliver
Al Virob7f95912012-11-05 13:06:22 -0500369#define ptrace_signal_deliver() ((void)0)
Al Viro4f4202f2012-11-05 12:59:15 -0500370#endif
371
Al Viro22062a92012-11-05 13:00:27 -0500372/*
373 * unlike current_pt_regs(), this one is equal to task_pt_regs(current)
374 * on *all* architectures; the only reason to have a per-arch definition
375 * is optimisation.
376 */
377#ifndef signal_pt_regs
378#define signal_pt_regs() task_pt_regs(current)
379#endif
380
Al Viro1ca97bb2012-11-18 12:50:10 -0500381#ifndef current_user_stack_pointer
382#define current_user_stack_pointer() user_stack_pointer(current_pt_regs())
383#endif
384
Roland McGrathbbc69862008-07-25 19:45:59 -0700385extern int task_current_syscall(struct task_struct *target, long *callno,
386 unsigned long args[6], unsigned int maxargs,
387 unsigned long *sp, unsigned long *pc);
388
Frederic Weisbeckerbf26c012011-04-07 16:53:20 +0200389#ifdef CONFIG_HAVE_HW_BREAKPOINT
390extern int ptrace_get_breakpoints(struct task_struct *tsk);
391extern void ptrace_put_breakpoints(struct task_struct *tsk);
392#else
393static inline void ptrace_put_breakpoints(struct task_struct *tsk) { }
394#endif /* CONFIG_HAVE_HW_BREAKPOINT */
395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396#endif