micropython · dpgeorge · Sep 19, 2024 · Sep 4, 2024 · Sep 4, 2024
diff --git a/docs/library/micropython.rst b/docs/library/micropython.rst
@@ -136,6 +136,14 @@ Functions
    the heap may be locked) and scheduling a function to call later will lift
    those restrictions.
 
+   On multi-threaded ports, the scheduled function's behaviour depends on
+   whether the Global Interpreter Lock (GIL) is enabled for the specific port:
+
+   - If GIL is enabled, the function can preempt any thread and run in its
+     context.
+   - If GIL is disabled, the function will only preempt the main thread and run
+     in its context.
+
    Note: If `schedule()` is called from a preempting IRQ, when memory
    allocation is not allowed and the callback to be passed to `schedule()` is
    a bound method, passing this directly will fail. This is because creating a

diff --git a/py/scheduler.c b/py/scheduler.c
@@ -236,7 +236,13 @@ void mp_handle_pending(bool raise_exc) {
 
     // Handle any pending callbacks.
     #if MICROPY_ENABLE_SCHEDULER
-    if (MP_STATE_VM(sched_state) == MP_SCHED_PENDING) {
+    bool run_scheduler = (MP_STATE_VM(sched_state) == MP_SCHED_PENDING);
+    #if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
+    // Avoid races by running the scheduler on the main thread, only.
+    // (Not needed if GIL enabled, as GIL ensures thread safety here.)
+    run_scheduler = run_scheduler && mp_thread_is_main_thread();
+    #endif
+    if (run_scheduler) {
         mp_sched_run_pending();
     }
     #endif

diff --git a/shared/tinyusb/mp_usbd_runtime.c b/shared/tinyusb/mp_usbd_runtime.c
@@ -501,6 +501,15 @@ void mp_usbd_task_callback(mp_sched_node_t *node) {
 // Task function can be called manually to force processing of USB events
 // (mostly from USB-CDC serial port when blocking.)
 void mp_usbd_task(void) {
+    #if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
+    if (!mp_thread_is_main_thread()) {
+        // Avoid race with the scheduler callback by scheduling TinyUSB to run
+        // on the main thread.
+        mp_usbd_schedule_task();
+        return;
+    }
+    #endif
+
     if (in_usbd_task) {
         // If this exception triggers, it means a USB callback tried to do
         // something that itself became blocked on TinyUSB (most likely: read or

diff --git a/tests/thread/thread_stdin.py b/tests/thread/thread_stdin.py
@@ -0,0 +1,44 @@
+# Test that having multiple threads block on stdin doesn't cause any issues.
+#
+# The test doesn't expect any input on stdin.
+#
+# This is a regression test for https://github.com/micropython/micropython/issues/15230
+# on rp2, but doubles as a general property to test across all ports.
+import sys
+import _thread
+
+try:
+    import select
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+
+class StdinWaiter:
+    def __init__(self):
+        self._done = False
+
+    def wait_stdin(self, timeout_ms):
+        poller = select.poll()
+        poller.register(sys.stdin, select.POLLIN)
+        poller.poll(timeout_ms)
+        # Ignoring the poll result as we don't expect any input
+        self._done = True
+
+    def is_done(self):
+        return self._done
+
+
+thread_waiter = StdinWaiter()
+_thread.start_new_thread(thread_waiter.wait_stdin, (1000,))
+StdinWaiter().wait_stdin(1000)
+
+# Spinning here is mostly not necessary but there is some inconsistency waking
+# the two threads, especially on CPython CI runners where the thread may not
+# have run yet. The actual delay is <20ms but spinning here instead of
+# sleep(0.1) means the test can run on MP builds without float support.
+while not thread_waiter.is_done():
+    pass
+
+# The background thread should have completed its wait by now.
+print(thread_waiter.is_done())