![Roland McGrath](/assets/img/avatar_default.png)
This moves the PTRACE_EVENT_EXIT tracing into a tracehook.h inline, tracehook_report_exec(). The change has no effect, just clean-up. Signed-off-by: Roland McGrath <roland@redhat.com> Cc: Oleg Nesterov <oleg@tv-sign.ru> Reviewed-by: Ingo Molnar <mingo@elte.hu> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
114 lines
4.3 KiB
C
114 lines
4.3 KiB
C
/*
|
|
* Tracing hooks
|
|
*
|
|
* Copyright (C) 2008 Red Hat, Inc. All rights reserved.
|
|
*
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
|
* of the GNU General Public License v.2.
|
|
*
|
|
* This file defines hook entry points called by core code where
|
|
* user tracing/debugging support might need to do something. These
|
|
* entry points are called tracehook_*(). Each hook declared below
|
|
* has a detailed kerneldoc comment giving the context (locking et
|
|
* al) from which it is called, and the meaning of its return value.
|
|
*
|
|
* Each function here typically has only one call site, so it is ok
|
|
* to have some nontrivial tracehook_*() inlines. In all cases, the
|
|
* fast path when no tracing is enabled should be very short.
|
|
*
|
|
* The purpose of this file and the tracehook_* layer is to consolidate
|
|
* the interface that the kernel core and arch code uses to enable any
|
|
* user debugging or tracing facility (such as ptrace). The interfaces
|
|
* here are carefully documented so that maintainers of core and arch
|
|
* code do not need to think about the implementation details of the
|
|
* tracing facilities. Likewise, maintainers of the tracing code do not
|
|
* need to understand all the calling core or arch code in detail, just
|
|
* documented circumstances of each call, such as locking conditions.
|
|
*
|
|
* If the calling core code changes so that locking is different, then
|
|
* it is ok to change the interface documented here. The maintainer of
|
|
* core code changing should notify the maintainers of the tracing code
|
|
* that they need to work out the change.
|
|
*
|
|
* Some tracehook_*() inlines take arguments that the current tracing
|
|
* implementations might not necessarily use. These function signatures
|
|
* are chosen to pass in all the information that is on hand in the
|
|
* caller and might conceivably be relevant to a tracer, so that the
|
|
* core code won't have to be updated when tracing adds more features.
|
|
* If a call site changes so that some of those parameters are no longer
|
|
* already on hand without extra work, then the tracehook_* interface
|
|
* can change so there is no make-work burden on the core code. The
|
|
* maintainer of core code changing should notify the maintainers of the
|
|
* tracing code that they need to work out the change.
|
|
*/
|
|
|
|
#ifndef _LINUX_TRACEHOOK_H
|
|
#define _LINUX_TRACEHOOK_H 1
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/ptrace.h>
|
|
#include <linux/security.h>
|
|
struct linux_binprm;
|
|
|
|
/**
|
|
* tracehook_unsafe_exec - check for exec declared unsafe due to tracing
|
|
* @task: current task doing exec
|
|
*
|
|
* Return %LSM_UNSAFE_* bits applied to an exec because of tracing.
|
|
*
|
|
* Called with task_lock() held on @task.
|
|
*/
|
|
static inline int tracehook_unsafe_exec(struct task_struct *task)
|
|
{
|
|
int unsafe = 0;
|
|
int ptrace = task_ptrace(task);
|
|
if (ptrace & PT_PTRACED) {
|
|
if (ptrace & PT_PTRACE_CAP)
|
|
unsafe |= LSM_UNSAFE_PTRACE_CAP;
|
|
else
|
|
unsafe |= LSM_UNSAFE_PTRACE;
|
|
}
|
|
return unsafe;
|
|
}
|
|
|
|
/**
|
|
* tracehook_report_exec - a successful exec was completed
|
|
* @fmt: &struct linux_binfmt that performed the exec
|
|
* @bprm: &struct linux_binprm containing exec details
|
|
* @regs: user-mode register state
|
|
*
|
|
* An exec just completed, we are shortly going to return to user mode.
|
|
* The freshly initialized register state can be seen and changed in @regs.
|
|
* The name, file and other pointers in @bprm are still on hand to be
|
|
* inspected, but will be freed as soon as this returns.
|
|
*
|
|
* Called with no locks, but with some kernel resources held live
|
|
* and a reference on @fmt->module.
|
|
*/
|
|
static inline void tracehook_report_exec(struct linux_binfmt *fmt,
|
|
struct linux_binprm *bprm,
|
|
struct pt_regs *regs)
|
|
{
|
|
if (!ptrace_event(PT_TRACE_EXEC, PTRACE_EVENT_EXEC, 0) &&
|
|
unlikely(task_ptrace(current) & PT_PTRACED))
|
|
send_sig(SIGTRAP, current, 0);
|
|
}
|
|
|
|
/**
|
|
* tracehook_report_exit - task has begun to exit
|
|
* @exit_code: pointer to value destined for @current->exit_code
|
|
*
|
|
* @exit_code points to the value passed to do_exit(), which tracing
|
|
* might change here. This is almost the first thing in do_exit(),
|
|
* before freeing any resources or setting the %PF_EXITING flag.
|
|
*
|
|
* Called with no locks held.
|
|
*/
|
|
static inline void tracehook_report_exit(long *exit_code)
|
|
{
|
|
ptrace_event(PT_TRACE_EXIT, PTRACE_EVENT_EXIT, *exit_code);
|
|
}
|
|
|
|
#endif /* <linux/tracehook.h> */
|