[PATCH 34/38] Create the BPF uprobes map

eugene.loh
2024-06-27T05:39:46Z

From: Eugene Loh <eugene.loh@oracle.com>

WIP, sizing is hardwired for now.
WIP, should add new pids and purge old ones (after the initial call).

Signed-off-by: Eugene Loh <eugene.loh@oracle.com>
---
libdtrace/dt_bpf.c | 44 +++++++++++++++++++++++++++
libdtrace/dt_dlibs.c | 1 +
libdtrace/dt_impl.h | 3 ++
libdtrace/dt_prov_uprobe.c | 61 ++++++++++++++++++++++++++++++++++++++
4 files changed, 109 insertions(+)

diff --git a/libdtrace/dt_bpf.c b/libdtrace/dt_bpf.c
index 428cb407..908c2823 100644
--- a/libdtrace/dt_bpf.c
+++ b/libdtrace/dt_bpf.c
@@ -944,6 +944,49 @@ gmap_create_probes(dtrace_hdl_t *dtp)
return 0;
}

+/*
+ * Create the 'uprobes' BPF map.
+ *
+ * Uprobe information map. This is a global hash map for use
+ * with USDT and pid probes). It is indexed by (pid, probe ID),
+ * using the probe ID of the underlying probe. The value is a
+ * probe ID for the overlying probe and a bit mask indicating
+ * which clauses to execute for this pid.
+ *
+ * WIP. Just make up some sizes for now.
+ *
+ * How big is a probe ID? Sometimes, it's a dtrace_id_t.
+ * And uts/common/sys/dtrace_types.h gives us "typedef uint32_t dtrace_id_t".
+ * Meanwhile, libdtrace/dt_impl.h has "uint32_t dt_probe_id".
+ * So either uint32_t or dtrace_id_t is fine.
+ *
+ * How big should our bit mask be? Start with 8*sizeof(long long) bits.
+ *
+ * How many entries should we allow? Start with 1000.
+ *
+ * WIP. Note that two different overlying probes (differing by more
+ * than just pid) could map to the same underlying probe. E.g., a
+ * USDT probe would have an underlying probe and pid probe with the
+ * right offset could map to the same uprobe. This means that clauses
+ * called by the uprobe might have to be called more than once; one
+ * would need to go through the clauses once for one overlying probe
+ * and then again for the other. This scenario is not yet addressed.
+ * It is a problem even before this patch, but easier to fix.
+ */
+static int
+gmap_create_uprobes(dtrace_hdl_t *dtp)
+{
+ dtp->dt_uprobesmap_fd = create_gmap(dtp, "uprobes", BPF_MAP_TYPE_HASH,
+ dtp->dt_uprobesmap_ksz, dtp->dt_uprobesmap_vsz, 1000);
+ if (dtp->dt_uprobesmap_fd == -1)
+ return -1;
+
+ /* Populate the newly created map. FIXME: this is probably not the right place for this. */
+ dt_uprobe.update(dtp, NULL);
+
+ return 0;
+}
+
/*
* Create the 'gvars' BPF map.
*
@@ -1049,6 +1092,7 @@ dt_bpf_gmap_create(dtrace_hdl_t *dtp)
CREATE_MAP(scratchmem)
CREATE_MAP(strtab)
CREATE_MAP(probes)
+ CREATE_MAP(uprobes)
CREATE_MAP(gvars)
CREATE_MAP(lvars)
CREATE_MAP(dvars)
diff --git a/libdtrace/dt_dlibs.c b/libdtrace/dt_dlibs.c
index 1fb561ad..357396c8 100644
--- a/libdtrace/dt_dlibs.c
+++ b/libdtrace/dt_dlibs.c
@@ -66,6 +66,7 @@ static const dt_ident_t dt_bpf_symbols[] = {
DT_BPF_SYMBOL(lvars, DT_IDENT_PTR),
DT_BPF_SYMBOL(mem, DT_IDENT_PTR),
DT_BPF_SYMBOL(probes, DT_IDENT_PTR),
+ DT_BPF_SYMBOL(uprobes, DT_IDENT_PTR),
DT_BPF_SYMBOL(scratchmem, DT_IDENT_PTR),
DT_BPF_SYMBOL(specs, DT_IDENT_PTR),
DT_BPF_SYMBOL(state, DT_IDENT_PTR),
diff --git a/libdtrace/dt_impl.h b/libdtrace/dt_impl.h
index f8799b86..1368d484 100644
--- a/libdtrace/dt_impl.h
+++ b/libdtrace/dt_impl.h
@@ -423,6 +423,9 @@ struct dtrace_hdl {
int dt_aggmap_fd; /* file descriptor for the 'aggs' BPF map */
int dt_genmap_fd; /* file descriptor for the 'agggen' BPF map */
int dt_cpumap_fd; /* file descriptor for the 'cpuinfo' BPF map */
+ int dt_uprobesmap_fd; /* file descriptor for the 'uprobes' BPF map */
+ int dt_uprobesmap_ksz; /* 'uprobes' BPF map key size */
+ int dt_uprobesmap_vsz; /* 'uprobes' BPF map value size */
dtrace_handle_err_f *dt_errhdlr; /* error handler, if any */
void *dt_errarg; /* error handler argument */
dtrace_handle_drop_f *dt_drophdlr; /* drop handler, if any */
diff --git a/libdtrace/dt_prov_uprobe.c b/libdtrace/dt_prov_uprobe.c
index 5f0c56db..e99f02c3 100644
--- a/libdtrace/dt_prov_uprobe.c
+++ b/libdtrace/dt_prov_uprobe.c
@@ -45,6 +45,7 @@
#include "dt_probe.h"
#include "dt_pid.h"
#include "dt_string.h"
+#include "port.h"

/* Provider name for the underlying probes. */
static const char prvname[] = "uprobe";
@@ -69,6 +70,15 @@ typedef struct list_probe {
dt_probe_t *probe;
} list_probe_t;

+typedef struct uprobe_map_key {
+ pid_t pid;
+ dtrace_id_t uprid;
+} uprobe_map_key_t;
+typedef struct uprobe_map_val {
+ dtrace_id_t prid;
+ long long mask;
+} uprobe_map_val_t;
+
static const dtrace_pattr_t pattr = {
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_ISA },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
@@ -83,6 +93,9 @@ dt_provimpl_t dt_usdt;

static int populate(dtrace_hdl_t *dtp)
{
+ dtp->dt_uprobesmap_ksz = sizeof(uprobe_map_key_t);
+ dtp->dt_uprobesmap_vsz = sizeof(uprobe_map_val_t);
+
if (dt_provider_create(dtp, dt_uprobe.name, &dt_uprobe, &pattr,
NULL) == NULL ||
dt_provider_create(dtp, dt_uprobe_is_enabled.name,
@@ -162,6 +175,53 @@ static int probe_add_clause(dtrace_hdl_t *dtp, dt_probe_t *prp, dt_ident_t *idp)
return 0;
}

+/*
+ * Update the uprobe provider.
+ */
+static void update_uprobe(dtrace_hdl_t *dtp, void *datap)
+{
+ dt_probe_t *prp;
+
+ for (prp = dt_list_next(&dtp->dt_enablings); prp != NULL;
+ prp = dt_list_next(prp)) {
+ pid_t pid;
+ const list_probe_t *pup;
+
+ /* Make sure it is an overlying pid or USDT probe. */
+ if (prp->prov->impl != &dt_pid && prp->prov->impl != &dt_usdt)
+ continue;
+
+ /* FIXME passing in NULL pcb and dpr wreaks havoc on error reporting? */
+ pid = dt_pid_get_pid(prp->desc, dtp, NULL, NULL);
+
+ for (pup = prp->prv_data; pup != NULL; pup = dt_list_next(pup)) {
+ dt_probe_t *uprp = pup->probe;
+ dt_probe_clause_t *pcp;
+ long long mask = 0, bit = 1;
+ uprobe_map_key_t key;
+ uprobe_map_val_t val;
+
+ for (pcp = dt_list_next(&uprp->clauses); pcp; pcp = dt_list_next(pcp)) {
+ int n = atoi(pcp->clause->di_name + strlen("dt_clause_"));
+
+ if (gmatch(prp->desc->prv, dtp->dt_retained[n]->prv))
+ mask |= bit;
+
+ bit <<= 1;
+ }
+
+ key.pid = pid;
+ key.uprid = uprp->desc->id;
+
+ val.prid = prp->desc->id;
+ val.mask = mask;
+
+ // FIXME Check return value, but how should errors be handled?
+ dt_bpf_map_update(dtp->dt_uprobesmap_fd, &key, &val);
+ }
+ }
+}
+
/*
* Look up or create an underlying (real) probe, corresponding directly to a
* uprobe. Since multiple pid and USDT probes may all map onto the same
@@ -820,6 +880,7 @@ dt_provimpl_t dt_uprobe = {
.probe_info = &probe_info,
.detach = &detach,
.probe_destroy = &probe_destroy_underlying,
+ .update = &update_uprobe,
};

/*
--
2.18.4