Reading constants from an ELF

[thediveo]

Describe the bug

Hopefully I've not missed the obvious here ... to the best of my knowledge there isn't currently "an official" way to keep constant/#define definitions synchronized between the eBPF C side and associated Go code. However, the opposite direction is supported via ebpf.CollectionSpec.RewriteConstants.

A potential ebpf.CollectionSpec.GetConstants(consts map[string]any) error would allow (albeit only at runtime) the Go side of code to pick up constant definitions and be always in sync; no more duplicate definition with #define in the eBPF program, and potentially out-of-sync Go consts.

For instance, in the eBPF C code:

#define MAX_FOOBAR 42
const volatile u64 max_foobar = MAX_FOOBAR;

SEC("very_raw_tracepoint/ohlala")
int BPF_PROG(ohlala) {
    /* ensure .rodata volatile constants get loaded */ __u32 _ = max_foobar;
}

Nota bene: I found out the hard way that elfCode.loadDataSections skips sections (including .rodata) when they aren't referenced in any way by program sections.

How to reproduce

n/a

Version information

github.com/cilium/ebpf v0.16.0

[ti-mo]

Reading constants is now possible with #1564 and will ship in 0.17. Manual is here: https://ebpf-go.dev/concepts/global-variables.

However, this strikes me as rather roundabout, esp. since we cull unreferenced symbols as you've mentioned. This cannot be worked around (aside from creating a reference..) and is still the case with the new CollectionSpec.Variables implementation.

For carrying e.g. some version info or other build-time info in an ELF, consider putting them in enums. Your MAX_ symbol in particular looks like it could be an enum in your actual code base. An ELF's enums are preserved in BTF, quick example in the repo's testdata:

λ  ebpf main ✓ bpftool btf dump file testdata/errors-el.elf
...
[4] STRUCT 'nonexist' size=4 vlen=1
	'non_exist' type_id=2 bits_offset=0

Try this in C:

enum metadata { bar = 1 };
// __hidden to omit from CollectionSpec.Variables. You could make this static,
// but then you'll need to mark it with __attribute__((used)), pick your poison..
// In the ELF, these would look exactly the same.
__hidden volatile enum metadata __meta;

bpftool:

[89] ENUM 'metadata' encoding=UNSIGNED size=4 vlen=1
        'bar' val=1

In Go:

var consts *btf.Enum
if err := spec.Types.TypeByName("metadata", &consts); err != nil {
    panic(err)
}

for _, v := range consts.Values {
    if v.Name == "non_exist" {
        return v.Value
    }
}

Hope this helps.

[thediveo]

It took me some time to finally arrive at the refactoring stage for this q&a, but now I've refactored my code to use the enum method as outlined by you. This allows me to retire my previous hack, so thank you very much again for your help!