2019-05-27 06:55:05 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Kernel Probes (KProbes)
|
|
|
|
*
|
|
|
|
* Copyright (C) IBM Corporation, 2002, 2004
|
|
|
|
*
|
|
|
|
* 2002-Oct Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
|
|
|
|
* Probes initial implementation ( includes contributions from
|
|
|
|
* Rusty Russell).
|
|
|
|
* 2004-July Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
|
|
|
|
* interface to access function arguments.
|
|
|
|
* 2004-Nov Ananth N Mavinakayanahalli <ananth@in.ibm.com> kprobes port
|
|
|
|
* for PPC64
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/preempt.h>
|
2016-08-16 14:57:34 +00:00
|
|
|
#include <linux/extable.h>
|
2007-05-08 07:27:03 +00:00
|
|
|
#include <linux/kdebug.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2021-06-09 01:34:26 +00:00
|
|
|
#include <linux/moduleloader.h>
|
2014-06-23 03:23:31 +00:00
|
|
|
#include <asm/code-patching.h>
|
2005-06-23 07:09:25 +00:00
|
|
|
#include <asm/cacheflush.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/sstep.h>
|
2017-04-19 15:29:51 +00:00
|
|
|
#include <asm/sections.h>
|
2020-05-06 03:40:26 +00:00
|
|
|
#include <asm/inst.h>
|
2021-06-09 01:34:26 +00:00
|
|
|
#include <asm/set_memory.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2008-06-26 07:01:37 +00:00
|
|
|
|
2005-11-07 09:00:10 +00:00
|
|
|
DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
|
|
|
|
DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-10-16 08:27:49 +00:00
|
|
|
struct kretprobe_blackpoint kretprobe_blacklist[] = {{NULL, NULL}};
|
|
|
|
|
2017-04-19 15:29:51 +00:00
|
|
|
bool arch_within_kprobe_blacklist(unsigned long addr)
|
|
|
|
{
|
|
|
|
return (addr >= (unsigned long)__kprobes_text_start &&
|
|
|
|
addr < (unsigned long)__kprobes_text_end) ||
|
|
|
|
(addr >= (unsigned long)_stext &&
|
|
|
|
addr < (unsigned long)__head_end);
|
|
|
|
}
|
|
|
|
|
2017-04-19 12:51:01 +00:00
|
|
|
kprobe_opcode_t *kprobe_lookup_name(const char *name, unsigned int offset)
|
2017-04-19 12:51:00 +00:00
|
|
|
{
|
2017-10-23 16:37:41 +00:00
|
|
|
kprobe_opcode_t *addr = NULL;
|
2017-04-19 12:51:00 +00:00
|
|
|
|
2022-05-09 05:36:07 +00:00
|
|
|
#ifdef CONFIG_PPC64_ELF_ABI_V2
|
2017-04-19 12:51:00 +00:00
|
|
|
/* PPC64 ABIv2 needs local entry point */
|
|
|
|
addr = (kprobe_opcode_t *)kallsyms_lookup_name(name);
|
2017-04-19 12:52:28 +00:00
|
|
|
if (addr && !offset) {
|
|
|
|
#ifdef CONFIG_KPROBES_ON_FTRACE
|
|
|
|
unsigned long faddr;
|
|
|
|
/*
|
|
|
|
* Per livepatch.h, ftrace location is always within the first
|
|
|
|
* 16 bytes of a function on powerpc with -mprofile-kernel.
|
|
|
|
*/
|
|
|
|
faddr = ftrace_location_range((unsigned long)addr,
|
|
|
|
(unsigned long)addr + 16);
|
|
|
|
if (faddr)
|
|
|
|
addr = (kprobe_opcode_t *)faddr;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
addr = (kprobe_opcode_t *)ppc_function_entry(addr);
|
|
|
|
}
|
2022-05-09 05:36:07 +00:00
|
|
|
#elif defined(CONFIG_PPC64_ELF_ABI_V1)
|
2017-04-19 12:51:00 +00:00
|
|
|
/*
|
|
|
|
* 64bit powerpc ABIv1 uses function descriptors:
|
|
|
|
* - Check for the dot variant of the symbol first.
|
|
|
|
* - If that fails, try looking up the symbol provided.
|
|
|
|
*
|
|
|
|
* This ensures we always get to the actual symbol and not
|
|
|
|
* the descriptor.
|
|
|
|
*
|
|
|
|
* Also handle <module:symbol> format.
|
|
|
|
*/
|
|
|
|
char dot_name[MODULE_NAME_LEN + 1 + KSYM_NAME_LEN];
|
|
|
|
bool dot_appended = false;
|
2017-10-23 16:37:41 +00:00
|
|
|
const char *c;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
if ((c = strnchr(name, MODULE_NAME_LEN, ':')) != NULL) {
|
|
|
|
c++;
|
|
|
|
len = c - name;
|
|
|
|
memcpy(dot_name, name, len);
|
|
|
|
} else
|
|
|
|
c = name;
|
|
|
|
|
|
|
|
if (*c != '\0' && *c != '.') {
|
|
|
|
dot_name[len++] = '.';
|
2017-04-19 12:51:00 +00:00
|
|
|
dot_appended = true;
|
|
|
|
}
|
2017-10-23 16:37:41 +00:00
|
|
|
ret = strscpy(dot_name + len, c, KSYM_NAME_LEN);
|
|
|
|
if (ret > 0)
|
|
|
|
addr = (kprobe_opcode_t *)kallsyms_lookup_name(dot_name);
|
|
|
|
|
|
|
|
/* Fallback to the original non-dot symbol lookup */
|
|
|
|
if (!addr && dot_appended)
|
2017-04-19 12:51:00 +00:00
|
|
|
addr = (kprobe_opcode_t *)kallsyms_lookup_name(name);
|
|
|
|
#else
|
|
|
|
addr = (kprobe_opcode_t *)kallsyms_lookup_name(name);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2022-03-08 15:30:32 +00:00
|
|
|
static bool arch_kprobe_on_func_entry(unsigned long offset)
|
|
|
|
{
|
2022-05-09 05:36:07 +00:00
|
|
|
#ifdef CONFIG_PPC64_ELF_ABI_V2
|
2022-03-08 15:30:32 +00:00
|
|
|
#ifdef CONFIG_KPROBES_ON_FTRACE
|
|
|
|
return offset <= 16;
|
|
|
|
#else
|
|
|
|
return offset <= 8;
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
return !offset;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX try and fold the magic of kprobe_lookup_name() in this */
|
|
|
|
kprobe_opcode_t *arch_adjust_kprobe_addr(unsigned long addr, unsigned long offset,
|
|
|
|
bool *on_func_entry)
|
|
|
|
{
|
|
|
|
*on_func_entry = arch_kprobe_on_func_entry(offset);
|
|
|
|
return (kprobe_opcode_t *)(addr + offset);
|
|
|
|
}
|
|
|
|
|
2021-06-09 01:34:26 +00:00
|
|
|
void *alloc_insn_page(void)
|
|
|
|
{
|
|
|
|
void *page;
|
|
|
|
|
|
|
|
page = module_alloc(PAGE_SIZE);
|
|
|
|
if (!page)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (strict_module_rwx_enabled()) {
|
|
|
|
set_memory_ro((unsigned long)page, 1);
|
|
|
|
set_memory_x((unsigned long)page, 1);
|
|
|
|
}
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
int arch_prepare_kprobe(struct kprobe *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-08 22:49:41 +00:00
|
|
|
int ret = 0;
|
2020-05-06 03:40:47 +00:00
|
|
|
struct kprobe *prev;
|
2021-11-29 17:49:38 +00:00
|
|
|
ppc_inst_t insn = ppc_inst_read(p->addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-08 22:49:41 +00:00
|
|
|
if ((unsigned long)p->addr & 0x03) {
|
|
|
|
printk("Attempt to register kprobe at an unaligned address\n");
|
|
|
|
ret = -EINVAL;
|
powerpc: Reject probes on instructions that can't be single stepped
Per the ISA, a Trace interrupt is not generated for:
- [h|u]rfi[d]
- rfscv
- sc, scv, and Trap instructions that trap
- Power-Saving Mode instructions
- other instructions that cause interrupts (other than Trace interrupts)
- the first instructions of any interrupt handler (applies to Branch and Single Step tracing;
CIABR matches may still occur)
- instructions that are emulated by software
Add a helper to check for instructions belonging to the first four
categories above and to reject kprobes, uprobes and xmon breakpoints on
such instructions. We reject probing on instructions belonging to these
categories across all ISA versions and across both BookS and BookE.
For trap instructions, we can't know in advance if they can cause a
trap, and there is no good reason to allow probing on those. Also,
uprobes already refuses to probe trap instructions and kprobes does not
allow probes on trap instructions used for kernel warnings and bugs. As
such, stop allowing any type of probes/breakpoints on trap instruction
across uprobes, kprobes and xmon.
For some of the fp/altivec instructions that can generate an interrupt
and which we emulate in the kernel (altivec assist, for example), we
check and turn off single stepping in emulate_single_step().
Instructions generating a DSI are restarted and single stepping normally
completes once the instruction is completed.
In uprobes, if a single stepped instruction results in a non-fatal
signal to be delivered to the task, such signals are "delayed" until
after the instruction completes. For fatal signals, single stepping is
cancelled and the instruction restarted in-place so that core dump
captures proper addresses.
In kprobes, we do not allow probes on instructions having an extable
entry and we also do not allow probing interrupt vectors.
Signed-off-by: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/f56ee979d50b8711fae350fc97870f3ca34acd75.1648648712.git.naveen.n.rao@linux.vnet.ibm.com
2022-03-30 14:07:18 +00:00
|
|
|
} else if (!can_single_step(ppc_inst_val(insn))) {
|
|
|
|
printk("Cannot register a kprobe on instructions that can't be single stepped\n");
|
2005-06-08 22:49:41 +00:00
|
|
|
ret = -EINVAL;
|
2021-05-19 10:47:17 +00:00
|
|
|
} else if ((unsigned long)p->addr & ~PAGE_MASK &&
|
2021-05-20 13:50:45 +00:00
|
|
|
ppc_inst_prefixed(ppc_inst_read(p->addr - 1))) {
|
2020-05-06 03:40:47 +00:00
|
|
|
printk("Cannot register a kprobe on the second word of prefixed instruction\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
preempt_disable();
|
|
|
|
prev = get_kprobe(p->addr - 1);
|
|
|
|
preempt_enable_no_resched();
|
2021-05-20 13:50:45 +00:00
|
|
|
if (prev && ppc_inst_prefixed(ppc_inst_read(prev->ainsn.insn))) {
|
2020-05-06 03:40:47 +00:00
|
|
|
printk("Cannot register a kprobe on the second word of prefixed instruction\n");
|
|
|
|
ret = -EINVAL;
|
2005-06-08 22:49:41 +00:00
|
|
|
}
|
2005-06-27 22:17:01 +00:00
|
|
|
|
2008-06-26 07:01:37 +00:00
|
|
|
/* insn must be on a special executable page on ppc64. This is
|
|
|
|
* not explicitly required on ppc32 (right now), but it doesn't hurt */
|
2005-06-27 22:17:01 +00:00
|
|
|
if (!ret) {
|
2005-10-01 17:14:17 +00:00
|
|
|
p->ainsn.insn = get_insn_slot();
|
2005-06-27 22:17:01 +00:00
|
|
|
if (!p->ainsn.insn)
|
|
|
|
ret = -ENOMEM;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-10 04:52:43 +00:00
|
|
|
if (!ret) {
|
2021-05-20 13:50:45 +00:00
|
|
|
patch_instruction(p->ainsn.insn, insn);
|
2020-05-06 03:40:32 +00:00
|
|
|
p->opcode = ppc_inst_val(insn);
|
2006-01-10 04:52:43 +00:00
|
|
|
}
|
|
|
|
|
2007-04-18 05:57:51 +00:00
|
|
|
p->ainsn.boostable = 0;
|
2006-01-10 04:52:43 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(arch_prepare_kprobe);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
void arch_arm_kprobe(struct kprobe *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2021-05-19 10:47:21 +00:00
|
|
|
WARN_ON_ONCE(patch_instruction(p->addr, ppc_inst(BREAKPOINT_INSTRUCTION)));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(arch_arm_kprobe);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
void arch_disarm_kprobe(struct kprobe *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2021-05-19 10:47:21 +00:00
|
|
|
WARN_ON_ONCE(patch_instruction(p->addr, ppc_inst(p->opcode)));
|
2005-06-23 07:09:25 +00:00
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(arch_disarm_kprobe);
|
2005-06-23 07:09:25 +00:00
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
void arch_remove_kprobe(struct kprobe *p)
|
2005-06-23 07:09:25 +00:00
|
|
|
{
|
2009-01-06 22:41:50 +00:00
|
|
|
if (p->ainsn.insn) {
|
|
|
|
free_insn_slot(p->ainsn.insn, 0);
|
|
|
|
p->ainsn.insn = NULL;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(arch_remove_kprobe);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
static nokprobe_inline void prepare_singlestep(struct kprobe *p, struct pt_regs *regs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-12-03 15:08:37 +00:00
|
|
|
enable_single_step(regs);
|
2005-06-27 22:17:01 +00:00
|
|
|
|
2006-04-28 12:08:42 +00:00
|
|
|
/*
|
|
|
|
* On powerpc we should single step on the original
|
|
|
|
* instruction even if the probed insn is a trap
|
|
|
|
* variant as values in regs could play a part in
|
|
|
|
* if the trap is taken or not
|
|
|
|
*/
|
2021-06-17 15:51:03 +00:00
|
|
|
regs_set_return_ip(regs, (unsigned long)p->ainsn.insn);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
static nokprobe_inline void save_previous_kprobe(struct kprobe_ctlblk *kcb)
|
2005-11-07 09:00:10 +00:00
|
|
|
{
|
|
|
|
kcb->prev_kprobe.kp = kprobe_running();
|
|
|
|
kcb->prev_kprobe.status = kcb->kprobe_status;
|
|
|
|
kcb->prev_kprobe.saved_msr = kcb->kprobe_saved_msr;
|
|
|
|
}
|
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
static nokprobe_inline void restore_previous_kprobe(struct kprobe_ctlblk *kcb)
|
2005-06-23 07:09:38 +00:00
|
|
|
{
|
powerpc: Replace __get_cpu_var uses
This still has not been merged and now powerpc is the only arch that does
not have this change. Sorry about missing linuxppc-dev before.
V2->V2
- Fix up to work against 3.18-rc1
__get_cpu_var() is used for multiple purposes in the kernel source. One of
them is address calculation via the form &__get_cpu_var(x). This calculates
the address for the instance of the percpu variable of the current processor
based on an offset.
Other use cases are for storing and retrieving data from the current
processors percpu area. __get_cpu_var() can be used as an lvalue when
writing data or on the right side of an assignment.
__get_cpu_var() is defined as :
__get_cpu_var() always only does an address determination. However, store
and retrieve operations could use a segment prefix (or global register on
other platforms) to avoid the address calculation.
this_cpu_write() and this_cpu_read() can directly take an offset into a
percpu area and use optimized assembly code to read and write per cpu
variables.
This patch converts __get_cpu_var into either an explicit address
calculation using this_cpu_ptr() or into a use of this_cpu operations that
use the offset. Thereby address calculations are avoided and less registers
are used when code is generated.
At the end of the patch set all uses of __get_cpu_var have been removed so
the macro is removed too.
The patch set includes passes over all arches as well. Once these operations
are used throughout then specialized macros can be defined in non -x86
arches as well in order to optimize per cpu access by f.e. using a global
register that may be set to the per cpu base.
Transformations done to __get_cpu_var()
1. Determine the address of the percpu instance of the current processor.
DEFINE_PER_CPU(int, y);
int *x = &__get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(&y);
2. Same as #1 but this time an array structure is involved.
DEFINE_PER_CPU(int, y[20]);
int *x = __get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(y);
3. Retrieve the content of the current processors instance of a per cpu
variable.
DEFINE_PER_CPU(int, y);
int x = __get_cpu_var(y)
Converts to
int x = __this_cpu_read(y);
4. Retrieve the content of a percpu struct
DEFINE_PER_CPU(struct mystruct, y);
struct mystruct x = __get_cpu_var(y);
Converts to
memcpy(&x, this_cpu_ptr(&y), sizeof(x));
5. Assignment to a per cpu variable
DEFINE_PER_CPU(int, y)
__get_cpu_var(y) = x;
Converts to
__this_cpu_write(y, x);
6. Increment/Decrement etc of a per cpu variable
DEFINE_PER_CPU(int, y);
__get_cpu_var(y)++
Converts to
__this_cpu_inc(y)
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
CC: Paul Mackerras <paulus@samba.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
[mpe: Fix build errors caused by set/or_softirq_pending(), and rework
assignment in __set_breakpoint() to use memcpy().]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2014-10-21 20:23:25 +00:00
|
|
|
__this_cpu_write(current_kprobe, kcb->prev_kprobe.kp);
|
2005-11-07 09:00:10 +00:00
|
|
|
kcb->kprobe_status = kcb->prev_kprobe.status;
|
|
|
|
kcb->kprobe_saved_msr = kcb->prev_kprobe.saved_msr;
|
2005-06-23 07:09:38 +00:00
|
|
|
}
|
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
static nokprobe_inline void set_current_kprobe(struct kprobe *p, struct pt_regs *regs,
|
2005-11-07 09:00:10 +00:00
|
|
|
struct kprobe_ctlblk *kcb)
|
2005-06-23 07:09:38 +00:00
|
|
|
{
|
powerpc: Replace __get_cpu_var uses
This still has not been merged and now powerpc is the only arch that does
not have this change. Sorry about missing linuxppc-dev before.
V2->V2
- Fix up to work against 3.18-rc1
__get_cpu_var() is used for multiple purposes in the kernel source. One of
them is address calculation via the form &__get_cpu_var(x). This calculates
the address for the instance of the percpu variable of the current processor
based on an offset.
Other use cases are for storing and retrieving data from the current
processors percpu area. __get_cpu_var() can be used as an lvalue when
writing data or on the right side of an assignment.
__get_cpu_var() is defined as :
__get_cpu_var() always only does an address determination. However, store
and retrieve operations could use a segment prefix (or global register on
other platforms) to avoid the address calculation.
this_cpu_write() and this_cpu_read() can directly take an offset into a
percpu area and use optimized assembly code to read and write per cpu
variables.
This patch converts __get_cpu_var into either an explicit address
calculation using this_cpu_ptr() or into a use of this_cpu operations that
use the offset. Thereby address calculations are avoided and less registers
are used when code is generated.
At the end of the patch set all uses of __get_cpu_var have been removed so
the macro is removed too.
The patch set includes passes over all arches as well. Once these operations
are used throughout then specialized macros can be defined in non -x86
arches as well in order to optimize per cpu access by f.e. using a global
register that may be set to the per cpu base.
Transformations done to __get_cpu_var()
1. Determine the address of the percpu instance of the current processor.
DEFINE_PER_CPU(int, y);
int *x = &__get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(&y);
2. Same as #1 but this time an array structure is involved.
DEFINE_PER_CPU(int, y[20]);
int *x = __get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(y);
3. Retrieve the content of the current processors instance of a per cpu
variable.
DEFINE_PER_CPU(int, y);
int x = __get_cpu_var(y)
Converts to
int x = __this_cpu_read(y);
4. Retrieve the content of a percpu struct
DEFINE_PER_CPU(struct mystruct, y);
struct mystruct x = __get_cpu_var(y);
Converts to
memcpy(&x, this_cpu_ptr(&y), sizeof(x));
5. Assignment to a per cpu variable
DEFINE_PER_CPU(int, y)
__get_cpu_var(y) = x;
Converts to
__this_cpu_write(y, x);
6. Increment/Decrement etc of a per cpu variable
DEFINE_PER_CPU(int, y);
__get_cpu_var(y)++
Converts to
__this_cpu_inc(y)
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
CC: Paul Mackerras <paulus@samba.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
[mpe: Fix build errors caused by set/or_softirq_pending(), and rework
assignment in __set_breakpoint() to use memcpy().]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2014-10-21 20:23:25 +00:00
|
|
|
__this_cpu_write(current_kprobe, p);
|
2005-11-07 09:00:10 +00:00
|
|
|
kcb->kprobe_saved_msr = regs->msr;
|
2005-06-23 07:09:38 +00:00
|
|
|
}
|
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
void arch_prepare_kretprobe(struct kretprobe_instance *ri, struct pt_regs *regs)
|
2005-06-27 22:17:15 +00:00
|
|
|
{
|
2007-05-08 07:34:14 +00:00
|
|
|
ri->ret_addr = (kprobe_opcode_t *)regs->link;
|
2020-08-29 13:01:48 +00:00
|
|
|
ri->fp = NULL;
|
2007-05-08 07:34:14 +00:00
|
|
|
|
|
|
|
/* Replace the return addr with trampoline addr */
|
2021-09-14 14:40:54 +00:00
|
|
|
regs->link = (unsigned long)__kretprobe_trampoline;
|
2005-06-27 22:17:15 +00:00
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(arch_prepare_kretprobe);
|
2005-06-27 22:17:15 +00:00
|
|
|
|
2017-09-22 09:10:43 +00:00
|
|
|
static int try_to_emulate(struct kprobe *p, struct pt_regs *regs)
|
2017-04-19 12:51:04 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2021-11-29 17:49:38 +00:00
|
|
|
ppc_inst_t insn = ppc_inst_read(p->ainsn.insn);
|
2017-04-19 12:51:04 +00:00
|
|
|
|
|
|
|
/* regs->nip is also adjusted if emulate_step returns 1 */
|
|
|
|
ret = emulate_step(regs, insn);
|
|
|
|
if (ret > 0) {
|
|
|
|
/*
|
|
|
|
* Once this instruction has been boosted
|
|
|
|
* successfully, set the boostable flag
|
|
|
|
*/
|
|
|
|
if (unlikely(p->ainsn.boostable == 0))
|
|
|
|
p->ainsn.boostable = 1;
|
|
|
|
} else if (ret < 0) {
|
|
|
|
/*
|
|
|
|
* We don't allow kprobes on mtmsr(d)/rfi(d), etc.
|
|
|
|
* So, we should never get here... but, its still
|
|
|
|
* good to catch them, just in case...
|
|
|
|
*/
|
2020-06-02 05:27:25 +00:00
|
|
|
printk("Can't step on instruction %s\n", ppc_inst_as_str(insn));
|
2017-04-19 12:51:04 +00:00
|
|
|
BUG();
|
2017-09-22 09:10:44 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If we haven't previously emulated this instruction, then it
|
|
|
|
* can't be boosted. Note it down so we don't try to do so again.
|
|
|
|
*
|
|
|
|
* If, however, we had emulated this instruction in the past,
|
|
|
|
* then this is just an error with the current run (for
|
|
|
|
* instance, exceptions due to a load/store). We return 0 so
|
|
|
|
* that this is now single-stepped, but continue to try
|
|
|
|
* emulating it in subsequent probe hits.
|
|
|
|
*/
|
|
|
|
if (unlikely(p->ainsn.boostable != 1))
|
|
|
|
p->ainsn.boostable = -1;
|
|
|
|
}
|
2017-04-19 12:51:04 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2017-04-24 14:24:04 +00:00
|
|
|
NOKPROBE_SYMBOL(try_to_emulate);
|
2017-04-19 12:51:04 +00:00
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
int kprobe_handler(struct pt_regs *regs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct kprobe *p;
|
|
|
|
int ret = 0;
|
|
|
|
unsigned int *addr = (unsigned int *)regs->nip;
|
2005-11-07 09:00:14 +00:00
|
|
|
struct kprobe_ctlblk *kcb;
|
|
|
|
|
2016-11-21 17:06:41 +00:00
|
|
|
if (user_mode(regs))
|
|
|
|
return 0;
|
|
|
|
|
2021-08-09 02:36:58 +00:00
|
|
|
if (!IS_ENABLED(CONFIG_BOOKE) &&
|
|
|
|
(!(regs->msr & MSR_IR) || !(regs->msr & MSR_DR)))
|
2020-02-18 19:38:27 +00:00
|
|
|
return 0;
|
|
|
|
|
2005-11-07 09:00:14 +00:00
|
|
|
/*
|
|
|
|
* We don't want to be preempted for the entire
|
|
|
|
* duration of kprobe processing
|
|
|
|
*/
|
|
|
|
preempt_disable();
|
|
|
|
kcb = get_kprobe_ctlblk();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
p = get_kprobe(addr);
|
|
|
|
if (!p) {
|
2020-02-24 18:02:10 +00:00
|
|
|
unsigned int instr;
|
|
|
|
|
2020-06-17 07:37:55 +00:00
|
|
|
if (get_kernel_nofault(instr, addr))
|
2020-02-24 18:02:10 +00:00
|
|
|
goto no_kprobe;
|
|
|
|
|
|
|
|
if (instr != BREAKPOINT_INSTRUCTION) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* PowerPC has multiple variants of the "trap"
|
|
|
|
* instruction. If the current instruction is a
|
|
|
|
* trap variant, it could belong to someone else
|
|
|
|
*/
|
2020-02-24 18:02:10 +00:00
|
|
|
if (is_trap(instr))
|
2018-06-19 16:12:51 +00:00
|
|
|
goto no_kprobe;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The breakpoint instruction was removed right
|
|
|
|
* after we hit it. Another cpu has removed
|
|
|
|
* either a probepoint or a debugger breakpoint
|
|
|
|
* at this address. In either case, no further
|
|
|
|
* handling of this interrupt is appropriate.
|
|
|
|
*/
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
/* Not one of ours: let kernel handle it */
|
|
|
|
goto no_kprobe;
|
|
|
|
}
|
|
|
|
|
2020-02-19 08:05:57 +00:00
|
|
|
/* Check we're not actually recursing */
|
|
|
|
if (kprobe_running()) {
|
|
|
|
kprobe_opcode_t insn = *p->ainsn.insn;
|
|
|
|
if (kcb->kprobe_status == KPROBE_HIT_SS && is_trap(insn)) {
|
|
|
|
/* Turn off 'trace' bits */
|
2021-06-17 15:51:03 +00:00
|
|
|
regs_set_return_msr(regs,
|
|
|
|
(regs->msr & ~MSR_SINGLESTEP) |
|
|
|
|
kcb->kprobe_saved_msr);
|
2020-02-19 08:05:57 +00:00
|
|
|
goto no_kprobe;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have reentered the kprobe_handler(), since another probe
|
|
|
|
* was hit while within the handler. We here save the original
|
|
|
|
* kprobes variables and just single step on the instruction of
|
|
|
|
* the new probe without calling any user handlers.
|
|
|
|
*/
|
|
|
|
save_previous_kprobe(kcb);
|
|
|
|
set_current_kprobe(p, regs, kcb);
|
|
|
|
kprobes_inc_nmissed_count(p);
|
|
|
|
kcb->kprobe_status = KPROBE_REENTER;
|
|
|
|
if (p->ainsn.boostable >= 0) {
|
|
|
|
ret = try_to_emulate(p, regs);
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
restore_previous_kprobe(kcb);
|
|
|
|
preempt_enable_no_resched();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prepare_singlestep(p, regs);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-11-07 09:00:10 +00:00
|
|
|
kcb->kprobe_status = KPROBE_HIT_ACTIVE;
|
|
|
|
set_current_kprobe(p, regs, kcb);
|
2018-06-19 16:15:45 +00:00
|
|
|
if (p->pre_handler && p->pre_handler(p, regs)) {
|
|
|
|
/* handler changed execution path, so skip ss setup */
|
|
|
|
reset_current_kprobe();
|
|
|
|
preempt_enable_no_resched();
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
2018-06-19 16:15:45 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-04-18 05:57:51 +00:00
|
|
|
if (p->ainsn.boostable >= 0) {
|
2017-04-19 12:51:04 +00:00
|
|
|
ret = try_to_emulate(p, regs);
|
2007-04-18 05:57:51 +00:00
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
if (p->post_handler)
|
|
|
|
p->post_handler(p, regs, 0);
|
|
|
|
|
|
|
|
kcb->kprobe_status = KPROBE_HIT_SSDONE;
|
|
|
|
reset_current_kprobe();
|
|
|
|
preempt_enable_no_resched();
|
|
|
|
return 1;
|
2017-04-19 12:51:04 +00:00
|
|
|
}
|
2007-04-18 05:57:51 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
prepare_singlestep(p, regs);
|
2005-11-07 09:00:10 +00:00
|
|
|
kcb->kprobe_status = KPROBE_HIT_SS;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
no_kprobe:
|
2005-11-07 09:00:14 +00:00
|
|
|
preempt_enable_no_resched();
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(kprobe_handler);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-27 22:17:15 +00:00
|
|
|
/*
|
|
|
|
* Function return probe trampoline:
|
|
|
|
* - init_kprobes() establishes a probepoint here
|
|
|
|
* - When the probed function returns, this probe
|
|
|
|
* causes the handlers to fire
|
|
|
|
*/
|
2021-09-14 14:40:54 +00:00
|
|
|
asm(".global __kretprobe_trampoline\n"
|
|
|
|
".type __kretprobe_trampoline, @function\n"
|
|
|
|
"__kretprobe_trampoline:\n"
|
2016-03-31 20:10:40 +00:00
|
|
|
"nop\n"
|
2017-02-08 09:50:52 +00:00
|
|
|
"blr\n"
|
2021-09-14 14:40:54 +00:00
|
|
|
".size __kretprobe_trampoline, .-__kretprobe_trampoline\n");
|
2005-06-27 22:17:15 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Called when the probe at kretprobe trampoline is hit
|
|
|
|
*/
|
2017-04-12 11:18:51 +00:00
|
|
|
static int trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
|
2005-06-27 22:17:15 +00:00
|
|
|
{
|
2020-08-29 13:01:48 +00:00
|
|
|
unsigned long orig_ret_address;
|
2018-01-17 12:22:24 +00:00
|
|
|
|
2021-09-14 14:40:45 +00:00
|
|
|
orig_ret_address = __kretprobe_trampoline_handler(regs, NULL);
|
2017-02-08 09:50:52 +00:00
|
|
|
/*
|
2018-01-17 12:22:24 +00:00
|
|
|
* We get here through one of two paths:
|
|
|
|
* 1. by taking a trap -> kprobe_handler() -> here
|
|
|
|
* 2. by optprobe branch -> optimized_callback() -> opt_pre_handler() -> here
|
|
|
|
*
|
|
|
|
* When going back through (1), we need regs->nip to be setup properly
|
|
|
|
* as it is used to determine the return address from the trap.
|
|
|
|
* For (2), since nip is not honoured with optprobes, we instead setup
|
|
|
|
* the link register properly so that the subsequent 'blr' in
|
2021-09-14 14:40:54 +00:00
|
|
|
* __kretprobe_trampoline jumps back to the right instruction.
|
2018-01-17 12:22:24 +00:00
|
|
|
*
|
|
|
|
* For nip, we should set the address to the previous instruction since
|
|
|
|
* we end up emulating it in kprobe_handler(), which increments the nip
|
|
|
|
* again.
|
2017-02-08 09:50:52 +00:00
|
|
|
*/
|
2021-06-17 15:51:03 +00:00
|
|
|
regs_set_return_ip(regs, orig_ret_address - 4);
|
2017-02-08 09:50:52 +00:00
|
|
|
regs->link = orig_ret_address;
|
2005-06-27 22:17:15 +00:00
|
|
|
|
2018-01-17 12:22:24 +00:00
|
|
|
return 0;
|
2005-06-27 22:17:15 +00:00
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(trampoline_probe_handler);
|
2005-06-27 22:17:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Called after single-stepping. p->addr is the address of the
|
|
|
|
* instruction whose first byte has been replaced by the "breakpoint"
|
|
|
|
* instruction. To avoid the SMP problems that can occur when we
|
|
|
|
* temporarily put back the original opcode to single-step, we
|
|
|
|
* single-stepped a copy of the instruction. The address of this
|
|
|
|
* copy is p->ainsn.insn.
|
|
|
|
*/
|
2017-04-12 11:18:51 +00:00
|
|
|
int kprobe_post_handler(struct pt_regs *regs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2020-05-06 03:40:37 +00:00
|
|
|
int len;
|
2005-11-07 09:00:10 +00:00
|
|
|
struct kprobe *cur = kprobe_running();
|
|
|
|
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
|
|
|
|
2016-11-21 17:06:41 +00:00
|
|
|
if (!cur || user_mode(regs))
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2021-05-20 13:50:45 +00:00
|
|
|
len = ppc_inst_len(ppc_inst_read(cur->ainsn.insn));
|
2008-06-26 06:57:58 +00:00
|
|
|
/* make sure we got here for instruction we have a kprobe on */
|
2020-05-06 03:40:37 +00:00
|
|
|
if (((unsigned long)cur->ainsn.insn + len) != regs->nip)
|
2008-06-26 06:57:58 +00:00
|
|
|
return 0;
|
|
|
|
|
2005-11-07 09:00:10 +00:00
|
|
|
if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
|
|
|
|
kcb->kprobe_status = KPROBE_HIT_SSDONE;
|
|
|
|
cur->post_handler(cur, regs, 0);
|
2005-06-23 07:09:38 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-05-27 19:19:20 +00:00
|
|
|
/* Adjust nip to after the single-stepped instruction */
|
2021-06-17 15:51:03 +00:00
|
|
|
regs_set_return_ip(regs, (unsigned long)cur->addr + len);
|
|
|
|
regs_set_return_msr(regs, regs->msr | kcb->kprobe_saved_msr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-23 07:09:38 +00:00
|
|
|
/*Restore back the original saved kprobes variables and continue. */
|
2005-11-07 09:00:10 +00:00
|
|
|
if (kcb->kprobe_status == KPROBE_REENTER) {
|
|
|
|
restore_previous_kprobe(kcb);
|
2005-06-23 07:09:38 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2005-11-07 09:00:10 +00:00
|
|
|
reset_current_kprobe();
|
2005-06-23 07:09:38 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
preempt_enable_no_resched();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if somebody else is singlestepping across a probe point, msr
|
2008-06-26 07:01:37 +00:00
|
|
|
* will have DE/SE set, in which case, continue the remaining processing
|
2005-04-16 22:20:36 +00:00
|
|
|
* of do_debug, as if this is not a probe hit.
|
|
|
|
*/
|
2008-06-26 07:01:37 +00:00
|
|
|
if (regs->msr & MSR_SINGLESTEP)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(kprobe_post_handler);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-11-07 09:00:10 +00:00
|
|
|
struct kprobe *cur = kprobe_running();
|
|
|
|
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
2006-03-26 09:38:24 +00:00
|
|
|
const struct exception_table_entry *entry;
|
|
|
|
|
|
|
|
switch(kcb->kprobe_status) {
|
|
|
|
case KPROBE_HIT_SS:
|
|
|
|
case KPROBE_REENTER:
|
|
|
|
/*
|
|
|
|
* We are here because the instruction being single
|
|
|
|
* stepped caused a page fault. We reset the current
|
|
|
|
* kprobe and the nip points back to the probe address
|
|
|
|
* and allow the page fault handler to continue as a
|
|
|
|
* normal page fault.
|
|
|
|
*/
|
2021-06-17 15:51:03 +00:00
|
|
|
regs_set_return_ip(regs, (unsigned long)cur->addr);
|
|
|
|
/* Turn off 'trace' bits */
|
|
|
|
regs_set_return_msr(regs,
|
|
|
|
(regs->msr & ~MSR_SINGLESTEP) |
|
|
|
|
kcb->kprobe_saved_msr);
|
2006-03-26 09:38:24 +00:00
|
|
|
if (kcb->kprobe_status == KPROBE_REENTER)
|
|
|
|
restore_previous_kprobe(kcb);
|
|
|
|
else
|
|
|
|
reset_current_kprobe();
|
2005-04-16 22:20:36 +00:00
|
|
|
preempt_enable_no_resched();
|
2006-03-26 09:38:24 +00:00
|
|
|
break;
|
|
|
|
case KPROBE_HIT_ACTIVE:
|
|
|
|
case KPROBE_HIT_SSDONE:
|
|
|
|
/*
|
|
|
|
* In case the user-specified fault handler returned
|
|
|
|
* zero, try to fix up.
|
|
|
|
*/
|
|
|
|
if ((entry = search_exception_tables(regs->nip)) != NULL) {
|
2021-06-17 15:51:03 +00:00
|
|
|
regs_set_return_ip(regs, extable_fixup(entry));
|
2006-03-26 09:38:24 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fixup_exception() could not handle it,
|
|
|
|
* Let do_page_fault() fix it.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(kprobe_fault_handler);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-27 22:17:15 +00:00
|
|
|
static struct kprobe trampoline_p = {
|
2021-09-14 14:40:54 +00:00
|
|
|
.addr = (kprobe_opcode_t *) &__kretprobe_trampoline,
|
2005-06-27 22:17:15 +00:00
|
|
|
.pre_handler = trampoline_probe_handler
|
|
|
|
};
|
|
|
|
|
2005-07-06 01:54:50 +00:00
|
|
|
int __init arch_init_kprobes(void)
|
2005-06-27 22:17:15 +00:00
|
|
|
{
|
|
|
|
return register_kprobe(&trampoline_p);
|
|
|
|
}
|
2007-05-08 07:34:16 +00:00
|
|
|
|
2017-04-12 11:18:51 +00:00
|
|
|
int arch_trampoline_kprobe(struct kprobe *p)
|
2007-05-08 07:34:16 +00:00
|
|
|
{
|
2021-09-14 14:40:54 +00:00
|
|
|
if (p->addr == (kprobe_opcode_t *)&__kretprobe_trampoline)
|
2007-05-08 07:34:16 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-04-12 11:18:51 +00:00
|
|
|
NOKPROBE_SYMBOL(arch_trampoline_kprobe);
|