Get custom labels working with clang-17 and 4.19 kernel

Author: gnurizen

.github/workflows/unit-test-on-pull-request.yml

@@ -120,6 +120,7 @@ jobs:
           # https://github.com/cilium/ci-kernels/pkgs/container/ci-kernels/versions?filters%5Bversion_type%5D=tagged
 
           # AMD64
+          - { target_arch: amd64, kernel: 4.19.314 }
           - { target_arch: amd64, kernel: 5.4.276 }
           - { target_arch: amd64, kernel: 5.10.217 }
           - { target_arch: amd64, kernel: 5.15.159 }

support/ebpf/Makefile

@@ -1,7 +1,7 @@
 SHELL ?= bash
-BPF_CLANG ?= clang-16
-BPF_LINK ?= llvm-link-16
-LLC ?= llc-16
+BPF_CLANG ?= clang-17
+BPF_LINK ?= llvm-link-17
+LLC ?= llc-17
 
 DEBUG_FLAGS = -DOPTI_DEBUG -g
 

support/ebpf/bpfdefs.h

@@ -157,14 +157,4 @@ static long (*bpf_perf_prog_read_value)(struct pt_regs *ctx, struct bpf_perf_eve
 
 #endif // !TESTING_COREDUMP
 
-// HACK: On failure, bpf_perf_prog_read_value() zeroes the buffer. We ensure that this always
-// fail with a compile time assert that ensures that the struct size is different to the size
-// of the expected structure.
-#define bpf_large_memzero(_d, _l)                                                                                        \
-    ({                                                                                                                   \
-        _Static_assert(_l != sizeof(struct bpf_perf_event_value), "stack size must be different to the valid argument"); \
-        bpf_perf_prog_read_value(ctx, _d, _l);                                                                           \
-    })
-
-
 #endif // OPTI_BPFDEFS_H

support/ebpf/extmaps.h

@@ -17,6 +17,7 @@ extern bpf_map_def inhibit_events;
 extern bpf_map_def interpreter_offsets;
 extern bpf_map_def system_config;
 extern bpf_map_def trace_events;
+extern bpf_map_def go_procs;
 
 #if defined(TESTING_COREDUMP)
 

support/ebpf/hash.h

@@ -3,90 +3,33 @@
 
 #include "types.h"
 
-#define ROUNDUP_8(x) ((x + 7) & ~7)
-static inline __attribute__((__always_inline__))
-bool hash_custom_labels(CustomLabelsArray *lbls, int seed, u64 *out) {
-    // apply murmurhash2 as though this is an array of
-    // the number of labels (8 bytes), followed by all the key/val lengths,
-    // followed by all the keys/vals.
-    const u64 m = 0xc6a4a7935bd1e995LLU;
-    const int r = 47;
-
-    int len = 8;
-    for (int i = 0; i < MAX_CUSTOM_LABELS; ++i) {
-        if (i >= lbls->len)
-            break;
-        len += 8;
-        len += ROUNDUP_8(lbls->labels[i].key_len);
-        len += ROUNDUP_8(lbls->labels[i].val_len);
-    }
-
-    u64 h = seed ^ (len * m);
-
-    // hash the number of labels
-    {
-        u64 k = lbls->len;
-        k *= m;
-        k ^= k >> r;
-        k *= m;
-
-        h ^= k;
-        h *= m;
-    }
-
-    // hash each k/v len
-    for (int i = 0; i < MAX_CUSTOM_LABELS; ++i) {
-        // force clang not to unroll the loop by hiding the value of i.
-        // Unrolling this loop confuses the verifier.
-        asm volatile("" : "=r"(i) : "0"(i));
-        if (i >= lbls->len)
-            break;
-        u64 k = (((u64)lbls->labels[i].key_len) << 32) | ((u64)lbls->labels[i].val_len);
-        k *= m;
-        k ^= k >> r;
-        k *= m;
+#define M 0xc6a4a7935bd1e995LLU
 
-        h ^= k;
-        h *= m;
+static inline __attribute__((__always_inline__))
+u64 clear_or_hash_custom_labels(CustomLabelsArray *lbls, bool clear) {
+    u64 h = lbls->len * M;
+    u64 *bits = (u64 *)lbls;
+#pragma unroll
+    for (int i=0; i < sizeof(CustomLabelsArray)/8; i++) {
+      if (clear) {
+        bits[i] = 0;
+      } else {
+        h ^= bits[i];
+        h *= M;
+      }
     }
 
-    // hash each k/v
-    for (int i = 0; i < MAX_CUSTOM_LABELS; ++i) {
-        if (i >= lbls->len)
-            break;
-        CustomLabel *lbl = &lbls->labels[i];
-        u64 kl = ROUNDUP_8(lbl->key_len);
-        for (int j = 0; j < CUSTOM_LABEL_MAX_VAL_LEN / 8; ++j) {
-            if (j >= kl)
-                return false;
-            u64 k = lbl->key.key_u64[j];
-            k *= m;
-            k ^= k >> r;
-            k *= m;
-
-            h ^= k;
-            h *= m;
-        }
-        u64 vl = ROUNDUP_8(lbl->val_len);
-        for (int j = 0; j < CUSTOM_LABEL_MAX_VAL_LEN / 8; ++j) {
-            if (j >= vl)
-                return false;
-            u64 k = lbl->val.val_u64[j];
-            k *= m;
-            k ^= k >> r;
-            k *= m;
-
-            h ^= k;
-            h *= m;
-        }
-    }
+    return h;
+}
 
-    h ^= h >> r;
-    h *= m;
-    h ^= h >> r;
+static inline __attribute__((__always_inline__))
+void clear_custom_labels(CustomLabelsArray *lbls) {
+  clear_or_hash_custom_labels(lbls, true);
+}
 
-    *out = h;
-    return true;
+static inline __attribute__((__always_inline__))
+u64 hash_custom_labels(CustomLabelsArray *lbls) {
+  return clear_or_hash_custom_labels(lbls, false);
 }
 
-#endif
+#endif  // OPTI_HASH_H