Motivation:
Our bpf programs have a bunch of options which are set at the loading
time. After loading, they don't change. We currently use array map
to store them and bpf program does the following:
val = bpf_map_lookup_elem(&config_map, &key);
if (likely(val && *val)) {
// do some optional feature
}
Since the configuration is static and we have a lot of those features,
I feel like we're wasting precious cycles doing dynamic lookups
(and stalling on memory loads).
I was assuming that converting those to some fake kconfig options
would solve it, but it still seems like kconfig is stored in the
global map and kconfig entries are resolved dynamically.
Proposal:
Resolve kconfig options statically upon loading. Basically rewrite
ld+ldx to two nops and 'mov val, x'.
I'm also trying to rewrite conditional jump when the condition is
!imm. This seems to be catching all the cases in my program, but
it's probably too hacky.
I've attached very raw RFC patch to demonstrate the idea. Anything
I'm missing? Any potential problems with this approach?
Note, I don't intent to submit as is, mostly to start a discussion..
Signed-off-by: Stanislav Fomichev <sdf@xxxxxxxxxx>
---
tools/bpf/bpftool/prog.c | 3 +++
tools/lib/bpf/libbpf.c | 43 +++++++++++++++++++++++++++++++++++++---
2 files changed, 43 insertions(+), 3 deletions(-)
diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c
index f081de398b60..89d11b891735 100644
--- a/tools/bpf/bpftool/prog.c
+++ b/tools/bpf/bpftool/prog.c
@@ -1596,6 +1596,9 @@ static int load_with_options(int argc, char **argv, bool first_prog_only)
/* log_level1 + log_level2 + stats, but not stable UAPI */
open_opts.kernel_log_level = 1 + 2 + 4;
+ if (getenv("BPFTOOL_KCONFIG"))
+ open_opts.kconfig = getenv("BPFTOOL_KCONFIG");
+
obj = bpf_object__open_file(file, &open_opts);
if (libbpf_get_error(obj)) {
p_err("failed to open object file");
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 77ae83308199..58b45eb9a30a 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -5773,11 +5773,48 @@ bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog)
if (obj->gen_loader) {
insn[0].src_reg = BPF_PSEUDO_MAP_IDX_VALUE;
insn[0].imm = obj->kconfig_map_idx;
+ insn[1].imm = ext->kcfg.data_off;
} else {
- insn[0].src_reg = BPF_PSEUDO_MAP_VALUE;
- insn[0].imm = obj->maps[obj->kconfig_map_idx].fd;
+ bool is_set = ext->is_weak && ext->is_set;
+ bool is_ld_ldx = (BPF_CLASS(insn[0].code) == BPF_LD) &&
+ insn[1].code == 0 &&
+ (BPF_CLASS(insn[2].code) == BPF_LDX);
+
+ if (is_set && is_ld_ldx) {
+ __u32 dst_reg = insn[2].dst_reg; /* dst_reg is unchanged */
+ __s32 imm = 1; /* TODO: put real config value here */
+ int j;
+
+ /* Resolve dynamic kconfig lookups. */
+ insn[0] = BPF_JMP_A(0);
+ insn[1] = BPF_JMP_A(0);
+ insn[2] = BPF_ALU64_IMM(BPF_MOV, dst_reg, imm);
+
+ /* Look ahead at 7 insns. */
+ for (j = 3; j < 10; j++) {
+ /* SKETCHY?
+ *
+ * We can also replace conditional jump when it triggers with the opposite value.
+ * Scan a bunch of insns and stop as long we hit a jump or some other
+ * operation on the dst_reg.
+ */
+ if (BPF_CLASS(insn[j].code) == BPF_JMP) {
+ /* next insn is jump */
+ if (insn[j].dst_reg == dst_reg && /* that operates on the same dst_reg */
+ insn[j].imm == !imm) /* and the imm is the opposite */
+ insn[j] = BPF_JMP_A(0);
+ break;
+ } else {
+ if (insn[j].dst_reg == dst_reg)
+ break;
+ }
+ }
+ } else {
+ insn[0].src_reg = BPF_PSEUDO_MAP_VALUE;
+ insn[0].imm = obj->maps[obj->kconfig_map_idx].fd;
+ insn[1].imm = ext->kcfg.data_off;
+ }
}
- insn[1].imm = ext->kcfg.data_off;
} else /* EXT_KSYM */ {
if (ext->ksym.type_id && ext->is_set) { /* typed ksyms */
insn[0].src_reg = BPF_PSEUDO_BTF_ID;
--
2.37.0.170.g444d1eabd0-goog
