Add support for methods returning a long

minborg · minborg · commit 8345472d38c3 · 2025-02-01T08:09:12.000Z
diff --git a/src/java.base/share/classes/jdk/internal/foreign/ErrnoUtil.java b/src/java.base/share/classes/jdk/internal/foreign/ErrnoUtil.java
@@ -30,7 +30,6 @@
 import java.lang.foreign.Linker;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.StructLayout;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
@@ -39,55 +38,76 @@
 public final class ErrnoUtil {
 
     private static final Unsafe UNSAFE = Unsafe.getUnsafe();
-    private static final MethodHandles.Lookup ARGUS = MethodHandles.lookup();
-    private static final TerminatingThreadLocal<MemorySegment> TL = new TerminatingThreadLocal<>(){
+    private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
+
+    private static final TerminatingThreadLocal<MemorySegment> TL = new TerminatingThreadLocal<>() {
         @Override
         protected void threadTerminated(MemorySegment value) {
             free(value);
         }
     };
 
-    private static final StructLayout CAPTURE_STATE_LAYOUT = Linker.Option.captureStateLayout();
-        private static final VarHandle ERRNO_HANDLE =
-            CAPTURE_STATE_LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("errno"));
+    private static final VarHandle ERRNO_HANDLE =
+            Linker.Option.captureStateLayout()
+                    .varHandle(MemoryLayout.PathElement.groupElement("errno"));
 
     private static final MethodHandle ACQUIRE_MH =
-            MhUtil.findStatic(ARGUS, "acquireCaptureStateSegment",
+            MhUtil.findStatic(LOOKUP, "acquireCaptureStateSegment",
                     MethodType.methodType(MemorySegment.class));
-    private static final MethodHandle RETURN_FILTER_MH =
-            MhUtil.findStatic(ARGUS, "returnFilter",
+
+    private static final MethodHandle INT_RETURN_FILTER_MH =
+            MhUtil.findStatic(LOOKUP, "returnFilter",
                     MethodType.methodType(int.class, int.class));
 
-    private ErrnoUtil() {}
+    private static final MethodHandle LONG_RETURN_FILTER_MH =
+            MhUtil.findStatic(LOOKUP, "returnFilter",
+                    MethodType.methodType(long.class, long.class));
+
+    private ErrnoUtil() {
+    }
 
     /**
-     * {@return a new MethodHandle that returns the returned int value if the
-     *          returned value is non-negative, or else the negative errno}
+     * {@return a new MethodHandle that adapts the provided {@code target} so that it
+     *          directly returns the same value as the {@code target} if it is
+     *          non-negative, otherwise returns the negated errno}
      * <p>
-     * As such, this method is suitable for adapting method handles for system calls
-     * (e.g. {@code open()}, {@code read()}, and {@code close()}).
+     * This method is suitable for adapting system-call method handles(e.g.
+     * {@code open()}, {@code read()}, and {@code close()}). Clients can check the return
+     * value as shown in this example:
+     * {@snippet lang = java:
+     *      static final MethodHandle OPEN = ErrnoUtil.adaptSystemCall(CAPTURING_OPEN);
      *
-     * @param target that returns an {@code int} and has an errno MemorySegment as
-     *               the first parameter
-     * @throws IllegalArgumentException if the provided {@code target}'s return type
-     *         is not {@code int}
+     *      try {
+     *         int fh = (int)OPEN.invoke(pathName, flags);
+     *         if (fh < 0) {
+     *             throw new IOException("Error opening file: errno = " + (-fh));
+     *         }
+     *         processFile(fh);
+     *      }
+     *
+     *}
+     *
+     * @param target method handle that returns an {@code int} or a {@code long} and has
+     *              an errno MemorySegment as its first parameter
+     * @throws IllegalArgumentException if the provided {@code target}'s return type is
+     *                                  not {@code int} or {@code long}
      * @throws IllegalArgumentException if the provided {@code target}'s first parameter
-     *         type is not {@linkplain MemorySegment}
+     *                                  type is not {@linkplain MemorySegment}
      */
     public static MethodHandle adaptSystemCall(MethodHandle target) {
-        if (target.type().returnType() != int.class) {
-            throw new IllegalArgumentException("The provided target " + target
-                    + " does not return an int");
+        // Implicit null check
+        final Class<?> returnType = target.type().returnType();
+        if (!(returnType.equals(int.class) || returnType.equals(long.class))) {
+            throw illegalArgNot(target, "return an int or a long");
         }
         if (target.type().parameterType(0) != MemorySegment.class) {
-            throw new IllegalArgumentException("The provided target " + target
-                    + " does not have a MemorySegment as the first parameter");
+            throw illegalArgNot(target, "have a MemorySegment as the first parameter");
         }
-        // (MemorySegment, C*)int -> (C*)int
+        // (MemorySegment, C*)(int | long) -> (C*)(int | long)
         target = MethodHandles.collectArguments(target, 0, ACQUIRE_MH);
-        // (C*)int -> (C*)int
-        target = MethodHandles.filterReturnValue(target, RETURN_FILTER_MH);
-        return target;
+        // (C*)(int | long) -> (C*)(int | long)
+        return MethodHandles.filterReturnValue(target,
+                returnType.equals(int.class) ? INT_RETURN_FILTER_MH : LONG_RETURN_FILTER_MH);
     }
 
     // Used reflectively via ACQUIRE_MH
@@ -101,19 +121,32 @@ private static MemorySegment acquireCaptureStateSegment() {
 
     // Used reflectively via RETURN_FILTER_MH
     private static int returnFilter(int result) {
-        return result >= 0
-                ? result
-                : -(int) ERRNO_HANDLE.get(acquireCaptureStateSegment(), 0L);
+        return result >= 0 ? result : -errno();
+    }
+
+    // Used reflectively via RETURN_FILTER_MH
+    private static long returnFilter(long result) {
+        return result >= 0 ? result : -errno();
+    }
+
+    private static int errno() {
+        return (int) ERRNO_HANDLE.get(acquireCaptureStateSegment(), 0L);
     }
 
     @SuppressWarnings("restricted")
     private static MemorySegment malloc() {
-        long address = UNSAFE.allocateMemory(CAPTURE_STATE_LAYOUT.byteSize());
-        return MemorySegment.ofAddress(address).reinterpret(CAPTURE_STATE_LAYOUT.byteSize());
+        final long size = Linker.Option.captureStateLayout().byteSize();
+        final long address = UNSAFE.allocateMemory(size);
+        return MemorySegment.ofAddress(address).reinterpret(size);
     }
 
     private static void free(MemorySegment segment) {
         UNSAFE.freeMemory(segment.address());
     }
 
+    private static IllegalArgumentException illegalArgNot(MethodHandle target, String info) {
+        return new IllegalArgumentException("The provided target " + target
+                + " does not " + info);
+    }
+
 }
diff --git a/test/jdk/java/foreign/TestErrnoUtil.java b/test/jdk/java/foreign/TestErrnoUtil.java
@@ -46,39 +46,93 @@ final class TestErrnoUtil {
     private static final VarHandle ERRNO_HANDLE = Linker.Option.captureStateLayout()
                     .varHandle(MemoryLayout.PathElement.groupElement("errno"));
 
-    private static final MethodHandle DUMMY_HANDLE;
+    private static final MethodHandle INT_DUMMY_HANDLE;
+    private static final MethodHandle LONG_DUMMY_HANDLE;
 
     static {
         try {
-            DUMMY_HANDLE = MethodHandles.lookup()
+            MethodHandles.Lookup lookup = MethodHandles.lookup();
+            INT_DUMMY_HANDLE = lookup
                     .findStatic(TestErrnoUtil.class, "dummy",
                             MethodType.methodType(int.class, MemorySegment.class, int.class, int.class));
+            LONG_DUMMY_HANDLE = lookup
+                    .findStatic(TestErrnoUtil.class, "dummy",
+                            MethodType.methodType(long.class, MemorySegment.class, long.class, int.class));
         } catch (ReflectiveOperationException e) {
             throw new InternalError(e);
         }
     }
 
     @Test
-    void successful() throws Throwable {
-        MethodHandle adapted = ErrnoUtil.adaptSystemCall(DUMMY_HANDLE);
+    void successfulInt() throws Throwable {
+        MethodHandle adapted = ErrnoUtil.adaptSystemCall(INT_DUMMY_HANDLE);
         int r = (int) adapted.invoke(1, 0);
         assertEquals(1, r);
     }
 
     private static final int EACCES = 13; /* Permission denied */
 
     @Test
-    void error() throws Throwable {
-        MethodHandle adapted = ErrnoUtil.adaptSystemCall(DUMMY_HANDLE);
+    void errorInt() throws Throwable {
+        MethodHandle adapted = ErrnoUtil.adaptSystemCall(INT_DUMMY_HANDLE);
 
         int r = (int) adapted.invoke(-1, EACCES);
         assertEquals(-EACCES, r);
     }
 
+    @Test
+    void successfulLong() throws Throwable {
+        MethodHandle adapted = ErrnoUtil.adaptSystemCall(LONG_DUMMY_HANDLE);
+        long r = (long) adapted.invoke(1, 0);
+        assertEquals(1, r);
+    }
+
+    @Test
+    void errorLong() throws Throwable {
+        MethodHandle adapted = ErrnoUtil.adaptSystemCall(LONG_DUMMY_HANDLE);
+
+        long r = (long) adapted.invoke(-1, EACCES);
+        assertEquals(-EACCES, r);
+    }
+
+    @Test
+    void invariants() throws Throwable {
+        assertThrows(NullPointerException.class, () -> ErrnoUtil.adaptSystemCall(null));
+
+        MethodHandle noSegment = MethodHandles.lookup()
+                .findStatic(TestErrnoUtil.class, "wrongType",
+                        MethodType.methodType(long.class, long.class, int.class));
+
+        var noSegEx = assertThrows(IllegalArgumentException.class, () -> ErrnoUtil.adaptSystemCall(noSegment));
+        assertTrue(noSegEx.getMessage().contains("does not have a MemorySegment as the first parameter"));
+
+        MethodHandle wrongReturnType = MethodHandles.lookup()
+                .findStatic(TestErrnoUtil.class, "wrongType",
+                        MethodType.methodType(short.class, MemorySegment.class, long.class, int.class));
+
+        var wrongRetEx = assertThrows(IllegalArgumentException.class, () -> ErrnoUtil.adaptSystemCall(wrongReturnType));
+        assertTrue(wrongRetEx.getMessage().contains("does not return an int or a long"));
+
+    }
+
     // Dummy method that is just returning the provided parameters
     private static int dummy(MemorySegment segment, int result, int errno) {
         ERRNO_HANDLE.set(segment, 0, errno);
         return result;
     }
 
+    // Dummy method that is just returning the provided parameters
+    private static long dummy(MemorySegment segment, long result, int errno) {
+        ERRNO_HANDLE.set(segment, 0, errno);
+        return result;
+    }
+
+    private static long wrongType(long result, int errno) {
+        return 0;
+    }
+
+    private static short wrongType(MemorySegment segment, long result, int errno) {
+        return 0;
+    }
+
 }
