blob: 8cffd34f88d53d8d03e3bf059834b5b5bf6da33e [file] [log] [blame]
Roland McGrath88ac2922008-07-25 19:45:43 -07001/*
2 * Tracing hooks
3 *
4 * Copyright (C) 2008 Red Hat, Inc. All rights reserved.
5 *
6 * This copyrighted material is made available to anyone wishing to use,
7 * modify, copy, or redistribute it subject to the terms and conditions
8 * of the GNU General Public License v.2.
9 *
10 * This file defines hook entry points called by core code where
11 * user tracing/debugging support might need to do something. These
12 * entry points are called tracehook_*(). Each hook declared below
13 * has a detailed kerneldoc comment giving the context (locking et
14 * al) from which it is called, and the meaning of its return value.
15 *
16 * Each function here typically has only one call site, so it is ok
17 * to have some nontrivial tracehook_*() inlines. In all cases, the
18 * fast path when no tracing is enabled should be very short.
19 *
20 * The purpose of this file and the tracehook_* layer is to consolidate
21 * the interface that the kernel core and arch code uses to enable any
22 * user debugging or tracing facility (such as ptrace). The interfaces
23 * here are carefully documented so that maintainers of core and arch
24 * code do not need to think about the implementation details of the
25 * tracing facilities. Likewise, maintainers of the tracing code do not
26 * need to understand all the calling core or arch code in detail, just
27 * documented circumstances of each call, such as locking conditions.
28 *
29 * If the calling core code changes so that locking is different, then
30 * it is ok to change the interface documented here. The maintainer of
31 * core code changing should notify the maintainers of the tracing code
32 * that they need to work out the change.
33 *
34 * Some tracehook_*() inlines take arguments that the current tracing
35 * implementations might not necessarily use. These function signatures
36 * are chosen to pass in all the information that is on hand in the
37 * caller and might conceivably be relevant to a tracer, so that the
38 * core code won't have to be updated when tracing adds more features.
39 * If a call site changes so that some of those parameters are no longer
40 * already on hand without extra work, then the tracehook_* interface
41 * can change so there is no make-work burden on the core code. The
42 * maintainer of core code changing should notify the maintainers of the
43 * tracing code that they need to work out the change.
44 */
45
46#ifndef _LINUX_TRACEHOOK_H
47#define _LINUX_TRACEHOOK_H 1
48
49#include <linux/sched.h>
50#include <linux/ptrace.h>
Roland McGrath6341c392008-07-25 19:45:44 -070051#include <linux/security.h>
52struct linux_binprm;
53
54/**
Roland McGrathfa8e26c2008-07-25 19:45:50 -070055 * tracehook_expect_breakpoints - guess if task memory might be touched
56 * @task: current task, making a new mapping
57 *
58 * Return nonzero if @task is expected to want breakpoint insertion in
59 * its memory at some point. A zero return is no guarantee it won't
60 * be done, but this is a hint that it's known to be likely.
61 *
62 * May be called with @task->mm->mmap_sem held for writing.
63 */
64static inline int tracehook_expect_breakpoints(struct task_struct *task)
65{
66 return (task_ptrace(task) & PT_PTRACED) != 0;
67}
68
69/**
Roland McGrath6341c392008-07-25 19:45:44 -070070 * tracehook_unsafe_exec - check for exec declared unsafe due to tracing
71 * @task: current task doing exec
72 *
73 * Return %LSM_UNSAFE_* bits applied to an exec because of tracing.
74 *
75 * Called with task_lock() held on @task.
76 */
77static inline int tracehook_unsafe_exec(struct task_struct *task)
78{
79 int unsafe = 0;
80 int ptrace = task_ptrace(task);
81 if (ptrace & PT_PTRACED) {
82 if (ptrace & PT_PTRACE_CAP)
83 unsafe |= LSM_UNSAFE_PTRACE_CAP;
84 else
85 unsafe |= LSM_UNSAFE_PTRACE;
86 }
87 return unsafe;
88}
89
90/**
Roland McGrath0d094ef2008-07-25 19:45:49 -070091 * tracehook_tracer_task - return the task that is tracing the given task
92 * @tsk: task to consider
93 *
94 * Returns NULL if noone is tracing @task, or the &struct task_struct
95 * pointer to its tracer.
96 *
97 * Must called under rcu_read_lock(). The pointer returned might be kept
98 * live only by RCU. During exec, this may be called with task_lock()
99 * held on @task, still held from when tracehook_unsafe_exec() was called.
100 */
101static inline struct task_struct *tracehook_tracer_task(struct task_struct *tsk)
102{
103 if (task_ptrace(tsk) & PT_PTRACED)
104 return rcu_dereference(tsk->parent);
105 return NULL;
106}
107
108/**
Roland McGrath6341c392008-07-25 19:45:44 -0700109 * tracehook_report_exec - a successful exec was completed
110 * @fmt: &struct linux_binfmt that performed the exec
111 * @bprm: &struct linux_binprm containing exec details
112 * @regs: user-mode register state
113 *
114 * An exec just completed, we are shortly going to return to user mode.
115 * The freshly initialized register state can be seen and changed in @regs.
116 * The name, file and other pointers in @bprm are still on hand to be
117 * inspected, but will be freed as soon as this returns.
118 *
119 * Called with no locks, but with some kernel resources held live
120 * and a reference on @fmt->module.
121 */
122static inline void tracehook_report_exec(struct linux_binfmt *fmt,
123 struct linux_binprm *bprm,
124 struct pt_regs *regs)
125{
126 if (!ptrace_event(PT_TRACE_EXEC, PTRACE_EVENT_EXEC, 0) &&
127 unlikely(task_ptrace(current) & PT_PTRACED))
128 send_sig(SIGTRAP, current, 0);
129}
Roland McGrath88ac2922008-07-25 19:45:43 -0700130
Roland McGrath30199f52008-07-25 19:45:46 -0700131/**
132 * tracehook_report_exit - task has begun to exit
133 * @exit_code: pointer to value destined for @current->exit_code
134 *
135 * @exit_code points to the value passed to do_exit(), which tracing
136 * might change here. This is almost the first thing in do_exit(),
137 * before freeing any resources or setting the %PF_EXITING flag.
138 *
139 * Called with no locks held.
140 */
141static inline void tracehook_report_exit(long *exit_code)
142{
143 ptrace_event(PT_TRACE_EXIT, PTRACE_EVENT_EXIT, *exit_code);
144}
145
Roland McGrath09a05392008-07-25 19:45:47 -0700146/**
147 * tracehook_prepare_clone - prepare for new child to be cloned
148 * @clone_flags: %CLONE_* flags from clone/fork/vfork system call
149 *
150 * This is called before a new user task is to be cloned.
151 * Its return value will be passed to tracehook_finish_clone().
152 *
153 * Called with no locks held.
154 */
155static inline int tracehook_prepare_clone(unsigned clone_flags)
156{
157 if (clone_flags & CLONE_UNTRACED)
158 return 0;
159
160 if (clone_flags & CLONE_VFORK) {
161 if (current->ptrace & PT_TRACE_VFORK)
162 return PTRACE_EVENT_VFORK;
163 } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
164 if (current->ptrace & PT_TRACE_CLONE)
165 return PTRACE_EVENT_CLONE;
166 } else if (current->ptrace & PT_TRACE_FORK)
167 return PTRACE_EVENT_FORK;
168
169 return 0;
170}
171
172/**
173 * tracehook_finish_clone - new child created and being attached
174 * @child: new child task
175 * @clone_flags: %CLONE_* flags from clone/fork/vfork system call
176 * @trace: return value from tracehook_clone_prepare()
177 *
178 * This is called immediately after adding @child to its parent's children list.
179 * The @trace value is that returned by tracehook_prepare_clone().
180 *
181 * Called with current's siglock and write_lock_irq(&tasklist_lock) held.
182 */
183static inline void tracehook_finish_clone(struct task_struct *child,
184 unsigned long clone_flags, int trace)
185{
186 ptrace_init_task(child, (clone_flags & CLONE_PTRACE) || trace);
187}
188
189/**
190 * tracehook_report_clone - in parent, new child is about to start running
191 * @trace: return value from tracehook_clone_prepare()
192 * @regs: parent's user register state
193 * @clone_flags: flags from parent's system call
194 * @pid: new child's PID in the parent's namespace
195 * @child: new child task
196 *
197 * Called after a child is set up, but before it has been started running.
198 * The @trace value is that returned by tracehook_clone_prepare().
199 * This is not a good place to block, because the child has not started yet.
200 * Suspend the child here if desired, and block in tracehook_clone_complete().
201 * This must prevent the child from self-reaping if tracehook_clone_complete()
202 * uses the @child pointer; otherwise it might have died and been released by
203 * the time tracehook_report_clone_complete() is called.
204 *
205 * Called with no locks held, but the child cannot run until this returns.
206 */
207static inline void tracehook_report_clone(int trace, struct pt_regs *regs,
208 unsigned long clone_flags,
209 pid_t pid, struct task_struct *child)
210{
211 if (unlikely(trace)) {
212 /*
213 * The child starts up with an immediate SIGSTOP.
214 */
215 sigaddset(&child->pending.signal, SIGSTOP);
216 set_tsk_thread_flag(child, TIF_SIGPENDING);
217 }
218}
219
220/**
221 * tracehook_report_clone_complete - new child is running
222 * @trace: return value from tracehook_clone_prepare()
223 * @regs: parent's user register state
224 * @clone_flags: flags from parent's system call
225 * @pid: new child's PID in the parent's namespace
226 * @child: child task, already running
227 *
228 * This is called just after the child has started running. This is
229 * just before the clone/fork syscall returns, or blocks for vfork
230 * child completion if @clone_flags has the %CLONE_VFORK bit set.
231 * The @child pointer may be invalid if a self-reaping child died and
232 * tracehook_report_clone() took no action to prevent it from self-reaping.
233 *
234 * Called with no locks held.
235 */
236static inline void tracehook_report_clone_complete(int trace,
237 struct pt_regs *regs,
238 unsigned long clone_flags,
239 pid_t pid,
240 struct task_struct *child)
241{
242 if (unlikely(trace))
243 ptrace_event(0, trace, pid);
244}
245
Roland McGrathdaded342008-07-25 19:45:47 -0700246/**
247 * tracehook_report_vfork_done - vfork parent's child has exited or exec'd
248 * @child: child task, already running
249 * @pid: new child's PID in the parent's namespace
250 *
251 * Called after a %CLONE_VFORK parent has waited for the child to complete.
252 * The clone/vfork system call will return immediately after this.
253 * The @child pointer may be invalid if a self-reaping child died and
254 * tracehook_report_clone() took no action to prevent it from self-reaping.
255 *
256 * Called with no locks held.
257 */
258static inline void tracehook_report_vfork_done(struct task_struct *child,
259 pid_t pid)
260{
261 ptrace_event(PT_TRACE_VFORK_DONE, PTRACE_EVENT_VFORK_DONE, pid);
262}
263
Roland McGrathdae33572008-07-25 19:45:48 -0700264/**
265 * tracehook_prepare_release_task - task is being reaped, clean up tracing
266 * @task: task in %EXIT_DEAD state
267 *
268 * This is called in release_task() just before @task gets finally reaped
269 * and freed. This would be the ideal place to remove and clean up any
270 * tracing-related state for @task.
271 *
272 * Called with no locks held.
273 */
274static inline void tracehook_prepare_release_task(struct task_struct *task)
275{
276}
277
278/**
279 * tracehook_finish_release_task - task is being reaped, clean up tracing
280 * @task: task in %EXIT_DEAD state
281 *
282 * This is called in release_task() when @task is being in the middle of
283 * being reaped. After this, there must be no tracing entanglements.
284 *
285 * Called with write_lock_irq(&tasklist_lock) held.
286 */
287static inline void tracehook_finish_release_task(struct task_struct *task)
288{
289 ptrace_release_task(task);
290}
291
Roland McGrathc45aea22008-07-25 19:45:50 -0700292/**
293 * tracehook_signal_handler - signal handler setup is complete
294 * @sig: number of signal being delivered
295 * @info: siginfo_t of signal being delivered
296 * @ka: sigaction setting that chose the handler
297 * @regs: user register state
298 * @stepping: nonzero if debugger single-step or block-step in use
299 *
300 * Called by the arch code after a signal handler has been set up.
301 * Register and stack state reflects the user handler about to run.
302 * Signal mask changes have already been made.
303 *
304 * Called without locks, shortly before returning to user mode
305 * (or handling more signals).
306 */
307static inline void tracehook_signal_handler(int sig, siginfo_t *info,
308 const struct k_sigaction *ka,
309 struct pt_regs *regs, int stepping)
310{
311 if (stepping)
312 ptrace_notify(SIGTRAP);
313}
314
Roland McGrath35de2542008-07-25 19:45:51 -0700315/**
316 * tracehook_consider_ignored_signal - suppress short-circuit of ignored signal
317 * @task: task receiving the signal
318 * @sig: signal number being sent
319 * @handler: %SIG_IGN or %SIG_DFL
320 *
321 * Return zero iff tracing doesn't care to examine this ignored signal,
322 * so it can short-circuit normal delivery and never even get queued.
323 * Either @handler is %SIG_DFL and @sig's default is ignore, or it's %SIG_IGN.
324 *
325 * Called with @task->sighand->siglock held.
326 */
327static inline int tracehook_consider_ignored_signal(struct task_struct *task,
328 int sig,
329 void __user *handler)
330{
331 return (task_ptrace(task) & PT_PTRACED) != 0;
332}
333
Roland McGrath88ac2922008-07-25 19:45:43 -0700334#endif /* <linux/tracehook.h> */