Try not to break if batch bcc functions are unavailable

Author: parttimenerd

bcc/pom.xml

@@ -99,6 +99,12 @@
             <version>RELEASE</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>24.0.1</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
     <parent>

bcc/src/main/java/me/bechberger/ebpf/bcc/BPFTable.java

@@ -34,6 +34,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
 
 import static me.bechberger.ebpf.bcc.PanamaUtil.*;
 
@@ -191,18 +192,39 @@ public void rawRemove(Object key) {
         }
     }
 
+    /**
+     * Only use this method if batch functions are not available.
+     */
+    private Stream<K> slowKeyStream() {
+        assert !PanamaUtil.hasBCCBatchFunctions();
+        return keySet().stream();
+    }
+
     @NotNull
     public Set<K> keySet() {
+        if (!PanamaUtil.hasBCCBatchFunctions()) {
+            // very inefficient, but some bcc versions do not support batch functions
+            return slowKeyStream().collect(java.util.stream.Collectors.toSet());
+        }
         return items_lookup_batch().stream().map(Map.Entry::getKey).collect(java.util.stream.Collectors.toSet());
     }
 
     @NotNull
     public Collection<V> values() {
+        if (!PanamaUtil.hasBCCBatchFunctions()) {
+            // very inefficient, but some bcc versions do not support batch functions
+            return slowKeyStream().map(this::get).collect(java.util.stream.Collectors.toList());
+        }
         return items_lookup_batch().stream().map(Map.Entry::getValue).collect(java.util.stream.Collectors.toList());
     }
 
     @NotNull
     public Set<Map.Entry<K, V>> entrySet() {
+        if (!PanamaUtil.hasBCCBatchFunctions()) {
+            // very inefficient, but some bcc versions do not support batch functions
+            return slowKeyStream().map(k -> new AbstractMap.SimpleEntry<>(k, get(k)))
+                    .collect(java.util.stream.Collectors.toSet());
+        }
         return new HashSet<>(items_lookup_batch());
     }
 
@@ -297,6 +319,11 @@ private int sanity_check_keys_values(@Nullable MemorySegment keys, @Nullable Mem
      * @return key-value pairs
      */
     public List<Map.Entry<K, V>> items_lookup_batch() {
+        if (!PanamaUtil.hasBCCBatchFunctions()) {
+            // very inefficient, but some bcc versions do not support batch functions
+            return slowKeyStream().map(k -> new AbstractMap.SimpleEntry<>(k, get(k)))
+                    .collect(java.util.stream.Collectors.toList());
+        }
         return items_lookup_and_optionally_delete_batch(false);
     }
 
@@ -317,7 +344,8 @@ private ResultAndErr<Integer> bpf_delete_batch(Arena arena, int map_fd, @Nullabl
      *             deletes all the related keys-values.
      *             If keys is None (default) then it deletes all entries.
      */
-    public void items_delete_batch(Arena arena, @Nullable MemorySegment keys) {
+    private void items_delete_batch(Arena arena, @Nullable MemorySegment keys) {
+        assert PanamaUtil.hasBCCBatchFunctions();
         if (keys != null) {
             var count = sanity_check_keys_values(keys, null);
             var countRef = arena.allocate(ValueLayout.JAVA_LONG);
@@ -338,6 +366,15 @@ public void items_delete_batch(Arena arena, @Nullable MemorySegment keys) {
      * @param keys keys array to delete. If an array of keys is given then it deletes all
      */
     public void delete_keys(@Nullable List<K> keys) {
+        if (!PanamaUtil.hasBCCBatchFunctions()) {
+            // very inefficient, but some bcc versions do not support batch functions
+            if (keys == null) {
+                zero();
+                return;
+            }
+            keys.forEach(this::rawRemove);
+            return;
+        }
         try (var arena = Arena.ofConfined()) {
             if (keys != null) {
                 var allocated = alloc_key_values(arena, true, false, keys.size());
@@ -367,7 +404,7 @@ private static ResultAndErr<Integer> bpf_update_batch(Arena arena, int map_fd, @
      * @param keys   keys array to update
      * @param values values array to update
      */
-    public void items_update_batch(Arena arena, @Nullable MemorySegment keys, @Nullable MemorySegment values) {
+    private void items_update_batch(Arena arena, @Nullable MemorySegment keys, @Nullable MemorySegment values) {
         var count = sanity_check_keys_values(keys, values);
         var countRef = arena.allocate(ValueLayout.JAVA_LONG);
         countRef.set(ValueLayout.JAVA_LONG, 0, count);
@@ -380,7 +417,7 @@ public void items_update_batch(Arena arena, @Nullable MemorySegment keys, @Nulla
     /**
      * Look up and delete all the key-value pairs in the map.
      */
-    public List<Map.Entry<K, V>> items_lookup_and_delete_batch() {
+    private List<Map.Entry<K, V>> items_lookup_and_delete_batch() {
         return items_lookup_and_optionally_delete_batch(true);
     }
 

bcc/src/main/java/me/bechberger/ebpf/bcc/PanamaUtil.java

@@ -7,6 +7,8 @@
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.VarHandle;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 import static java.lang.foreign.ValueLayout.JAVA_BYTE;
 
@@ -19,6 +21,18 @@ public class PanamaUtil {
     public static final char O_WRONLY = 1;
     public static final char O_RDWR = 2;
 
+    private static final boolean HAS_BCC_BATCH_FUNCTIONS;
+    static {
+        boolean b = false;
+        try {
+            PanamaUtil.lookup("bpf_lookup_and_delete_batch");
+            b = true;
+        } catch (NoSuchElementException e) {
+            // ignore
+        }
+        HAS_BCC_BATCH_FUNCTIONS = b;
+    }
+
     /**
      * Convert a memory segment to a string, returns null if segment is NULL
      */
@@ -31,13 +45,25 @@ public static String toString(MemorySegment segment) {
 
     /**
      * Lookup a symbol in the current process
+     *
+     * @throws NoSuchElementException if the symbol is not found
      */
     public static MemorySegment lookup(String symbol) {
         return Linker.nativeLinker().defaultLookup().find(symbol)
                 .or(() -> SymbolLookup.loaderLookup().find(symbol))
                 .orElseThrow(() -> new NoSuchElementException("Symbol not found: " + symbol));
     }
 
+    /**
+     * Check if the batch functions of bcc (like bpf_lookup_and_delete_batch) are available.
+     * <p>
+     * Some versions of bcc (on some platforms) apparently do not have these functions.
+     * @return true if the batch functions are available
+     */
+    public static boolean hasBCCBatchFunctions() {
+        return HAS_BCC_BATCH_FUNCTIONS;
+    }
+
     /**
      * Pointer type
      */
@@ -78,10 +104,22 @@ public record ResultAndErr<R>(R result, int err) {
     /**
      * Wraps a method handle and captures the errno value
      */
-    public record HandlerWithErrno<R>(MethodHandle handle) {
+    public static class HandlerWithErrno<R> {
+
+        private MethodHandle handle = null;
+        private final Supplier<MethodHandle> handleSupplier;
 
         public HandlerWithErrno(String symbol, FunctionDescriptor descriptor) {
-            this(Linker.nativeLinker().downcallHandle(PanamaUtil.lookup(symbol), descriptor, Linker.Option.captureCallState("errno")));
+            handleSupplier = () -> Linker.nativeLinker()
+                    .downcallHandle(PanamaUtil.lookup(symbol), descriptor,
+                            Linker.Option.captureCallState("errno"));
+        }
+
+        private MethodHandle getHandle() {
+            if (handle == null) {
+                handle = handleSupplier.get();
+            }
+            return handle;
         }
 
         @SuppressWarnings("unchecked")
@@ -95,7 +133,8 @@ public ResultAndErr<R> call(Arena arena, Object... args) {
                 Object[] argsWithState = new Object[args.length + 1];
                 argsWithState[0] = capturedState;
                 System.arraycopy(args, 0, argsWithState, 1, args.length);
-                return new ResultAndErr<>((R) handle.invokeWithArguments(argsWithState), (int) errnoHandle.get(capturedState));
+                return new ResultAndErr<>((R) getHandle().invokeWithArguments(argsWithState),
+                        (int) errnoHandle.get(capturedState));
             } catch (Throwable throwable) {
                 throw new RuntimeException(throwable);
             }