[PATCH 34/38] Create the BPF uprobes map

[eugene.loh@oracle.com]

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