py: Fix Zephyr threading double initialization bugs.

Threads were hanging when executing Python functions due to two critical bugs
in the thread initialization path when MICROPY_ZEPHYR_THREADING is enabled:

Bug #1 - C Stack Initialization Corruption (runtime.h):
zephyr_entry() correctly sets C stack bounds using actual Zephyr thread
stack info, but mp_thread_init_state() was then overwriting those bounds
by calling mp_cstack_init_with_top(ts + 1, stack_size). The ts + 1 address
points to memory after a local variable, causing mp_cstack_check() to
calculate garbage values and potentially raise recursion depth errors.

Bug #2 - Thread State Pointer Corruption (modthread.c):
zephyr_entry() correctly sets TLS to heap-allocated self->thread_state,
but thread_entry() creates a local variable mp_state_thread_t ts and calls
mp_thread_init_state(&ts, ...) which overwrites the TLS pointer to point
to this local stack variable. When the stack frame changes, all
MP_STATE_THREAD() accesses point to invalid memory.

Root cause: For Zephyr threading there are two entry points:
1. zephyr_entry() - Zephyr thread entry that initializes MicroPython
2. thread_entry() - Generic MicroPython thread entry

The bugs occurred because thread_entry() was reinitializing everything
that zephyr_entry() had already correctly initialized, causing double
initialization and memory corruption.

Solution: Modified thread_entry() to skip thread state allocation,
C stack initialization, and mp_thread_start() call when Zephyr threading
is enabled, as these are already handled by zephyr_entry(). Thread_entry()
now only handles GIL, NLR, and function execution for Zephyr threading.

Changes:
- py/runtime.h: Skip mp_cstack_init_with_top() for Zephyr threading
- py/modthread.c: Skip thread state init and mp_thread_start() for Zephyr

Tested on STM32 NUCLEO_F429ZI (STM32F429ZITx).
Threads now successfully execute Python functions.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

py/modthread.c

@@ -158,42 +158,38 @@ static void *thread_entry(void *args_in) {
 
     thread_entry_args_t *args = (thread_entry_args_t *)args_in;
 
-    fprintf(stderr, "[thread_entry] Starting new thread\n");
+    #if !MICROPY_ZEPHYR_THREADING
+    // For Zephyr threading, thread state is already initialized by zephyr_entry()
+    // using heap-allocated state. Do NOT reinitialize here with local variable.
     mp_state_thread_t ts;
-    fprintf(stderr, "[thread_entry] About to init thread state, ts=%p, stack_size=%zu\n", &ts, args->stack_size);
     mp_thread_init_state(&ts, args->stack_size, args->dict_locals, args->dict_globals);
-    fprintf(stderr, "[thread_entry] Thread state initialized\n");
-    mp_state_thread_t *tls_check = mp_thread_get_state();
-    fprintf(stderr, "[thread_entry] TLS check: %p (should match ts=%p)\n", (void *)tls_check, (void *)&ts);
 
     #if MICROPY_ENABLE_PYSTACK
     // TODO threading and pystack is not fully supported, for now just make a small stack
     mp_obj_t mini_pystack[128];
     mp_pystack_init(mini_pystack, &mini_pystack[128]);
     #endif
+    #endif
 
-    fprintf(stderr, "[thread_entry] About to acquire GIL\n");
     MP_THREAD_GIL_ENTER();
-    fprintf(stderr, "[thread_entry] GIL acquired\n");
 
-    // signal that we are set up and running
-    fprintf(stderr, "[thread_entry] Calling mp_thread_start()\n");
+    #if !MICROPY_ZEPHYR_THREADING
+    // For Zephyr threading, mp_thread_start() is already called by zephyr_entry()
     mp_thread_start();
-    fprintf(stderr, "[thread_entry] mp_thread_start() returned\n");
+    #endif
 
     // TODO set more thread-specific state here:
     //  cur_exception (root pointer)
 
+    #if !MICROPY_ZEPHYR_THREADING
     DEBUG_printf("[thread] start ts=%p args=%p stack=%p\n", &ts, &args, MP_STATE_THREAD(stack_top));
+    #else
+    DEBUG_printf("[thread] start args=%p stack=%p\n", &args, MP_STATE_THREAD(stack_top));
+    #endif
 
     nlr_buf_t nlr;
-    fprintf(stderr, "[thread_entry] About to push NLR handler\n");
-    fprintf(stderr, "[thread_entry] Before nlr_push: nlr_top=%p\n", (void *)MP_STATE_THREAD(nlr_top));
     if (nlr_push(&nlr) == 0) {
-        fprintf(stderr, "[thread_entry] After nlr_push: nlr_top=%p, nlr=%p\n", (void *)MP_STATE_THREAD(nlr_top), (void *)&nlr);
-        fprintf(stderr, "[thread_entry] Calling Python function\n");
         mp_call_function_n_kw(args->fun, args->n_args, args->n_kw, args->args);
-        fprintf(stderr, "[thread_entry] Python function returned normally\n");
         nlr_pop();
     } else {
         // uncaught exception
@@ -210,7 +206,11 @@ static void *thread_entry(void *args_in) {
         }
     }
 
+    #if !MICROPY_ZEPHYR_THREADING
     DEBUG_printf("[thread] finish ts=%p\n", &ts);
+    #else
+    DEBUG_printf("[thread] finish\n");
+    #endif
 
     // signal that we are finished
     mp_thread_finish();

py/runtime.h

@@ -159,7 +159,14 @@ void mp_call_function_1_from_nlr_jump_callback(void *ctx_in);
 static inline void mp_thread_init_state(mp_state_thread_t *ts, size_t stack_size, mp_obj_dict_t *locals, mp_obj_dict_t *globals) {
     mp_thread_set_state(ts);
 
+    #if !MICROPY_ZEPHYR_THREADING
+    // For Zephyr threading, C stack is already initialized by zephyr_entry()
+    // using actual Zephyr thread stack info. Do NOT reinitialize here.
     mp_cstack_init_with_top(ts + 1, stack_size); // need to include ts in root-pointer scan
+    #else
+    // Zephyr threading: stack_top/stack_limit already set correctly by zephyr_entry()
+    (void)stack_size;  // Suppress unused parameter warning
+    #endif
 
     // GC starts off unlocked
     ts->gc_lock_depth = 0;