usb,rp2: Fix "TinyUSB callback can't recurse" error when using threads.

projectgus · projectgus · commit c90205107e57 · 2024-07-11T14:41:50.000+10:00
Looks like there was a long standing underlying bug here when using rp2 threads, where either CPU may poll CDC input and trigger the TinyUSB task. TinyUSB could run on both CPUs concurrently, which may have lead to some incorrect behaviour. The race started triggering an exception when runtime USB support was added, and a check was added for the USB task recursing on itself from a Python handler function. The race is most commonly triggered when working from the interactive REPL, even a minimal running thread can trigger it. This commit adds a test case that triggers it in a different way (polling stdin from a thread). Fix is to add a port-level macro that indicates whether the TinyUSB task can run. Closes #15390. This work was funded through GitHub Sponsors. Signed-off-by: Angus Gratton <angus@redyak.com.au>
diff --git a/ports/rp2/mphalport.h b/ports/rp2/mphalport.h
@@ -68,6 +68,11 @@
 extern int mp_interrupt_char;
 extern ringbuf_t stdin_ringbuf;
 
+#if MICROPY_PY_THREAD
+// Only run the TinyUSB task on CPU 0 to avoid data races
+#define MICROPY_HW_USBD_TASK_CAN_RUN() (get_core_num() == 0)
+#endif
+
 // Port-specific function to create a wakeup interrupt after timeout_ms and enter WFE
 void mp_wfe_or_timeout(uint32_t timeout_ms);
 
diff --git a/shared/tinyusb/mp_usbd.c b/shared/tinyusb/mp_usbd.c
@@ -24,20 +24,20 @@
  * THE SOFTWARE.
  */
 
-#include "py/mpconfig.h"
+#include "mp_usbd.h"
 
 #if MICROPY_HW_ENABLE_USBDEV
 
-#include "mp_usbd.h"
-
 #ifndef NO_QSTR
 #include "device/dcd.h"
 #endif
 
 #if !MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE
 
 void mp_usbd_task(void) {
-    tud_task_ext(0, false);
+    if (MICROPY_HW_USBD_TASK_CAN_RUN()) {
+        tud_task_ext(0, false);
+    }
 }
 
 void mp_usbd_task_callback(mp_sched_node_t *node) {
diff --git a/shared/tinyusb/mp_usbd.h b/shared/tinyusb/mp_usbd.h
@@ -27,7 +27,7 @@
 #ifndef MICROPY_INCLUDED_SHARED_TINYUSB_MP_USBD_H
 #define MICROPY_INCLUDED_SHARED_TINYUSB_MP_USBD_H
 
-#include "py/mpconfig.h"
+#include "py/mphal.h"
 
 #if MICROPY_HW_ENABLE_USBDEV
 
@@ -67,6 +67,11 @@ extern const uint8_t mp_usbd_builtin_desc_cfg[MP_USBD_BUILTIN_DESC_CFG_LEN];
 
 void mp_usbd_task_callback(mp_sched_node_t *node);
 
+#ifndef MICROPY_HW_USBD_TASK_CAN_RUN
+// Redefine this macro on ports where the TinyUSB task can't always execute
+#define MICROPY_HW_USBD_TASK_CAN_RUN() (1)
+#endif
+
 #if MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE
 void mp_usbd_deinit(void);
 void mp_usbd_init(void);
diff --git a/shared/tinyusb/mp_usbd_runtime.c b/shared/tinyusb/mp_usbd_runtime.c
@@ -488,7 +488,7 @@ static void mp_usbd_disconnect(mp_obj_usb_device_t *usbd) {
 
 // Thjs callback is queued by mp_usbd_schedule_task() to process USB later.
 void mp_usbd_task_callback(mp_sched_node_t *node) {
-    if (tud_inited() && !in_usbd_task) {
+    if (tud_inited() && !in_usbd_task && MICROPY_HW_USBD_TASK_CAN_RUN()) {
         mp_usbd_task_inner();
     }
     // If in_usbd_task is set, it means something else has already manually called
@@ -501,6 +501,9 @@ 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_HW_USBD_TASK_CAN_RUN()) {
+        return; // The port can't run the USB task from here (i.e. wrong CPU)
+    }
     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,42 @@
+# 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 select
+import sys
+import time
+import _thread
+
+
+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)
+
+# add a short delay to account for inconsistency waking the two threads (on
+# CPython CI runners there seems to be some intermittent difference in thread
+# wakeup delays.) On Linux we expect both threads should resume more or less
+# concurrently - aka the "thundering herd" effect"
+try:
+    time.sleep_ms(100)
+except AttributeError:
+    time.sleep(0.1)
+
+# the background thread should have completed its wait by now
+print(thread_waiter.is_done())
