A few more fixes.

Author: christianhaeubl

substratevm/CHANGELOG.md

@@ -25,7 +25,7 @@ This changelog summarizes major changes to GraalVM Native Image.
 * (GR-38414) BellSoft implemented the `MemoryPoolMXBean` for the serial and epsilon GCs.
 * (GR-40641) Dynamic linking of AWT libraries on Linux.
 * (GR-40463) Red Hat added experimental support for JMX, which can be enabled with the `--enable-monitoring` option (e.g. `--enable-monitoring=jmxclient,jmxserver`).
-* (GR-42740) Red Hat added experimental support for JFR event streaming.
+* (GR-42740) Together with Red Hat, we added experimental support for JFR event streaming.
 * (GR-44110) Native Image now targets `x86-64-v3` by default on AMD64 and supports a new `-march` option. Use `-march=compatibility` for best compatibility (previous default) or `-march=native` for best performance if the native executable is deployed on the same machine or on a machine with the same CPU features. To list all available machine types, use `-march=list`.
 * (GR-43971) Add native-image option `-E<env-var-key>[=<env-var-value>]` and support environment variable capturing in bundles. Previously almost all environment variables were available in the builder. To temporarily revert back to the old behaviour, env setting `NATIVE_IMAGE_SLOPPY_BUILDER_SANITATION=true` can be used. The old behaviour will be removed in a future release.
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/JDKContainerSubstitutions.java

@@ -36,6 +36,7 @@
 import com.oracle.svm.core.annotate.RecomputeFieldValue;
 import com.oracle.svm.core.annotate.RecomputeFieldValue.Kind;
 import com.oracle.svm.core.annotate.TargetClass;
+import com.oracle.svm.core.annotate.TargetElement;
 
 @TargetClass(className = "jdk.internal.platform.cgroupv1.CgroupV1Subsystem", onlyWith = JDK17OrLater.class)
 @Platforms(LINUX.class)
@@ -69,6 +70,7 @@ final class Target_jdk_jfr_internal_instrument_JDKEvents {
 @Platforms(LINUX.class)
 final class Target_jdk_jfr_internal_RequestEngine {
     @Alias //
+    @TargetElement(onlyWith = JDK20OrLater.class) //
     @RecomputeFieldValue(kind = Kind.NewInstance, declClass = ReentrantLock.class) //
     private static ReentrantLock lock;
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/UninterruptibleUtils.java

@@ -611,6 +611,7 @@ public static Pointer toModifiedUTF8(java.lang.String string, Pointer buffer, Po
 
     @FunctionalInterface
     public interface CharReplacer {
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
         char replace(char val);
     }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrBufferNodeAccess.java

@@ -42,6 +42,7 @@
  * Used to access the raw memory of a {@link JfrBufferNode}.
  */
 public final class JfrBufferNodeAccess {
+    private static final byte NONE = 0b00;
     private static final byte RETIRED = 0b01;
 
     private JfrBufferNodeAccess() {
@@ -54,6 +55,7 @@ public static JfrBufferNode allocate(JfrBuffer buffer) {
             node.setBuffer(buffer);
             node.setNext(WordFactory.nullPointer());
             node.setLockOwner(WordFactory.nullPointer());
+            node.setFlags(NONE);
             NativeSpinLockUtils.initialize(ptrToLock(node));
         }
         return node;
@@ -113,6 +115,13 @@ private static CIntPointer ptrToLock(JfrBufferNode node) {
         return (CIntPointer) ((Pointer) node).add(JfrBufferNode.offsetOfLock());
     }
 
+    /**
+     * The thread-local {@link JfrBuffer}s that are used for Java-level JFR events can't be freed
+     * when JFR recording is stopped because the JDK class {@code EventWriter} is not
+     * uninterruptible (i.e., threads could continue using such {@link JfrBuffer}s even after the
+     * 'StopRecording' safepoint ends). Therefore, we mark those buffers as retired and either free
+     * or reinstantiate them at a later point in time.
+     */
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static void setRetired(JfrBufferNode node) {
         assert isLockedByCurrentThread(node);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrBufferType.java

@@ -24,6 +24,8 @@
  */
 package com.oracle.svm.core.jfr;
 
+import com.oracle.svm.core.Uninterruptible;
+
 /**
  * List of all possible {@link JfrBuffer} types.
  */
@@ -53,6 +55,7 @@ public enum JfrBufferType {
         this.threadLocal = threadLocal;
     }
 
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public boolean isThreadLocal() {
         return threadLocal;
     }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrChunkWriter.java

@@ -34,7 +34,6 @@
 import org.graalvm.nativeimage.IsolateThread;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
-import org.graalvm.word.SignedWord;
 import org.graalvm.word.UnsignedWord;
 import org.graalvm.word.WordFactory;
 
@@ -45,6 +44,8 @@
 import com.oracle.svm.core.jfr.traceid.JfrTraceIdEpoch;
 import com.oracle.svm.core.locks.VMMutex;
 import com.oracle.svm.core.os.RawFileOperationSupport;
+import com.oracle.svm.core.os.RawFileOperationSupport.FileAccessMode;
+import com.oracle.svm.core.os.RawFileOperationSupport.FileCreationMode;
 import com.oracle.svm.core.os.RawFileOperationSupport.RawFileDescriptor;
 import com.oracle.svm.core.sampler.SamplerBuffersAccess;
 import com.oracle.svm.core.thread.JavaVMOperation;
@@ -89,8 +90,8 @@ public final class JfrChunkWriter implements JfrUnlockedChunkWriter {
     private boolean newChunk;
     private boolean isFinal;
     private long lastMetadataId;
-    private SignedWord metadataPosition;
-    private SignedWord lastCheckpointOffset;
+    private long metadataPosition;
+    private long lastCheckpointOffset;
 
     @Platforms(Platform.HOSTED_ONLY.class)
     public JfrChunkWriter(JfrGlobalMemory globalMemory, JfrStackTraceRepository stackTraceRepo, JfrMethodRepository methodRepo, JfrTypeRepository typeRepo, JfrSymbolRepository symbolRepo,
@@ -158,8 +159,8 @@ public void openFile(String outputFile) {
         newChunk = true;
         isFinal = false;
         lastMetadataId = -1;
-        metadataPosition = WordFactory.signed(-1);
-        lastCheckpointOffset = WordFactory.signed(-1);
+        metadataPosition = -1;
+        lastCheckpointOffset = -1;
 
         writeFileHeader();
     }
@@ -169,7 +170,7 @@ public void write(JfrBuffer buffer) {
         assert lock.isOwner();
         assert buffer.isNonNull();
         assert buffer.getBufferType() == JfrBufferType.C_HEAP || VMOperation.isInProgressAtSafepoint() || JfrBufferNodeAccess.isLockedByCurrentThread(buffer.getNode());
-        assert buffer.getNode() == null || !JfrBufferNodeAccess.isRetired(buffer.getNode());
+        assert buffer.getNode().isNull() || !JfrBufferNodeAccess.isRetired(buffer.getNode());
 
         UnsignedWord unflushedSize = JfrBufferAccess.getUnflushedSize(buffer);
         if (unflushedSize.equal(0)) {
@@ -233,38 +234,37 @@ private void writeFileHeader() {
         getFileSupport().write(fd, FILE_MAGIC);
         getFileSupport().writeShort(fd, JFR_VERSION_MAJOR);
         getFileSupport().writeShort(fd, JFR_VERSION_MINOR);
-        assert getFileSupport().position(fd).equal(CHUNK_SIZE_OFFSET);
+        assert getFileSupport().position(fd) == CHUNK_SIZE_OFFSET;
         getFileSupport().writeLong(fd, 0L); // chunk size
         getFileSupport().writeLong(fd, 0L); // last checkpoint offset
         getFileSupport().writeLong(fd, 0L); // metadata position
         getFileSupport().writeLong(fd, chunkStartNanos);
         getFileSupport().writeLong(fd, 0L); // durationNanos
         getFileSupport().writeLong(fd, chunkStartTicks);
         getFileSupport().writeLong(fd, JfrTicks.getTicksFrequency());
-        assert getFileSupport().position(fd).equal(FILE_STATE_OFFSET);
+        assert getFileSupport().position(fd) == FILE_STATE_OFFSET;
         getFileSupport().writeByte(fd, getAndIncrementGeneration());
         getFileSupport().writeByte(fd, (byte) 0); // padding
         getFileSupport().writeShort(fd, computeHeaderFlags());
     }
 
     private void patchFileHeader(boolean flushpoint) {
         assert lock.isOwner();
-        assert metadataPosition.greaterThan(0);
-        assert lastCheckpointOffset.greaterThan(0);
+        assert metadataPosition > 0;
+        assert lastCheckpointOffset > 0;
 
         byte generation = flushpoint ? getAndIncrementGeneration() : COMPLETE;
-        SignedWord currentPos = getFileSupport().position(fd);
-        long chunkSize = currentPos.rawValue();
+        long currentPos = getFileSupport().position(fd);
         long durationNanos = JfrTicks.currentTimeNanos() - chunkStartNanos;
 
-        getFileSupport().seek(fd, WordFactory.signed(CHUNK_SIZE_OFFSET));
-        getFileSupport().writeLong(fd, chunkSize);
-        getFileSupport().writeLong(fd, lastCheckpointOffset.rawValue());
-        getFileSupport().writeLong(fd, metadataPosition.rawValue());
+        getFileSupport().seek(fd, CHUNK_SIZE_OFFSET);
+        getFileSupport().writeLong(fd, currentPos);
+        getFileSupport().writeLong(fd, lastCheckpointOffset);
+        getFileSupport().writeLong(fd, metadataPosition);
         getFileSupport().writeLong(fd, chunkStartNanos);
         getFileSupport().writeLong(fd, durationNanos);
 
-        getFileSupport().seek(fd, WordFactory.signed(FILE_STATE_OFFSET));
+        getFileSupport().seek(fd, FILE_STATE_OFFSET);
         getFileSupport().writeByte(fd, generation);
         getFileSupport().writeByte(fd, (byte) 0);
         getFileSupport().writeShort(fd, computeHeaderFlags());
@@ -308,20 +308,20 @@ private void writeThreadCheckpoint(boolean flushpoint) {
     private void writeCheckpointEvent(JfrCheckpointType type, JfrRepository[] repositories, boolean writeSerializers, boolean flushpoint) {
         assert lock.isOwner();
 
-        SignedWord start = beginEvent();
+        long start = beginEvent();
         writeCompressedLong(JfrReservedEvent.CHECKPOINT.getId());
         writeCompressedLong(JfrTicks.elapsedTicks());
         writeCompressedLong(0); // duration
         writeCompressedLong(getDeltaToLastCheckpoint(start));
         writeByte(type.getId());
 
-        SignedWord poolCountPos = getFileSupport().position(fd);
+        long poolCountPos = getFileSupport().position(fd);
         getFileSupport().writeInt(fd, 0); // pool count (patched below)
 
         int poolCount = writeSerializers ? writeSerializers() : 0;
         poolCount += writeConstantPools(repositories, flushpoint);
 
-        SignedWord currentPos = getFileSupport().position(fd);
+        long currentPos = getFileSupport().position(fd);
         getFileSupport().seek(fd, poolCountPos);
         writePaddedInt(poolCount);
 
@@ -331,11 +331,11 @@ private void writeCheckpointEvent(JfrCheckpointType type, JfrRepository[] reposi
         lastCheckpointOffset = start;
     }
 
-    private long getDeltaToLastCheckpoint(SignedWord startOfNewCheckpoint) {
-        if (lastCheckpointOffset.lessThan(0)) {
+    private long getDeltaToLastCheckpoint(long startOfNewCheckpoint) {
+        if (lastCheckpointOffset < 0) {
             return 0L;
         }
-        return lastCheckpointOffset.subtract(startOfNewCheckpoint).rawValue();
+        return lastCheckpointOffset - startOfNewCheckpoint;
     }
 
     private int writeSerializers() {
@@ -367,7 +367,7 @@ private void writeMetadataEvent() {
             return;
         }
 
-        SignedWord start = beginEvent();
+        long start = beginEvent();
         writeCompressedLong(JfrReservedEvent.METADATA.getId());
         writeCompressedLong(JfrTicks.elapsedTicks());
         writeCompressedLong(0); // duration
@@ -381,25 +381,25 @@ private void writeMetadataEvent() {
 
     public boolean shouldRotateDisk() {
         assert lock.isOwner();
-        return getFileSupport().isValid(fd) && getFileSupport().size(fd).greaterThan(WordFactory.signed(notificationThreshold));
+        return getFileSupport().isValid(fd) && getFileSupport().size(fd) > notificationThreshold;
     }
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
-    public SignedWord beginEvent() {
-        SignedWord start = getFileSupport().position(fd);
+    public long beginEvent() {
+        long start = getFileSupport().position(fd);
         // Write a placeholder for the size. Will be patched by endEvent,
         getFileSupport().writeInt(fd, 0);
         return start;
     }
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
-    public void endEvent(SignedWord start) {
-        SignedWord end = getFileSupport().position(fd);
-        SignedWord writtenBytes = end.subtract(start);
-        assert (int) writtenBytes.rawValue() == writtenBytes.rawValue();
+    public void endEvent(long start) {
+        long end = getFileSupport().position(fd);
+        long writtenBytes = end - start;
+        assert (int) writtenBytes == writtenBytes;
 
         getFileSupport().seek(fd, start);
-        writePaddedInt(writtenBytes.rawValue());
+        writePaddedInt(writtenBytes);
         getFileSupport().seek(fd, end);
     }
 
@@ -520,8 +520,8 @@ private void traverseThreadLocalBuffers(JfrBufferList list, boolean flushpoint)
 
         while (node.isNonNull()) {
             JfrBufferNode next = node.getNext();
-            boolean success = JfrBufferNodeAccess.tryLock(node);
-            if (success) {
+            boolean lockAcquired = JfrBufferNodeAccess.tryLock(node);
+            if (lockAcquired) {
                 JfrBuffer buffer = JfrBufferNodeAccess.getBuffer(node);
                 if (buffer.isNull()) {
                     list.removeNode(node, prev);
@@ -530,9 +530,9 @@ private void traverseThreadLocalBuffers(JfrBufferList list, boolean flushpoint)
                     continue;
                 }
 
-                /* Skip retired nodes as they may contain invalid data. */
-                if (!JfrBufferNodeAccess.isRetired(node)) {
-                    try {
+                try {
+                    /* Skip retired nodes as they may contain invalid data. */
+                    if (!JfrBufferNodeAccess.isRetired(node)) {
                         if (flushpoint) {
                             /*
                              * I/O operations may be slow, so this flushes to the global buffers
@@ -548,13 +548,13 @@ private void traverseThreadLocalBuffers(JfrBufferList list, boolean flushpoint)
                          * reinitialize the thread-local buffers as the individual threads will
                          * handle space reclamation on their own time.
                          */
-                    } finally {
-                        JfrBufferNodeAccess.unlock(node);
                     }
+                } finally {
+                    JfrBufferNodeAccess.unlock(node);
                 }
             }
 
-            assert success || flushpoint;
+            assert lockAcquired || flushpoint;
             prev = node;
             node = next;
         }
@@ -565,8 +565,8 @@ private void flushGlobalMemory(boolean flushpoint) {
         JfrBufferList buffers = globalMemory.getBuffers();
         JfrBufferNode node = buffers.getHead();
         while (node.isNonNull()) {
-            boolean success = JfrBufferNodeAccess.tryLock(node);
-            if (success) {
+            boolean lockAcquired = JfrBufferNodeAccess.tryLock(node);
+            if (lockAcquired) {
                 try {
                     JfrBuffer buffer = JfrBufferNodeAccess.getBuffer(node);
                     write(buffer);
@@ -575,7 +575,7 @@ private void flushGlobalMemory(boolean flushpoint) {
                     JfrBufferNodeAccess.unlock(node);
                 }
             }
-            assert success || flushpoint;
+            assert lockAcquired || flushpoint;
             node = node.getNext();
         }
     }
@@ -647,7 +647,7 @@ private void changeEpoch() {
          * accessing the currently active buffers of other threads.
          */
         @Uninterruptible(reason = "Prevent JFR recording.")
-        private void processSamplerBuffers() {
+        private static void processSamplerBuffers() {
             assert VMOperation.isInProgressAtSafepoint();
             assert ThreadingSupportImpl.isRecurringCallbackPaused();
 
@@ -660,7 +660,7 @@ private void processSamplerBuffers() {
         }
 
         @Uninterruptible(reason = "Prevent JFR recording.")
-        private void processSamplerBuffers0() {
+        private static void processSamplerBuffers0() {
             SamplerBuffersAccess.processActiveBuffers();
             SamplerBuffersAccess.processFullBuffers(false);
         }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrEventWriterAccess.java

@@ -24,6 +24,8 @@
  */
 package com.oracle.svm.core.jfr;
 
+import java.lang.reflect.Field;
+
 import org.graalvm.compiler.serviceprovider.JavaVersionUtil;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
@@ -43,11 +45,11 @@ public final class JfrEventWriterAccess {
      * The fields "startPosition" and "startPositionAddress" in the JDK class EventWriter refer to
      * the committed position and not to the start of the buffer.
      */
-    private static final long COMMITTED_POSITION_OFFSET = U.objectFieldOffset(getEventWriterClass(), "startPosition");
-    private static final long COMMITTED_POSITION_ADDRESS_OFFSET = U.objectFieldOffset(getEventWriterClass(), "startPositionAddress");
-    private static final long CURRENT_POSITION_OFFSET = U.objectFieldOffset(getEventWriterClass(), "currentPosition");
-    private static final long MAX_POSITION_OFFSET = U.objectFieldOffset(getEventWriterClass(), "maxPosition");
-    private static final long VALID_OFFSET = U.objectFieldOffset(getEventWriterClass(), "valid");
+    private static final Field COMMITTED_POSITION_FIELD = ReflectionUtil.lookupField(getEventWriterClass(), "startPosition");
+    private static final Field COMMITTED_POSITION_ADDRESS_FIELD = ReflectionUtil.lookupField(getEventWriterClass(), "startPositionAddress");
+    private static final Field CURRENT_POSITION_FIELD = ReflectionUtil.lookupField(getEventWriterClass(), "currentPosition");
+    private static final Field MAX_POSITION_FIELD = ReflectionUtil.lookupField(getEventWriterClass(), "maxPosition");
+    private static final Field VALID_FIELD = ReflectionUtil.lookupField(getEventWriterClass(), "valid");
 
     @Platforms(Platform.HOSTED_ONLY.class)
     private JfrEventWriterAccess() {
@@ -89,10 +91,10 @@ public static void update(Target_jdk_jfr_internal_EventWriter writer, JfrBuffer
         Pointer currentPos = committedPos.add(uncommittedSize);
         Pointer maxPos = JfrBufferAccess.getDataEnd(buffer);
 
-        U.putLong(writer, COMMITTED_POSITION_OFFSET, committedPos.rawValue());
-        U.putLong(writer, COMMITTED_POSITION_ADDRESS_OFFSET, addressOfCommittedPos.rawValue());
-        U.putLong(writer, CURRENT_POSITION_OFFSET, currentPos.rawValue());
-        U.putLong(writer, MAX_POSITION_OFFSET, maxPos.rawValue());
+        U.putLong(writer, U.objectFieldOffset(COMMITTED_POSITION_FIELD), committedPos.rawValue());
+        U.putLong(writer, U.objectFieldOffset(COMMITTED_POSITION_ADDRESS_FIELD), addressOfCommittedPos.rawValue());
+        U.putLong(writer, U.objectFieldOffset(CURRENT_POSITION_FIELD), currentPos.rawValue());
+        U.putLong(writer, U.objectFieldOffset(MAX_POSITION_FIELD), maxPos.rawValue());
         if (!valid) {
             markAsInvalid(writer);
         }
@@ -101,6 +103,6 @@ public static void update(Target_jdk_jfr_internal_EventWriter writer, JfrBuffer
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static void markAsInvalid(Target_jdk_jfr_internal_EventWriter writer) {
         /* The VM should never write true (only the JDK code may do that). */
-        U.putBooleanVolatile(writer, VALID_OFFSET, false);
+        U.putBooleanVolatile(writer, U.objectFieldOffset(VALID_FIELD), false);
     }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrRepository.java

@@ -33,7 +33,7 @@
  * added data when it tries to iterate the data at a safepoint.
  *
  * Some repositories (e.g., {@link JfrTypeRepository}) return stable JFR trace IDs (i.e., the trace
- * id does not change if the epoch changes). However, the corresponding data (e.g., the type) is
+ * ID does not change if the epoch changes). However, the corresponding data (e.g., the type) is
  * only marked as used in a certain epoch, so callers must always be aware that the returned trace
  * ID is only valid for a specific epoch, no matter if the trace ID is stable or not.
  */