/* stapkp_refresh is called for two reasons: either a kprobe needs to be
* enabled/disabled (modname is NULL), or a module has been loaded/unloaded and
* kprobes need to be registered/unregistered (modname is !NULL). */
static void
stapkp_refresh(const char *modname,
struct stap_dwarf_probe *probes,
size_t nprobes)
{
size_t i;
for (i = 0; i < nprobes; i++) {
struct stap_dwarf_probe *sdp = &probes[i];
// was this probe's target module loaded/unloaded
if (modname && sdp->module
&& strcmp(modname, sdp->module) == 0) {
int rc;
unsigned long addr = stapkp_relocate_addr(sdp);
// module being loaded?
if (sdp->registered_p == 0 && addr != 0)
stapkp_register_probe(sdp);
// module/section being unloaded?
else if (sdp->registered_p == 1 && addr == 0)
stapkp_unregister_probe(sdp);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
} else if (stapkp_should_enable_probe(sdp)
|| stapkp_should_disable_probe(sdp)) {
stapkp_refresh_probe(sdp);
#endif
}
}
}
static int
stapkp_prepare_kprobe(struct stap_dwarf_probe *sdp)
{
struct kprobe *kp = &sdp->kprobe->u.kp;
unsigned long addr = stapkp_relocate_addr(sdp);
if (addr == 0)
return 1;
kp->addr = (void *) addr;
kp->pre_handler = &enter_kprobe_probe;
#ifdef __ia64__ // PR6028
sdp->kprobe->dummy.addr = kp->addr;
sdp->kprobe->dummy.pre_handler = NULL;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
if (!sdp->probe->cond_enabled) {
kp->flags |= KPROBE_FLAG_DISABLED;
dbug_otf("registering as disabled (kprobe) pidx %zu\n",
sdp->probe->index);
}
#endif
return 0;
}
static int
stapkp_prepare_kretprobe(struct stap_kprobe_probe *skp)
{
struct kretprobe *krp = &skp->kprobe->u.krp;
unsigned long addr = 0;
if (! skp->symbol_name) {
addr = stapkp_relocate_addr(skp);
if (addr == 0)
return 1;
krp->kp.addr = (void *) addr;
}
else {
#ifdef STAPCONF_KALLSYMS_ON_EACH_SYMBOL
if (krp->kp.addr == 0)
return 1;
#else
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0)
if (krp->kp.symbol_name == NULL)
krp->kp.symbol_name = kstrdup(skp->symbol_name, STP_ALLOC_FLAGS);
#else
krp->kp.symbol_name = (typeof(krp->kp.symbol_name))skp->symbol_name;
#endif
krp->kp.offset = skp->offset;
#endif
}
if (skp->maxactive_p)
krp->maxactive = skp->maxactive_val;
else
krp->maxactive = KRETACTIVE;
krp->handler = &enter_kretprobe_probe;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
if (skp->entry_probe) {
krp->entry_handler = &enter_kretprobe_entry_probe;
krp->data_size = skp->saved_longs * sizeof(int64_t) +
skp->saved_strings * MAXSTRINGLEN;
}
#endif
#ifdef __ia64__ // PR6028
skp->kprobe->dummy.addr = krp->kp.addr;
skp->kprobe->dummy.pre_handler = NULL;
skp->kprobe->dummy.symbol_name = krp->kp.symbol_name;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
if (!skp->probe->cond_enabled) {
krp->kp.flags |= KPROBE_FLAG_DISABLED;
dbug_otf("registering as disabled (kretprobe) pidx %zu\n",
skp->probe->index);
}
#endif
return 0;
}
static int
stapkp_init(struct stap_kprobe_probe *probes,
size_t nprobes)
{
size_t i;
#ifdef STAPCONF_KALLSYMS_ON_EACH_SYMBOL
// If we have any symbol_name+offset probes, we need to try to
// convert those into address-based probes.
size_t probe_max = 0;
for (i = 0; i < nprobes; i++) {
struct stap_kprobe_probe *skp = &probes[i];
if (! skp->symbol_name)
continue;
++probe_max;
}
if (probe_max > 0) {
// Here we're going to try to convert any symbol_name+offset
// probes into address probes.
struct stapkp_symbol_data sd;
dbug_stapkp("looking up %lu probes\n", probe_max);
sd.probes = probes;
sd.nprobes = nprobes;
sd.probe_max = probe_max;
sd.modname = NULL;
preempt_disable();
kallsyms_on_each_symbol(stapkp_symbol_callback, &sd);
preempt_enable();
dbug_stapkp("found %lu probes\n", sd.probe_max);
}
#endif
for (i = 0; i < nprobes; i++) {
struct stap_kprobe_probe *skp = &probes[i];
int rc = 0;
rc = stapkp_register_probe(skp);
if (rc == 1) // failed to relocate addr?
continue; // don't fuss about it, module probably not loaded
// NB: We keep going even if a probe failed to register (PR6749). We only
// warn about it if it wasn't optional and isn't in a module.
if (rc && !skp->optional_p
&& ((skp->module == NULL) || skp->module[0] == '\0'
|| strcmp(skp->module, "kernel") == 0)) {
if (skp->symbol_name)
_stp_warn("probe %s (%s+%u) registration error (rc %d)",
skp->probe->pp, skp->symbol_name, skp->offset, rc);
else
_stp_warn("probe %s (address 0x%lx) registration error (rc %d)",
skp->probe->pp, stapkp_relocate_addr(skp), rc);
}
}
return 0;
}
static int
stapkp_prepare_kretprobe(struct stap_dwarf_probe *sdp)
{
struct kretprobe *krp = &sdp->kprobe->u.krp;
unsigned long addr = stapkp_relocate_addr(sdp);
if (addr == 0)
return 1;
krp->kp.addr = (void *) addr;
if (sdp->maxactive_p)
krp->maxactive = sdp->maxactive_val;
else
krp->maxactive = KRETACTIVE;
krp->handler = &enter_kretprobe_probe;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
if (sdp->entry_probe) {
krp->entry_handler = &enter_kretprobe_entry_probe;
krp->data_size = sdp->saved_longs * sizeof(int64_t) +
sdp->saved_strings * MAXSTRINGLEN;
}
#endif
#ifdef __ia64__ // PR6028
sdp->kprobe->dummy.addr = krp->kp.addr;
sdp->kprobe->dummy.pre_handler = NULL;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
if (!sdp->probe->cond_enabled) {
krp->kp.flags |= KPROBE_FLAG_DISABLED;
dbug_otf("registering as disabled (kretprobe) pidx %zu\n",
sdp->probe->index);
}
#endif
return 0;
}
static int
stapkp_init(struct stap_dwarf_probe *probes,
size_t nprobes)
{
size_t i;
for (i = 0; i < nprobes; i++) {
struct stap_dwarf_probe *sdp = &probes[i];
int rc = 0;
rc = stapkp_register_probe(sdp);
if (rc == 1) // failed to relocate addr?
continue; // don't fuss about it, module probably not loaded
// NB: We keep going even if a probe failed to register (PR6749). We only
// warn about it if it wasn't optional.
if (rc && !sdp->optional_p) {
_stp_warn("probe %s (address 0x%lx) registration error (rc %d)",
sdp->probe->pp, stapkp_relocate_addr(sdp), rc);
}
}
return 0;
}
/* stapkp_refresh is called for two reasons: either a kprobe needs to be
* enabled/disabled (modname is NULL), or a module has been loaded/unloaded and
* kprobes need to be registered/unregistered (modname is !NULL). */
static void
stapkp_refresh(const char *modname,
struct stap_kprobe_probe *probes,
size_t nprobes)
{
size_t i;
dbug_stapkp("refresh %lu probes with module %s\n", nprobes, modname ?: "?");
#ifdef STAPCONF_KALLSYMS_ON_EACH_SYMBOL
if (modname) {
size_t probe_max = 0;
for (i = 0; i < nprobes; i++) {
struct stap_kprobe_probe *skp = &probes[i];
// If this probe is in the same module that is being
// loaded/unloaded and the probe is symbol_name+offset based
// and it isn't registered (so the module must be loaded),
// try to convert all probes in the same module to
// address-based probes.
if (skp->module && strcmp(modname, skp->module) == 0
&& skp->symbol_name && skp->registered_p == 0)
++probe_max;
}
if (probe_max > 0) {
struct stapkp_symbol_data sd;
sd.probes = probes;
sd.nprobes = nprobes;
sd.probe_max = probe_max;
sd.modname = modname;
preempt_disable();
kallsyms_on_each_symbol(stapkp_symbol_callback, &sd);
preempt_enable();
}
}
#endif
for (i = 0; i < nprobes; i++) {
struct stap_kprobe_probe *skp = &probes[i];
// was this probe's target module loaded/unloaded
if (modname && skp->module
&& strcmp(modname, skp->module) == 0) {
int rc;
unsigned long addr = (! skp->symbol_name
? stapkp_relocate_addr(skp) : 0);
// module being loaded?
if (skp->registered_p == 0 && (addr != 0 || skp->symbol_name))
stapkp_register_probe(skp);
// module/section being unloaded?
else if (skp->registered_p == 1 && addr == 0)
stapkp_unregister_probe(skp);
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
else if (stapkp_should_enable_probe(skp)
|| stapkp_should_disable_probe(skp)) {
stapkp_refresh_probe(skp);
}
#endif
}
}
static int
stapkp_prepare_kprobe(struct stap_kprobe_probe *skp)
{
struct kprobe *kp = &skp->kprobe->u.kp;
unsigned long addr = 0;
if (! skp->symbol_name) {
addr = stapkp_relocate_addr(skp);
if (addr == 0)
return 1;
kp->addr = (void *) addr;
}
else {
#ifdef STAPCONF_KALLSYMS_ON_EACH_SYMBOL
// If we're doing symbolic name + offset probing (that gets
// converted to an address), it doesn't really matter if the
// symbol is in a module and the module isn't loaded right
// now. The registration will fail, but will get tried again
// when the module is loaded.
if (kp->addr == 0)
return 1;
#else
// If we don't have kallsyms_on_each_symbol(), we'll use
// symbol_name+offset probing and let
// register_kprobe()/register_kretprobe() call
// kallsyms_lookup_name() for us. However, on kernels < 3.11,
// module_kallsyms_lookup_name() (called from
// kallsyms_lookup_name()) has a bug where it modifies its
// argument. So, for those kernels we'll workaround the bug by
// duplicating the string (so we go from read-only memory in the
// initialized struct data to read-write allocated memory). The
// memory gets freed when the probe is unregistered.
//
// This bug was fixed in kernel 3.11+ by the following commit:
//
// commit 4f6de4d51f4a3ab06a85e91e708cc89a513ef30c
// Author: Mathias Krause <*****@*****.**>
// Date: Tue Jul 2 15:35:11 2013 +0930
//
// module: don't modify argument of module_kallsyms_lookup_name()
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0)
if (kp->symbol_name == NULL)
kp->symbol_name = kstrdup(skp->symbol_name, STP_ALLOC_FLAGS);
#else
kp->symbol_name = (typeof(kp->symbol_name))skp->symbol_name;
#endif
kp->offset = skp->offset;
#endif
}
kp->pre_handler = &enter_kprobe_probe;
#ifdef __ia64__ // PR6028
skp->kprobe->dummy.addr = kp->addr;
skp->kprobe->dummy.pre_handler = NULL;
skp->kprobe->dummy.symbol_name = kp->symbol_name;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
if (!skp->probe->cond_enabled) {
kp->flags |= KPROBE_FLAG_DISABLED;
dbug_otf("registering as disabled (kprobe) pidx %zu\n",
skp->probe->index);
}
#endif
return 0;
}
