loom locking stuff

Signed-off-by: Tobi Ajila <atobia@ca.ibm.com>

make/data/hotspot-symbols/symbols-unix

@@ -224,6 +224,7 @@ JVM_VirtualThreadMount
 JVM_VirtualThreadUnmount
 JVM_VirtualThreadHideFrames
 JVM_VirtualThreadDisableSuspend
+JVM_VirtualThreadWaitForPendingList
 
 # Scoped values
 JVM_EnsureMaterializedForStackWalk_func

src/hotspot/share/include/jvm.h

@@ -1157,6 +1157,9 @@ JVM_VirtualThreadHideFrames(JNIEnv* env, jobject vthread, jboolean hide);
 JNIEXPORT void JNICALL
 JVM_VirtualThreadDisableSuspend(JNIEnv* env, jobject vthread, jboolean enter);
 
+JNIEXPORT jobject JNICALL
+JVM_VirtualThreadWaitForPendingList(JNIEnv* env);
+
 /*
  * Core reflection support.
  */

src/java.base/share/classes/java/lang/VirtualThread.java

@@ -81,6 +81,7 @@ final class VirtualThread extends BaseVirtualThread {
     private static final long PARK_PERMIT = U.objectFieldOffset(VirtualThread.class, "parkPermit");
     private static final long CARRIER_THREAD = U.objectFieldOffset(VirtualThread.class, "carrierThread");
     private static final long TERMINATION = U.objectFieldOffset(VirtualThread.class, "termination");
+    private static final long ON_WAITING_LIST = U.objectFieldOffset(VirtualThread.class, "onWaitingList");
 
     // scheduler and continuation
     private final Executor scheduler;
@@ -132,6 +133,9 @@ final class VirtualThread extends BaseVirtualThread {
     // Thread.yield
     private static final int YIELDING = 10;
     private static final int YIELDED  = 11;         // unmounted but runnable
+    // monitor enter
+    private static final int BLOCKING   = 12;
+    private static final int BLOCKED    = 13;
 
     private static final int TERMINATED = 99;  // final state
 
@@ -141,12 +145,20 @@ final class VirtualThread extends BaseVirtualThread {
     // parking permit
     private volatile boolean parkPermit;
 
+
+    // unblocked
+    private volatile boolean unblocked;
+
     // carrier thread when mounted, accessed by VM
     private volatile Thread carrierThread;
 
     // termination object when joining, created lazily if needed
     private volatile CountDownLatch termination;
 
+   // Next waiting vthread to unpark()
+    private VirtualThread next;
+    private byte onWaitingList;
+
     /**
      * Returns the continuation scope used for virtual threads.
      */
@@ -499,6 +511,16 @@ private void afterYield() {
             return;
         }
 
+        // blocking on monitorenter
+        if (s == BLOCKING) {
+            setState(BLOCKED);
+            if (unblocked && compareAndSetState(BLOCKED, UNPARKED)) {
+                unblocked = false;
+                submitRunContinuation();
+            }
+            return;
+        }
+
         assert false;
     }
 
@@ -772,6 +794,19 @@ void unpark() {
         }
     }
 
+    /**
+     * Re-enables this virtual thread for scheduling after blocking on monitor enter.
+     * @throws RejectedExecutionException if the scheduler cannot accept a task
+     */
+    private void unblock() {
+        assert !Thread.currentThread().isVirtual();
+        unblocked = true;
+        if (state() == BLOCKED && compareAndSetState(BLOCKED, UNPARKED)) {
+            unblocked = false;
+            submitRunContinuation();
+        }
+    }
+
     /**
      * Attempts to yield the current virtual thread (Thread.yield).
      */
@@ -924,6 +959,7 @@ Thread.State threadState() {
                 }
             case UNPARKED:
             case YIELDED:
+            case BLOCKING:
                 // runnable, not mounted
                 return Thread.State.RUNNABLE;
             case RUNNING:
@@ -952,6 +988,8 @@ Thread.State threadState() {
             case TIMED_PARKED:
             case TIMED_PINNED:
                 return State.TIMED_WAITING;
+            case BLOCKED:
+                return State.BLOCKED;
             case TERMINATED:
                 return Thread.State.TERMINATED;
             default:
@@ -997,7 +1035,7 @@ private StackTraceElement[] tryGetStackTrace() {
             case RUNNING, PINNED, TIMED_PINNED -> {
                 return null;   // mounted
             }
-            case PARKED, TIMED_PARKED -> {
+            case PARKED, BLOCKED, TIMED_PARKED -> {
                 // unmounted, not runnable
             }
             case UNPARKED, YIELDED -> {
@@ -1028,9 +1066,9 @@ private StackTraceElement[] tryGetStackTrace() {
                 // resubmit as task may have run while suspended
                 yield true;
             }
-            case PARKED, TIMED_PARKED -> {
+            case PARKED, BLOCKED, TIMED_PARKED -> {
                 // resubmit if unparked while suspended
-                yield parkPermit && compareAndSetState(initialState, UNPARKED);
+                yield (parkPermit || unblocked) && compareAndSetState(initialState, UNPARKED);
             }
             default -> throw new InternalError();
         };
@@ -1119,6 +1157,16 @@ private void setState(int newValue) {
         state = newValue;  // volatile write
     }
 
+    private VirtualThread next() {
+        return next;
+    }
+
+    private void removeFromWaitingList() {
+        next = null;
+        boolean res = U.compareAndSetByte(this, ON_WAITING_LIST, (byte)0x01, (byte)0x00);
+        assert res;
+    }
+
     private boolean compareAndSetState(int expectedValue, int newValue) {
         return U.compareAndSetInt(this, STATE, expectedValue, newValue);
     }
@@ -1244,4 +1292,29 @@ private static int tracePinningMode() {
         }
         return 0;
     }
+
+    /**
+     * Unblock virtual threads that are ready to scheduled again.
+     */
+    private static void processPendingList() {
+        while (true) {
+            VirtualThread currentWaitingVThread = waitForPendingList();
+            VirtualThread nextWaitingVThread = null;
+            while (currentWaitingVThread != null) {
+                nextWaitingVThread = currentWaitingVThread.next();
+                currentWaitingVThread.removeFromWaitingList();
+                currentWaitingVThread.unpark();
+                currentWaitingVThread = nextWaitingVThread;
+            }
+        }
+    }
+
+    private static native VirtualThread waitForPendingList();
+
+    static {
+        var unblocker = InnocuousThread.newThread("VirtualThread-unblocker",
+                VirtualThread::processPendingList);
+        unblocker.setDaemon(true);
+        unblocker.start();
+    }
 }

src/java.base/share/native/libjava/VirtualThread.c

@@ -38,6 +38,7 @@ static JNINativeMethod methods[] = {
     { "notifyJvmtiUnmount",        "(Z)V", (void *)&JVM_VirtualThreadUnmount },
     { "notifyJvmtiHideFrames",     "(Z)V", (void *)&JVM_VirtualThreadHideFrames },
     { "notifyJvmtiDisableSuspend", "(Z)V", (void *)&JVM_VirtualThreadDisableSuspend },
+    { "waitForPendingList",      "()" VIRTUAL_THREAD, (void *)&JVM_VirtualThreadWaitForPendingList },
 };
 
 JNIEXPORT void JNICALL