2019-05-27 14:55:15 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2010-08-04 02:22:20 +08:00
|
|
|
/*
|
|
|
|
* Kernel Probes (KProbes)
|
|
|
|
* arch/mips/kernel/kprobes.c
|
|
|
|
*
|
|
|
|
* Copyright 2006 Sony Corp.
|
|
|
|
* Copyright 2010 Cavium Networks
|
|
|
|
*
|
|
|
|
* Some portions copied from the powerpc version.
|
|
|
|
*
|
|
|
|
* Copyright (C) IBM Corporation, 2002, 2004
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/preempt.h>
|
2011-11-08 19:34:54 +08:00
|
|
|
#include <linux/uaccess.h>
|
2010-08-04 02:22:20 +08:00
|
|
|
#include <linux/kdebug.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
|
|
|
#include <asm/ptrace.h>
|
2011-11-08 19:38:26 +08:00
|
|
|
#include <asm/branch.h>
|
2010-08-04 02:22:20 +08:00
|
|
|
#include <asm/break.h>
|
2016-09-30 17:33:45 +08:00
|
|
|
|
|
|
|
#include "probes-common.h"
|
2010-08-04 02:22:20 +08:00
|
|
|
|
|
|
|
static const union mips_instruction breakpoint_insn = {
|
|
|
|
.b_format = {
|
|
|
|
.opcode = spec_op,
|
|
|
|
.code = BRK_KPROBE_BP,
|
|
|
|
.func = break_op
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const union mips_instruction breakpoint2_insn = {
|
|
|
|
.b_format = {
|
|
|
|
.opcode = spec_op,
|
|
|
|
.code = BRK_KPROBE_SSTEPBP,
|
|
|
|
.func = break_op
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_PER_CPU(struct kprobe *, current_kprobe);
|
|
|
|
DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
|
|
|
|
|
|
|
|
static int __kprobes insn_has_delayslot(union mips_instruction insn)
|
|
|
|
{
|
2016-09-30 17:33:45 +08:00
|
|
|
return __insn_has_delay_slot(insn);
|
2010-08-04 02:22:20 +08:00
|
|
|
}
|
|
|
|
|
2011-11-08 19:35:35 +08:00
|
|
|
/*
|
|
|
|
* insn_has_ll_or_sc function checks whether instruction is ll or sc
|
|
|
|
* one; putting breakpoint on top of atomic ll/sc pair is bad idea;
|
|
|
|
* so we need to prevent it and refuse kprobes insertion for such
|
|
|
|
* instructions; cannot do much about breakpoint in the middle of
|
|
|
|
* ll/sc pair; it is upto user to avoid those places
|
|
|
|
*/
|
|
|
|
static int __kprobes insn_has_ll_or_sc(union mips_instruction insn)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
switch (insn.i_format.opcode) {
|
|
|
|
case ll_op:
|
|
|
|
case lld_op:
|
|
|
|
case sc_op:
|
|
|
|
case scd_op:
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-08-04 02:22:20 +08:00
|
|
|
int __kprobes arch_prepare_kprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
union mips_instruction insn;
|
|
|
|
union mips_instruction prev_insn;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
insn = p->addr[0];
|
|
|
|
|
2011-11-08 19:35:35 +08:00
|
|
|
if (insn_has_ll_or_sc(insn)) {
|
|
|
|
pr_notice("Kprobes for ll and sc instructions are not"
|
|
|
|
"supported\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-11-08 19:34:54 +08:00
|
|
|
if ((probe_kernel_read(&prev_insn, p->addr - 1,
|
|
|
|
sizeof(mips_instruction)) == 0) &&
|
|
|
|
insn_has_delayslot(prev_insn)) {
|
|
|
|
pr_notice("Kprobes for branch delayslot are not supported\n");
|
2010-08-04 02:22:20 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-09-30 17:33:46 +08:00
|
|
|
if (__insn_is_compact_branch(insn)) {
|
|
|
|
pr_notice("Kprobes for compact branches are not supported\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-08-04 02:22:20 +08:00
|
|
|
/* insn: must be on special executable page on mips. */
|
|
|
|
p->ainsn.insn = get_insn_slot();
|
|
|
|
if (!p->ainsn.insn) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the kprobe->ainsn.insn[] array we store the original
|
|
|
|
* instruction at index zero and a break trap instruction at
|
|
|
|
* index one.
|
2011-11-08 19:38:26 +08:00
|
|
|
*
|
|
|
|
* On MIPS arch if the instruction at probed address is a
|
|
|
|
* branch instruction, we need to execute the instruction at
|
|
|
|
* Branch Delayslot (BD) at the time of probe hit. As MIPS also
|
|
|
|
* doesn't have single stepping support, the BD instruction can
|
|
|
|
* not be executed in-line and it would be executed on SSOL slot
|
|
|
|
* using a normal breakpoint instruction in the next slot.
|
|
|
|
* So, read the instruction and save it for later execution.
|
2010-08-04 02:22:20 +08:00
|
|
|
*/
|
2011-11-08 19:38:26 +08:00
|
|
|
if (insn_has_delayslot(insn))
|
|
|
|
memcpy(&p->ainsn.insn[0], p->addr + 1, sizeof(kprobe_opcode_t));
|
|
|
|
else
|
|
|
|
memcpy(&p->ainsn.insn[0], p->addr, sizeof(kprobe_opcode_t));
|
2010-08-04 02:22:20 +08:00
|
|
|
|
|
|
|
p->ainsn.insn[1] = breakpoint2_insn;
|
|
|
|
p->opcode = *p->addr;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __kprobes arch_arm_kprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
*p->addr = breakpoint_insn;
|
|
|
|
flush_insn_slot(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __kprobes arch_disarm_kprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
*p->addr = p->opcode;
|
|
|
|
flush_insn_slot(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __kprobes arch_remove_kprobe(struct kprobe *p)
|
|
|
|
{
|
2013-05-22 16:34:13 +08:00
|
|
|
if (p->ainsn.insn) {
|
|
|
|
free_insn_slot(p->ainsn.insn, 0);
|
|
|
|
p->ainsn.insn = NULL;
|
|
|
|
}
|
2010-08-04 02:22:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void save_previous_kprobe(struct kprobe_ctlblk *kcb)
|
|
|
|
{
|
|
|
|
kcb->prev_kprobe.kp = kprobe_running();
|
|
|
|
kcb->prev_kprobe.status = kcb->kprobe_status;
|
|
|
|
kcb->prev_kprobe.old_SR = kcb->kprobe_old_SR;
|
|
|
|
kcb->prev_kprobe.saved_SR = kcb->kprobe_saved_SR;
|
|
|
|
kcb->prev_kprobe.saved_epc = kcb->kprobe_saved_epc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void restore_previous_kprobe(struct kprobe_ctlblk *kcb)
|
|
|
|
{
|
mips: Replace __get_cpu_var uses
__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 :
#define __get_cpu_var(var) (*this_cpu_ptr(&(var)))
__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: Ralf Baechle <ralf@linux-mips.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-08-18 01:30:44 +08:00
|
|
|
__this_cpu_write(current_kprobe, kcb->prev_kprobe.kp);
|
2010-08-04 02:22:20 +08:00
|
|
|
kcb->kprobe_status = kcb->prev_kprobe.status;
|
|
|
|
kcb->kprobe_old_SR = kcb->prev_kprobe.old_SR;
|
|
|
|
kcb->kprobe_saved_SR = kcb->prev_kprobe.saved_SR;
|
|
|
|
kcb->kprobe_saved_epc = kcb->prev_kprobe.saved_epc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_current_kprobe(struct kprobe *p, struct pt_regs *regs,
|
|
|
|
struct kprobe_ctlblk *kcb)
|
|
|
|
{
|
mips: Replace __get_cpu_var uses
__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 :
#define __get_cpu_var(var) (*this_cpu_ptr(&(var)))
__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: Ralf Baechle <ralf@linux-mips.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-08-18 01:30:44 +08:00
|
|
|
__this_cpu_write(current_kprobe, p);
|
2010-08-04 02:22:20 +08:00
|
|
|
kcb->kprobe_saved_SR = kcb->kprobe_old_SR = (regs->cp0_status & ST0_IE);
|
|
|
|
kcb->kprobe_saved_epc = regs->cp0_epc;
|
|
|
|
}
|
|
|
|
|
2011-11-08 19:38:26 +08:00
|
|
|
/**
|
|
|
|
* evaluate_branch_instrucion -
|
|
|
|
*
|
|
|
|
* Evaluate the branch instruction at probed address during probe hit. The
|
|
|
|
* result of evaluation would be the updated epc. The insturction in delayslot
|
|
|
|
* would actually be single stepped using a normal breakpoint) on SSOL slot.
|
|
|
|
*
|
|
|
|
* The result is also saved in the kprobe control block for later use,
|
|
|
|
* in case we need to execute the delayslot instruction. The latter will be
|
|
|
|
* false for NOP instruction in dealyslot and the branch-likely instructions
|
|
|
|
* when the branch is taken. And for those cases we set a flag as
|
|
|
|
* SKIP_DELAYSLOT in the kprobe control block
|
|
|
|
*/
|
|
|
|
static int evaluate_branch_instruction(struct kprobe *p, struct pt_regs *regs,
|
|
|
|
struct kprobe_ctlblk *kcb)
|
|
|
|
{
|
|
|
|
union mips_instruction insn = p->opcode;
|
|
|
|
long epc;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
epc = regs->cp0_epc;
|
|
|
|
if (epc & 3)
|
|
|
|
goto unaligned;
|
|
|
|
|
|
|
|
if (p->ainsn.insn->word == 0)
|
|
|
|
kcb->flags |= SKIP_DELAYSLOT;
|
|
|
|
else
|
|
|
|
kcb->flags &= ~SKIP_DELAYSLOT;
|
|
|
|
|
|
|
|
ret = __compute_return_epc_for_insn(regs, insn);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (ret == BRANCH_LIKELY_TAKEN)
|
|
|
|
kcb->flags |= SKIP_DELAYSLOT;
|
|
|
|
|
|
|
|
kcb->target_epc = regs->cp0_epc;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
unaligned:
|
|
|
|
pr_notice("%s: unaligned epc - sending SIGBUS.\n", current->comm);
|
2019-05-23 23:17:27 +08:00
|
|
|
force_sig(SIGBUS);
|
2011-11-08 19:38:26 +08:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prepare_singlestep(struct kprobe *p, struct pt_regs *regs,
|
|
|
|
struct kprobe_ctlblk *kcb)
|
2010-08-04 02:22:20 +08:00
|
|
|
{
|
2011-11-08 19:38:26 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2010-08-04 02:22:20 +08:00
|
|
|
regs->cp0_status &= ~ST0_IE;
|
|
|
|
|
|
|
|
/* single step inline if the instruction is a break */
|
|
|
|
if (p->opcode.word == breakpoint_insn.word ||
|
|
|
|
p->opcode.word == breakpoint2_insn.word)
|
|
|
|
regs->cp0_epc = (unsigned long)p->addr;
|
2011-11-08 19:38:26 +08:00
|
|
|
else if (insn_has_delayslot(p->opcode)) {
|
|
|
|
ret = evaluate_branch_instruction(p, regs, kcb);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_notice("Kprobes: Error in evaluating branch\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
regs->cp0_epc = (unsigned long)&p->ainsn.insn[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called after single-stepping. p->addr is the address of the
|
|
|
|
* instruction whose first byte has been replaced by the "break 0"
|
2013-01-22 19:59:30 +08:00
|
|
|
* instruction. To avoid the SMP problems that can occur when we
|
2011-11-08 19:38:26 +08:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* This function prepares to return from the post-single-step
|
|
|
|
* breakpoint trap. In case of branch instructions, the target
|
|
|
|
* epc to be restored.
|
|
|
|
*/
|
|
|
|
static void __kprobes resume_execution(struct kprobe *p,
|
|
|
|
struct pt_regs *regs,
|
|
|
|
struct kprobe_ctlblk *kcb)
|
|
|
|
{
|
|
|
|
if (insn_has_delayslot(p->opcode))
|
|
|
|
regs->cp0_epc = kcb->target_epc;
|
|
|
|
else {
|
|
|
|
unsigned long orig_epc = kcb->kprobe_saved_epc;
|
|
|
|
regs->cp0_epc = orig_epc + 4;
|
|
|
|
}
|
2010-08-04 02:22:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __kprobes kprobe_handler(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct kprobe *p;
|
|
|
|
int ret = 0;
|
|
|
|
kprobe_opcode_t *addr;
|
|
|
|
struct kprobe_ctlblk *kcb;
|
|
|
|
|
|
|
|
addr = (kprobe_opcode_t *) regs->cp0_epc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't want to be preempted for the entire
|
|
|
|
* duration of kprobe processing
|
|
|
|
*/
|
|
|
|
preempt_disable();
|
|
|
|
kcb = get_kprobe_ctlblk();
|
|
|
|
|
|
|
|
/* Check we're not actually recursing */
|
|
|
|
if (kprobe_running()) {
|
|
|
|
p = get_kprobe(addr);
|
|
|
|
if (p) {
|
|
|
|
if (kcb->kprobe_status == KPROBE_HIT_SS &&
|
|
|
|
p->ainsn.insn->word == breakpoint_insn.word) {
|
|
|
|
regs->cp0_status &= ~ST0_IE;
|
|
|
|
regs->cp0_status |= kcb->kprobe_saved_SR;
|
|
|
|
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);
|
2011-11-08 19:38:26 +08:00
|
|
|
prepare_singlestep(p, regs, kcb);
|
2010-08-04 02:22:20 +08:00
|
|
|
kcb->kprobe_status = KPROBE_REENTER;
|
2011-11-08 19:38:26 +08:00
|
|
|
if (kcb->flags & SKIP_DELAYSLOT) {
|
|
|
|
resume_execution(p, regs, kcb);
|
|
|
|
restore_previous_kprobe(kcb);
|
|
|
|
preempt_enable_no_resched();
|
|
|
|
}
|
2010-08-04 02:22:20 +08:00
|
|
|
return 1;
|
2018-06-20 00:13:49 +08:00
|
|
|
} else if (addr->word != breakpoint_insn.word) {
|
|
|
|
/*
|
|
|
|
* The breakpoint instruction was removed by
|
|
|
|
* another cpu right after we hit, no further
|
|
|
|
* handling of this interrupt is appropriate
|
|
|
|
*/
|
|
|
|
ret = 1;
|
2010-08-04 02:22:20 +08:00
|
|
|
}
|
|
|
|
goto no_kprobe;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = get_kprobe(addr);
|
|
|
|
if (!p) {
|
|
|
|
if (addr->word != breakpoint_insn.word) {
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_current_kprobe(p, regs, kcb);
|
|
|
|
kcb->kprobe_status = KPROBE_HIT_ACTIVE;
|
|
|
|
|
|
|
|
if (p->pre_handler && p->pre_handler(p, regs)) {
|
|
|
|
/* handler has already set things up, so skip ss setup */
|
2018-06-20 00:15:45 +08:00
|
|
|
reset_current_kprobe();
|
|
|
|
preempt_enable_no_resched();
|
2010-08-04 02:22:20 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-11-08 19:38:26 +08:00
|
|
|
prepare_singlestep(p, regs, kcb);
|
|
|
|
if (kcb->flags & SKIP_DELAYSLOT) {
|
|
|
|
kcb->kprobe_status = KPROBE_HIT_SSDONE;
|
|
|
|
if (p->post_handler)
|
|
|
|
p->post_handler(p, regs, 0);
|
|
|
|
resume_execution(p, regs, kcb);
|
|
|
|
preempt_enable_no_resched();
|
|
|
|
} else
|
|
|
|
kcb->kprobe_status = KPROBE_HIT_SS;
|
|
|
|
|
2010-08-04 02:22:20 +08:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
no_kprobe:
|
|
|
|
preempt_enable_no_resched();
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int post_kprobe_handler(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct kprobe *cur = kprobe_running();
|
|
|
|
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
|
|
|
|
|
|
|
if (!cur)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
|
|
|
|
kcb->kprobe_status = KPROBE_HIT_SSDONE;
|
|
|
|
cur->post_handler(cur, regs, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
resume_execution(cur, regs, kcb);
|
|
|
|
|
|
|
|
regs->cp0_status |= kcb->kprobe_saved_SR;
|
|
|
|
|
|
|
|
/* Restore back the original saved kprobes variables and continue. */
|
|
|
|
if (kcb->kprobe_status == KPROBE_REENTER) {
|
|
|
|
restore_previous_kprobe(kcb);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
reset_current_kprobe();
|
|
|
|
out:
|
|
|
|
preempt_enable_no_resched();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2019-07-17 07:28:00 +08:00
|
|
|
int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
|
2010-08-04 02:22:20 +08:00
|
|
|
{
|
|
|
|
struct kprobe *cur = kprobe_running();
|
|
|
|
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
|
|
|
|
|
|
|
if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (kcb->kprobe_status & KPROBE_HIT_SS) {
|
|
|
|
resume_execution(cur, regs, kcb);
|
|
|
|
regs->cp0_status |= kcb->kprobe_old_SR;
|
|
|
|
|
|
|
|
reset_current_kprobe();
|
|
|
|
preempt_enable_no_resched();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wrapper routine for handling exceptions.
|
|
|
|
*/
|
|
|
|
int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
|
|
|
|
unsigned long val, void *data)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct die_args *args = (struct die_args *)data;
|
|
|
|
int ret = NOTIFY_DONE;
|
|
|
|
|
|
|
|
switch (val) {
|
|
|
|
case DIE_BREAK:
|
|
|
|
if (kprobe_handler(args->regs))
|
|
|
|
ret = NOTIFY_STOP;
|
|
|
|
break;
|
|
|
|
case DIE_SSTEPBP:
|
|
|
|
if (post_kprobe_handler(args->regs))
|
|
|
|
ret = NOTIFY_STOP;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DIE_PAGE_FAULT:
|
|
|
|
/* kprobe_running() needs smp_processor_id() */
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
if (kprobe_running()
|
|
|
|
&& kprobe_fault_handler(args->regs, args->trapnr))
|
|
|
|
ret = NOTIFY_STOP;
|
|
|
|
preempt_enable();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function return probe trampoline:
|
|
|
|
* - init_kprobes() establishes a probepoint here
|
|
|
|
* - When the probed function returns, this probe causes the
|
|
|
|
* handlers to fire
|
|
|
|
*/
|
|
|
|
static void __used kretprobe_trampoline_holder(void)
|
|
|
|
{
|
|
|
|
asm volatile(
|
|
|
|
".set push\n\t"
|
|
|
|
/* Keep the assembler from reordering and placing JR here. */
|
|
|
|
".set noreorder\n\t"
|
|
|
|
"nop\n\t"
|
|
|
|
".global kretprobe_trampoline\n"
|
|
|
|
"kretprobe_trampoline:\n\t"
|
|
|
|
"nop\n\t"
|
|
|
|
".set pop"
|
|
|
|
: : : "memory");
|
|
|
|
}
|
|
|
|
|
|
|
|
void kretprobe_trampoline(void);
|
|
|
|
|
|
|
|
void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
ri->ret_addr = (kprobe_opcode_t *) regs->regs[31];
|
|
|
|
|
|
|
|
/* Replace the return addr with trampoline addr */
|
|
|
|
regs->regs[31] = (unsigned long)kretprobe_trampoline;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called when the probe at kretprobe trampoline is hit
|
|
|
|
*/
|
|
|
|
static int __kprobes trampoline_probe_handler(struct kprobe *p,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct kretprobe_instance *ri = NULL;
|
|
|
|
struct hlist_head *head, empty_rp;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
struct hlist_node *tmp;
|
2010-08-04 02:22:20 +08:00
|
|
|
unsigned long flags, orig_ret_address = 0;
|
|
|
|
unsigned long trampoline_address = (unsigned long)kretprobe_trampoline;
|
|
|
|
|
|
|
|
INIT_HLIST_HEAD(&empty_rp);
|
|
|
|
kretprobe_hash_lock(current, &head, &flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It is possible to have multiple instances associated with a given
|
|
|
|
* task either because an multiple functions in the call path
|
|
|
|
* have a return probe installed on them, and/or more than one return
|
|
|
|
* return probe was registered for a target function.
|
|
|
|
*
|
|
|
|
* We can handle this because:
|
|
|
|
* - instances are always inserted at the head of the list
|
|
|
|
* - when multiple return probes are registered for the same
|
2013-01-22 19:59:30 +08:00
|
|
|
* function, the first instance's ret_addr will point to the
|
|
|
|
* real return address, and all the rest will point to
|
|
|
|
* kretprobe_trampoline
|
2010-08-04 02:22:20 +08:00
|
|
|
*/
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
hlist_for_each_entry_safe(ri, tmp, head, hlist) {
|
2010-08-04 02:22:20 +08:00
|
|
|
if (ri->task != current)
|
|
|
|
/* another task is sharing our hash bucket */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ri->rp && ri->rp->handler)
|
|
|
|
ri->rp->handler(ri, regs);
|
|
|
|
|
|
|
|
orig_ret_address = (unsigned long)ri->ret_addr;
|
|
|
|
recycle_rp_inst(ri, &empty_rp);
|
|
|
|
|
|
|
|
if (orig_ret_address != trampoline_address)
|
|
|
|
/*
|
|
|
|
* This is the real return address. Any other
|
|
|
|
* instances associated with this task are for
|
|
|
|
* other calls deeper on the call stack
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
kretprobe_assert(ri, orig_ret_address, trampoline_address);
|
|
|
|
instruction_pointer(regs) = orig_ret_address;
|
|
|
|
|
|
|
|
kretprobe_hash_unlock(current, &flags);
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
|
2010-08-04 02:22:20 +08:00
|
|
|
hlist_del(&ri->hlist);
|
|
|
|
kfree(ri);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* By returning a non-zero value, we are telling
|
|
|
|
* kprobe_handler() that we don't want the post_handler
|
|
|
|
* to run (and have re-enabled preemption)
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int __kprobes arch_trampoline_kprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
if (p->addr == (kprobe_opcode_t *)kretprobe_trampoline)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct kprobe trampoline_p = {
|
|
|
|
.addr = (kprobe_opcode_t *)kretprobe_trampoline,
|
|
|
|
.pre_handler = trampoline_probe_handler
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init arch_init_kprobes(void)
|
|
|
|
{
|
|
|
|
return register_kprobe(&trampoline_p);
|
|
|
|
}
|