Linux: varhandle for array access

Author: manuelbl

java-does-usb/src/main/java/net/codecrete/usb/linux/EPoll.java

@@ -22,6 +22,23 @@
 
 @SuppressWarnings({"OptionalGetWithoutIsPresent", "SameParameterValue", "java:S100"})
 public class EPoll {
+    // Memory layout for an array of epoll_event structs
+    private static final SequenceLayout EVENT_ARRAY$LAYOUT = MemoryLayout.sequenceLayout(epoll_event.$LAYOUT());
+
+    // varhandle to access the "fd" field in an array of epoll_event structs
+    static final VarHandle EVENT_ARRAY_DATA_FD$VH = EVENT_ARRAY$LAYOUT.varHandle(
+            MemoryLayout.PathElement.sequenceElement(),
+            MemoryLayout.PathElement.groupElement("data"),
+            MemoryLayout.PathElement.groupElement("fd")
+    );
+
+    // varhandle to access the "fd" field in an epoll_event struct
+    static final VarHandle EVENT_DATA_FD$VH = epoll_event.$LAYOUT().varHandle(
+            MemoryLayout.PathElement.groupElement("data"),
+            MemoryLayout.PathElement.groupElement("fd")
+    );
+
+
     private EPoll() {}
 
     private static final Linker linker = Linker.nativeLinker();
@@ -38,11 +55,6 @@ private EPoll() {}
     private static final MethodHandle epoll_wait$MH = linker.downcallHandle(linker.defaultLookup().find(
             "epoll_wait").get(), epoll_wait$FUNC, Linux.ERRNO_STATE);
 
-    private static final VarHandle epoll_event_data_fd$VH = epoll_event.$LAYOUT().varHandle(
-            MemoryLayout.PathElement.groupElement("data"),
-            MemoryLayout.PathElement.groupElement("fd")
-    );
-
     static int epoll_create(int size, MemorySegment errno) {
         try {
             return (int) epoll_create$MH.invokeExact(errno, size);
@@ -73,7 +85,7 @@ static void addFileDescriptor(int epfd, int op, int fd) {
 
             var event = arena.allocate(epoll_event.$LAYOUT());
             epoll_event.events$set(event, op);
-            epoll_event_data_fd$VH.set(event, fd);
+            EVENT_DATA_FD$VH.set(event, fd);
             var ret = epoll_ctl(epfd, EPOLL_CTL_ADD(), fd, event, errorState);
             if (ret < 0)
                 throwLastError(errorState, "internal error (epoll_ctl_add)");
@@ -86,7 +98,7 @@ static void removeFileDescriptor(int epfd, int fd) {
 
             var event = arena.allocate(epoll_event.$LAYOUT());
             epoll_event.events$set(event, 0);
-            epoll_event_data_fd$VH.set(event, fd);
+            EVENT_DATA_FD$VH.set(event, fd);
             var ret = epoll_ctl(epfd, EPOLL_CTL_DEL(), fd, event, errorState);
             if (ret < 0) {
                 var err = Linux.getErrno(errorState);

java-does-usb/src/main/java/net/codecrete/usb/linux/LinuxAsyncTask.java

@@ -13,9 +13,7 @@
 import net.codecrete.usb.linux.gen.usbdevice_fs.usbdevfs_urb;
 
 import java.lang.foreign.Arena;
-import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
-import java.lang.invoke.VarHandle;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -57,11 +55,6 @@ class LinuxAsyncTask {
 
     private static final int NUM_EVENTS = 5;
 
-    private static final VarHandle epoll_event_data_fd$VH = epoll_event.$LAYOUT().varHandle(
-            MemoryLayout.PathElement.groupElement("data"),
-            MemoryLayout.PathElement.groupElement("fd")
-    );
-
     private final Arena urbArena = Arena.ofAuto();
     /// available URBs
     private final List<MemorySegment> availableURBs = new ArrayList<>();
@@ -87,16 +80,18 @@ private void asyncCompletionTask() {
 
             while (true) {
 
+                // wait for file descriptor to be ready
                 var res = epoll_wait(epollFd, events, NUM_EVENTS, -1, errorState);
                 if (res < 0) {
                     var err = Linux.getErrno(errorState);
                     if (err == EINTR())
-                        continue;
+                        continue; // continue on interrupt
                     throwException(err, "internal error (epoll_wait)");
                 }
 
+                // for all ready file descriptors, reap URBs
                 for (int i = 0; i < res; i++) {
-                    var fd = (int) epoll_event_data_fd$VH.get(events.asSlice(epoll_event.sizeof() * i, epoll_event.sizeof()));
+                    var fd = (int) EPoll.EVENT_ARRAY_DATA_FD$VH.get(events, i);
                     reapURBs(fd, urbPointerHolder, errorState);
                 }
             }
@@ -111,6 +106,7 @@ private void asyncCompletionTask() {
      * @param errorState       native memory to receive the errno
      */
     private void reapURBs(int fd, MemorySegment urbPointerHolder, MemorySegment errorState) {
+
         while (true) {
             var res = IO.ioctl(fd, REAPURBNDELAY, urbPointerHolder, errorState);
             if (res < 0) {
@@ -119,7 +115,7 @@ private void reapURBs(int fd, MemorySegment urbPointerHolder, MemorySegment erro
                     return; // no more pending URBs
                 if (err == errno.ENODEV()) {
                     // device might have been unplugged
-                    removeFdFromAsyncIOCompletion(fd);
+                    EPoll.removeFileDescriptor(epollFd, fd);
                     return;
                 }
                 throwException(err, "internal error (reap URB)");
@@ -154,13 +150,9 @@ synchronized void removeFromAsyncIOCompletion(LinuxUsbDevice device) {
         EPoll.removeFileDescriptor(epollFd, device.fileDescriptor());
     }
 
-    private synchronized void removeFdFromAsyncIOCompletion(int fd) {
-        EPoll.removeFileDescriptor(epollFd, fd);
-    }
-
     synchronized void submitTransfer(LinuxUsbDevice device, int endpointAddress, UsbTransferType transferType, LinuxTransfer transfer) {
 
-        addURB(transfer);
+        linkToUrb(transfer);
         var urb = transfer.urb;
 
         usbdevfs_urb.type$set(urb, (byte) urbTransferType(transferType));
@@ -188,7 +180,15 @@ private static int urbTransferType(UsbTransferType transferType) {
         };
     }
 
-    private void addURB(LinuxTransfer transfer) {
+    /**
+     * Links the specified transfer instance to a URB.
+     * <p>
+     * The transfer is assigned an URB instance, and a list
+     * of associations from URB to transfer is maintained.
+     * </p>
+     * @param transfer the transfer to assign a URB.
+     */
+    private void linkToUrb(LinuxTransfer transfer) {
         MemorySegment urb;
         var size = availableURBs.size();
         if (size > 0) {
@@ -201,6 +201,15 @@ private void addURB(LinuxTransfer transfer) {
         transfersByURB.put(urb, transfer);
     }
 
+    /**
+     * Gets the transfer associated with the specified URB.
+     * <p>
+     * The URB is returned into the list of URBs available for further transfers.
+     * </p>
+     *
+     * @param urb URB instance
+     * @return transfer associated with the URB
+     */
     @SuppressWarnings("java:S2259")
     private synchronized LinuxTransfer getTransferResult(MemorySegment urb) {
         var transfer = transfersByURB.remove(urb);

java-does-usb/src/main/java/net/codecrete/usb/linux/UsbDevFS.java

@@ -19,6 +19,7 @@ class UsbDevFS {
     private UsbDevFS() {
     }
 
+    // constants that jextract cannot generate as they are built from function-like macros
     static final long CLAIMINTERFACE = 0x8004550FL;
     static final long RELEASEINTERFACE = 0x80045510L;
     static final long SETINTERFACE = 0x80085504L;