diff options
Diffstat (limited to 'libcr/coroutine.c')
| -rw-r--r-- | libcr/coroutine.c | 520 |
1 files changed, 296 insertions, 224 deletions
diff --git a/libcr/coroutine.c b/libcr/coroutine.c index b3dccff..8bfdb86 100644 --- a/libcr/coroutine.c +++ b/libcr/coroutine.c @@ -18,19 +18,19 @@ #include "config.h" #ifndef CONFIG_COROUTINE_DEFAULT_STACK_SIZE -# error config.h must define CONFIG_COROUTINE_DEFAULT_STACK_SIZE +# error config.h must define CONFIG_COROUTINE_DEFAULT_STACK_SIZE #endif #ifndef CONFIG_COROUTINE_NUM -# error config.h must define CONFIG_COROUTINE_NUM +# error config.h must define CONFIG_COROUTINE_NUM #endif #ifndef CONFIG_COROUTINE_MEASURE_STACK -# error config.h must define CONFIG_COROUTINE_MEASURE_STACK +# error config.h must define CONFIG_COROUTINE_MEASURE_STACK #endif #ifndef CONFIG_COROUTINE_PROTECT_STACK -# error config.h must define CONFIG_COROUTINE_PROTECT_STACK +# error config.h must define CONFIG_COROUTINE_PROTECT_STACK #endif #ifndef CONFIG_COROUTINE_DEBUG -# error config.h must define CONFIG_COROUTINE_DEBUG +# error config.h must define CONFIG_COROUTINE_DEBUG #endif /* Implementation *************************************************************/ @@ -38,17 +38,17 @@ /* * Portability notes: * - * - It uses GCC `__attribute__`s, and the GNUC ({ ... }) statement exprs - etension. + * - It uses GCC `__attribute__`s, and the GNUC ({ ... }) statement + * exprs extension. * - * - It has a small bit of platform-specific code in the "platform support" - * section. Other than this, it should be portable to other platforms CPUs. - * It currently contains implementations for __x86_64__ (assumes POSIX) and - * __arm__ (assumes ARM CMSIS), and should be fairly easy to add - * implementations for other platforms. + * - It has a small bit of platform-specific code in the "platform + * support" section. Other than this, it should be portable to + * other platforms CPUs. It currently contains implementations for + * __x86_64__ (assumes POSIX) and __arm__ (assumes bare-metal), and + * should be fairly easy to add implementations for other platforms. * * - It uses setjmp()/longjmp() in "unsafe" ways. POSIX-2017 - * longjmp(3) says + * longjmp(3p) says * * > If the most recent invocation of setjmp() with the * > corresponding jmp_buf ... or if the function containing the @@ -65,29 +65,29 @@ * choose to do something else, but I'm calling it out here because * you never know. * - * Note that setjmp()/longjmp() are defined in 3 places: in the libc - * (glibc/newlib), as GCC intrinsics, and the lower-level GCC - * __builtin_{setjmp,newlib} which the libc and intrinsic versions - * likely use. Our assumptions seem to be valid for + * Our assumptions seem to be valid for * x86_64-pc-linux-gnu/gcc-14.2.1/glibc-2.40 and * arm-none-eabi/gcc-14.1.0/newlib-4.4.0. * - * Why not use <ucontext.h>, the now-deprecated (was in POSIX.1-2001, - * is gone in POSIX-2008) predecesor to <setjmp.h>? It would let us - * do this without any assembly or unsafe assumptions. Simply: - * because newlib does not provide it. + * Why not use <ucontext.h>, the now-deprecated (was in + * POSIX.1-2001, is gone in POSIX-2008) predecesor to <setjmp.h>? + * It would let us do this without any assembly or unsafe + * assumptions. Simply: because newlib does not provide it. But it + * would let us avoid having an `sp` member in `struct coroutine`... + * Maybe https://github.com/kaniini/libucontext ? Or building a + * ucontext-lib abstraction on top of setjmp/longjmp? */ /* * Design decisions and notes: * - * - Coroutines are launched with a stack stack that is filled with - * known values (zero or a pre-determined pattern, depending on the - * config above). Because all stack variables should be initialized - * before they are read, this "shouldn't" make a difference, but: - * (1) Initializing it to a known value allows us to measure how - * much of the stack was written to, which is helpful to tune stack - * sizes. (2) Leaving it uninitialized just gives me the willies. + * - Coroutines are launched with a stack that is filled with known + * arbitrary values. Because all stack variables should be + * initialized before they are read, this "shouldn't" make a + * difference, but: (1) Initializing it to a known value allows us + * to measure how much of the stack was written to, which is helpful + * to tune stack sizes. (2) Leaving it uninitialized just gives me + * the willies. * * - Because embedded programs should be adverse to using the heap, * CONFIG_COROUTINE_NUM is fixed, instead of having coroutine_add() @@ -111,12 +111,133 @@ * no longer exists. */ -#if __x86_64__ -# include <unistd.h> /* for pause() */ -# define wait_for_interrupt() pause() -#elif __arm__ -# include "hardware/sync.h" /* for __wfi(); */ -# define wait_for_interrupt() __wfi() +#define ALWAYS_INLINE inline __attribute__((always_inline)) + +/* platform support ***********************************************************/ + +/* As part of sbc-harness, this only really needs to support ARM-32, but being + * able to run it on my x86-64 GNU/Linux laptop is useful for debugging. */ + +#define CR_PLAT_STACK_ALIGNMENT \ + ({ __attribute__((aligned)) void fn(void) {}; __alignof__(fn); }) + +#if 0 +{ /* to get Emacs indentation to work how I want */ +#endif +#if __arm__ /*======================================================*/ + /* Assume bare metal ARMv6-M. */ + + #define CR_PLAT_STACK_GROWS_DOWNWARD 1 + + /* Wrappers for setjmp()/longjmp() that do *not* save the + * interrupt mask. + * + * newlib setjmp()/longjmp() do not save the interrupt mask, * + * so we can use them directly. */ + #define cr_plat_setjmp(env) setjmp(env) + #define cr_plat_longjmp(env, val) longjmp(env, val) + + static ALWAYS_INLINE void cr_plat_wait_for_interrupt(void) { + asm volatile ("wfi":::"memory"); + } + static ALWAYS_INLINE void cr_plat_disable_interrupts(void) { + asm volatile ("cpsid i":::"memory"); + } + static ALWAYS_INLINE void cr_plat_enable_interrupts(void) { + asm volatile ("cpsie i":::"memory"); + } + + #if CONFIG_COROUTINE_MEASURE_STACK + static ALWAYS_INLINE uintptr_t cr_plat_get_sp(void) { + uintptr_t sp; + asm volatile ("mov %0, sp":"=r"(sp)); + return sp; + } + #endif + + static void cr_plat_call_with_stack(void *stack, + cr_fn_t fn, void *args) { + static void *saved_sp = NULL; + /* str/ldr can only work with a "lo" register, which + * sp is not, so we use r0 as an intermediate because + * we're going to clobber it with args anyway. */ + asm volatile ("mov r0, sp\n\t" /* [saved_sp = sp */ + "str r0, %0\n\t" /* ] */ + "mov sp, %1\n\t" /* [sp = stack] */ + "mov r0, %3\n\t" /* [arg0 = args] */ + "blx %2\n\t" /* [fn()] */ + "ldr r0, %0\n\t" /* [sp = staved_sp */ + "mov sp, r0" /* ] */ + : + : /* %0 */"m"(saved_sp), + /* %1 */"r"(stack), + /* %2 */"r"(fn), + /* %3 */"r"(args) + : "r0" + ); + } + +#elif __x86_64__ /*=================================================*/ + /* Assume POSIX. */ + #include <signal.h> /* for sig*, SIG_* */ + #include <unistd.h> /* for pause() */ + + #define CR_PLAT_STACK_GROWS_DOWNWARD 1 + + /* Wrappers for setjmp()/longjmp() that do *not* save the + * interrupt mask. + * + * POSIX leaves it implementation-defined whether they save + * the signal mask; while glibc does not save it, let's not + * rely on that. */ + #define cr_plat_setjmp(env) sigsetjmp(env, 0) + #define cr_plat_longjmp(env, val) siglongjmp(env, val) + + static inline void cr_plat_wait_for_interrupt(void) { + pause(); + } + static inline void cr_plat_disable_interrupts(void) { + sigset_t all; + sigfillset(&all); + sigprocmask(SIG_BLOCK, &all, NULL); + } + static inline void cr_plat_enable_interrupts(void) { + sigset_t all; + sigfillset(&all); + sigprocmask(SIG_UNBLOCK, &all, NULL); + } + + #if CONFIG_COROUTINE_MEASURE_STACK + static ALWAYS_INLINE uintptr_t cr_plat_get_sp(void) { + uintptr_t sp; + asm volatile ("movq %%rsp, %0":"=r"(sp)); + return sp; + } + #endif + + static void cr_plat_call_with_stack(void *stack, + cr_fn_t fn, void *args) { + static void *saved_sp = NULL; + asm volatile ("movq %%rsp , %0\n\t" /* saved_sp = sp */ + "movq %1 , %%rsp\n\t" /* sp = stack */ + "movq %3 , %%rdi\n\t" /* arg0 = args */ + "call *%2\n\t" /* fn() */ + "movq %0 , %%rsp" /* sp = saved_sp */ + : + : /* %0 */"m"(saved_sp), + /* %1 */"r"(stack), + /* %2 */"r"(fn), + /* %3 */"r"(args) + : "rdi" + ); + } + +#else + #error unsupported platform + +#endif +#if 0 +} #endif /* types **********************************************************************/ @@ -125,7 +246,8 @@ enum coroutine_state { CR_NONE = 0, /* this slot in the table is empty */ CR_INITIALIZING, /* running, before cr_begin() */ CR_RUNNING, /* running, after cr_begin() */ - CR_PRE_RUNNABLE, /* running, between cr_unpause_from_intrhandler() and cr_pause() */ + CR_PRE_RUNNABLE, /* running, after cr_unpause_from_intrhandler() + * but before cr_pause() */ CR_RUNNABLE, /* not running, but runnable */ CR_PAUSED, /* not running, and not runnable */ }; @@ -133,6 +255,12 @@ enum coroutine_state { struct coroutine { volatile enum coroutine_state state; jmp_buf env; +#if CONFIG_COROUTINE_MEASURE_STACK + /* We aught to be able to get this out of .env, but libc + * authors insist on jmp_buf being opaque, glibc going as far + * as to xor it with a secret ot obfuscate it! */ + uintptr_t sp; +#endif size_t stack_size; void *stack; }; @@ -156,6 +284,12 @@ static const uint8_t stack_pattern[] = { 0x4b, 0x14, 0xc4, 0xe0, 0xea, 0x62, 0x25, 0x63, }; #endif +#if CONFIG_COROUTINE_PROTECT_STACK +# define STACK_GUARD_SIZE \ + round_up(sizeof(stack_pattern), CR_PLAT_STACK_ALIGNMENT) +#else +# define STACK_GUARD_SIZE 0 +#endif /* global variables ***********************************************************/ @@ -193,24 +327,23 @@ static cid_t coroutine_running = 0; #endif #ifdef __GLIBC__ -# define assertf(expr, ...) \ - ((void) sizeof ((expr) ? 1 : 0), __extension__ ({ \ - if (expr) \ - ; /* empty */ \ - else { \ - errorf("assertion: " __VA_ARGS__); \ - __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION); \ - } \ - })) +# define assertf(expr, ...) ({ \ + if (!(expr)) { \ + errorf("assertion: " __VA_ARGS__); \ + __assert_fail(#expr, __FILE__, __LINE__, __func__); \ + } \ + }) #else -# define assertf(expr, ...) assert(expr) +# define assertf(expr, ...) assert(expr) #endif /** Return `n` rounded up to the nearest multiple of `d` */ -#define round_up(n, d) ( ( ((n)+(d)-1) / (d) ) * (d) ) +#define round_up(n, d) ( ( ((n)+(d)-1) / (d) ) * (d) ) + +#define array_len(arr) (sizeof(arr)/sizeof(arr[0])) static inline const char* coroutine_state_str(enum coroutine_state state) { - assert(state < (sizeof(coroutine_state_strs)/sizeof(coroutine_state_strs[0]))); + assert(state < array_len(coroutine_state_strs)); return coroutine_state_strs[state]; } @@ -219,121 +352,22 @@ static inline void assert_cid(cid_t cid) { assert(cid <= CONFIG_COROUTINE_NUM); #if CONFIG_COROUTINE_PROTECT_STACK assert(coroutine_table[cid-1].stack_size); - assert(coroutine_table[cid-1].stack); - for (size_t i = 0; i < sizeof(stack_pattern); i++) { + uint8_t *stack = coroutine_table[cid-1].stack; + assert(stack); + for (size_t i = 0; i < STACK_GUARD_SIZE; i++) { size_t j = coroutine_table[cid-1].stack_size - (i+1); - assert(((uint8_t*)coroutine_table[cid-1].stack)[i] == stack_pattern[i]); - assert(((uint8_t*)coroutine_table[cid-1].stack)[j] == stack_pattern[j%sizeof(stack_pattern)]); + assert(stack[i] == stack_pattern[i%sizeof(stack_pattern)]); + assert(stack[j] == stack_pattern[j%sizeof(stack_pattern)]); } #endif } -#define assert_cid_state(cid, expr) do { \ - assert_cid(cid); \ +#define assert_cid_state(cid, expr) do { \ + assert_cid(cid); \ cid_t state = coroutine_table[(cid)-1].state; \ - assert(expr); \ + assert(expr); \ } while (0) -/* platform support ***********************************************************/ - -/* As part of sbc-harness, this only really needs to support ARM-32, but being - * able to run it on my x86-64 GNU/Linux laptop is useful for debugging. */ - -#define CR_PLAT_STACK_ALIGNMENT ({ __attribute__((aligned)) void fn(void) {}; __alignof__(fn); }) - -#if 0 -{ /* to get Emacs indentation to work how I want */ -#endif -#if __arm__ - /* Assume bare metal ARMv6-M. */ - #include "cmsis_compiler.h" /* for __WFI(), __disable_irq(), __enable_irq() */ - - #define CR_PLAT_STACK_GROWS_DOWNWARD 1 - - static void cr_plat_wait_for_interrupt(void) { asm volatile ("wfi":::"memory"); } - static void cr_plat_disable_interrupt(void) { asm volatile ("cpsid i":::"memory"); } - static void cr_plat_enable_interrupts(void) { asm volatile ("cpsie i":::"memory"); } - -#if CONFIG_COROUTINE_MEASURE_STACK - static size_t cr_plat_get_sp(void) { - size_t sp; - asm volatile ("mov %0, sp":"=r"(sp)); - return sp; - } -#endif - - static void cr_plat_call_with_stack(void *stack, cr_fn_t fn, void *args) { - static void *saved_sp = NULL; - /* str/ldr can only work with a "lo" register, which sp is - * not, so we use r0 as an intermediate because we're going to - * clobber it with args anyway. */ - asm volatile ("mov r0, sp\n\t" /* [saved_sp = sp */ - "str r0, %0\n\t" /* ] */ - "mov sp, %1\n\t" /* [sp = stack] */ - "mov r0, %3\n\t" /* [arg0 = args] */ - "blx %2\n\t" /* [fn()] */ - "ldr r0, %0\n\t" /* [sp = staved_sp */ - "mov sp, r0" /* ] */ - : - : /* %0 */"m"(saved_sp), - /* %1 */"r"(stack), - /* %2 */"r"(fn), - /* %3 */"r"(args) - : "r0" - ); - } - -#elif __x86_64__ - /* Assume POSIX. */ - #include <signal.h> /* for sigset_t, sigprocmask(), SIG_*, sigfillset() */ - #include <unistd.h> /* for pause() */ - - #define CR_PLAT_STACK_GROWS_DOWNWARD 1 - - static void cr_plat_wait_for_interrupt(void) { - pause(); - } - static void cr_plat_disable_interrupts(void) { - sigset_t all; - sigfillset(&all); - sigprocmask(SIG_BLOCK, &all, NULL); - } - static void cr_plat_enable_interrupts(void) { - sigset_t all; - sigfillset(&all); - sigprocmask(SIG_UNBLOCK, &all, NULL); - } - -#if CONFIG_COROUTINE_MEASURE_STACK - static size_t cr_plat_get_sp(void) { - size_t sp; - asm volatile ("movq %%rsp, %0":"=r"(sp)); - return sp; - } -#endif - - static void cr_plat_call_with_stack(void *stack, cr_fn_t fn, void *args) { - static void *saved_sp = NULL; - asm volatile ("movq %%rsp , %0\n\t" /* saved_sp = sp */ - "movq %1 , %%rsp\n\t" /* sp = stack */ - "movq %3 , %%rdi\n\t" /* arg0 = args */ - "call *%2\n\t" /* fn() */ - "movq %0 , %%rsp" /* sp = saved_sp */ - : - : /* %0 */"m"(saved_sp), - /* %1 */"r"(stack), - /* %2 */"r"(fn), - /* %3 */"r"(args) - : "rdi" - ); - -#else - #error unsupported platform - -#endif -#if 0 -} -#endif /* coroutine_add() ************************************************************/ @@ -345,13 +379,14 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { assert_cid_state(parent, state == CR_RUNNING); assert(stack_size); assert(fn); - debugf("coroutine_add_with_stack_size(%zu, %p, %p)...\n", stack_size, fn, args); + debugf("coroutine_add_with_stack_size(%zu, %p, %p)...\n", + stack_size, fn, args); cid_t child; { - size_t idx_base = last_created; - for (size_t idx_shift = 0; idx_shift < CONFIG_COROUTINE_NUM; idx_shift++) { - child = ((idx_base + idx_shift) % CONFIG_COROUTINE_NUM) + 1; + size_t base = last_created; + for (size_t shift = 0; shift < CONFIG_COROUTINE_NUM; shift++) { + child = ((base + shift) % CONFIG_COROUTINE_NUM) + 1; if (coroutine_table[child-1].state == CR_NONE) goto found; } @@ -363,23 +398,25 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { last_created = child; coroutine_table[child-1].stack_size = stack_size; - coroutine_table[child-1].stack = aligned_alloc(CR_PLAT_STACK_ALIGNMENT, stack_size); + coroutine_table[child-1].stack = + aligned_alloc(CR_PLAT_STACK_ALIGNMENT, stack_size); #if CONFIG_COROUTINE_MEASURE_STACK || CONFIG_COROUTINE_PROTECT_STACK for (size_t i = 0; i < stack_size; i++) - ((uint8_t*)coroutine_table[child-1].stack)[i] = stack_pattern[i%sizeof(stack_pattern)]; + ((uint8_t *)coroutine_table[child-1].stack)[i] = + stack_pattern[i%sizeof(stack_pattern)]; #endif coroutine_running = child; coroutine_table[child-1].state = CR_INITIALIZING; - if (!setjmp(coroutine_add_env)) { /* point=a */ - void *stack_base = coroutine_table[child-1].stack + (CR_PLAT_STACK_GROWS_DOWNWARD ? stack_size : 0); -#if CONFIG_COROUTINE_PROTECT_STACK -# if CR_PLAT_STACK_GROWS_DOWNWARD - stack_base -= round_up(sizeof(stack_pattern), CR_PLAT_STACK_ALIGNMENT); -# else - stack_base += round_up(sizeof(stack_pattern), CR_PLAT_STACK_ALIGNMENT); -# endif + if (!cr_plat_setjmp(coroutine_add_env)) { /* point=a */ + void *stack_base = coroutine_table[child-1].stack +#if CR_PLAT_STACK_GROWS_DOWNWARD + + stack_size + - STACK_GUARD_SIZE +#else + + STACK_GUARD_SIZE #endif + ; debugf("...stack =%p\n", coroutine_table[child-1].stack); debugf("...stack_base=%p\n", stack_base); /* run until cr_begin() */ @@ -395,35 +432,12 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { } cid_t coroutine_add(cr_fn_t fn, void *args) { - return coroutine_add_with_stack_size(CONFIG_COROUTINE_DEFAULT_STACK_SIZE, fn, args); + return coroutine_add_with_stack_size( + CONFIG_COROUTINE_DEFAULT_STACK_SIZE, fn, args); } /* coroutine_main() ***********************************************************/ -#if CONFIG_COROUTINE_MEASURE_STACK -struct stack_stats { - size_t cap; - size_t max; - //size_t cur; -}; - -static void measure_stack(cid_t cid, struct stack_stats *ret) { - ret->cap = coroutine_table[cid-1].stack_size - (CONFIG_COROUTINE_PROTECT_STACK ? 2*round_up(sizeof(stack_pattern), CR_PLAT_STACK_ALIGNMENT) : 0); - - ret->max = ret->cap; - for (;;) { -#if CR_PLAT_STACK_GROWS_DOWNWARD - size_t i = (CONFIG_COROUTINE_PROTECT_STACK ? round_up(sizeof(stack_pattern), CR_PLAT_STACK_ALIGNMENT) : 0) + ret->cap - ret->max; -#else - size_t i = ret->max - 1 - (CONFIG_COROUTINE_PROTECT_STACK ? round_up(sizeof(stack_pattern), CR_PLAT_STACK_ALIGNMENT) : 0); -#endif - if (ret->max == 0 || ((uint8_t*)coroutine_table[cid-1].stack)[i] != stack_pattern[i%sizeof(stack_pattern)]) - break; - ret->max--; - } -} -#endif - static inline cid_t next_coroutine() { for (cid_t next = (coroutine_running%CONFIG_COROUTINE_NUM)+1; next != coroutine_running; @@ -436,24 +450,23 @@ static inline cid_t next_coroutine() { void coroutine_main(void) { debugf("coroutine_main()\n"); + cr_plat_disable_interrupts(); coroutine_running = 0; for (;;) { cid_t next = next_coroutine(); if (!next) { + cr_plat_enable_interrupts(); errorf("no coroutines\n"); return; } - if (!setjmp(coroutine_main_env)) { /* point=b */ + if (!cr_plat_setjmp(coroutine_main_env)) { /* point=b */ coroutine_running = next; coroutine_table[coroutine_running-1].state = CR_RUNNING; - longjmp(coroutine_table[coroutine_running-1].env, 1); /* jump to point=c */ + cr_plat_longjmp(coroutine_table[coroutine_running-1].env, 1); /* jump to point=c */ } + /* This is where we jump to from cr_exit(), and from + * nowhere else. */ assert_cid_state(coroutine_running, state == CR_NONE); -#if CONFIG_COROUTINE_MEASURE_STACK - struct stack_stats sizes; - measure_stack(coroutine_running, &sizes); - infof("cid=%zu: exited having used %zu B stack space\n", coroutine_running, sizes.max); -#endif free(coroutine_table[coroutine_running-1].stack); coroutine_table[coroutine_running-1] = (struct coroutine){0}; } @@ -462,81 +475,140 @@ void coroutine_main(void) { /* cr_*() *********************************************************************/ void cr_begin(void) { + debugf("cid=%zu: cr_begin()\n", coroutine_running); assert_cid_state(coroutine_running, state == CR_INITIALIZING); coroutine_table[coroutine_running-1].state = CR_RUNNABLE; - if (!setjmp(coroutine_table[coroutine_running-1].env)) /* point=c1 */ - longjmp(coroutine_add_env, 1); /* jump to point=a */ + coroutine_table[coroutine_running-1].sp = cr_plat_get_sp(); + if (!cr_plat_setjmp(coroutine_table[coroutine_running-1].env)) /* point=c1 */ + cr_plat_longjmp(coroutine_add_env, 1); /* jump to point=a */ + cr_plat_enable_interrupts(); } -static inline void _yield() { +static inline void _cr_transition(enum coroutine_state state) { + coroutine_table[coroutine_running-1].state = state; + cid_t next; for (;;) { next = next_coroutine(); if (next) + /* Switch to `next`. */ break; if (coroutine_table[coroutine_running-1].state == CR_RUNNABLE) { - debugf("cid=%zu: no other runnable coroutines, not yielding\n", coroutine_running); + /* No other coroutine is runnable, don't + * transition after all. */ coroutine_table[coroutine_running-1].state = CR_RUNNING; return; - } else { // XXX - debugf("cid=%zu: no runnable coroutines, sleeping\n", coroutine_running); // XXX - wait_for_interrupt(); // XXX } + /* No coroutines are runnable, wait for an interrupt + * to change that. */ + cr_plat_wait_for_interrupt(); } - if (!setjmp(coroutine_table[coroutine_running-1].env)) { /* point=c2 */ + + coroutine_table[coroutine_running-1].sp = cr_plat_get_sp(); + if (!cr_plat_setjmp(coroutine_table[coroutine_running-1].env)) { /* point=c2 */ coroutine_running = next; coroutine_table[coroutine_running-1].state = CR_RUNNING; - longjmp(coroutine_table[coroutine_running-1].env, 1); /* jump to point=b */ + cr_plat_longjmp(coroutine_table[coroutine_running-1].env, 1); /* jump to point=b */ } } void cr_yield(void) { + debugf("cid=%zu: cr_yield()\n", coroutine_running); assert_cid_state(coroutine_running, state == CR_RUNNING); - coroutine_table[coroutine_running-1].state = CR_RUNNABLE; - _yield(); + + cr_plat_disable_interrupts(); + _cr_transition(CR_RUNNABLE); + cr_plat_enable_interrupts(); } void cr_pause_and_yield(void) { + debugf("cid=%zu: cr_pause_and_yield()\n", coroutine_running); assert_cid_state(coroutine_running, state == CR_RUNNING || state == CR_PRE_RUNNABLE); - coroutine_table[coroutine_running-1].state = CR_PAUSED; - _yield(); + + cr_plat_disable_interrupts(); + if (coroutine_table[coroutine_running-1].state == CR_PRE_RUNNABLE) + _cr_transition(CR_RUNNABLE); + else + _cr_transition(CR_PAUSED); + cr_plat_enable_interrupts(); } void cr_exit(void) { + debugf("cid=%zu: cr_exit()\n", coroutine_running); assert_cid_state(coroutine_running, state == CR_RUNNING); - debugf("cid=%zu: exit\n", coroutine_running); + cr_plat_disable_interrupts(); coroutine_table[coroutine_running-1].state = CR_NONE; - longjmp(coroutine_main_env, 1); /* jump to point=b */ + cr_plat_longjmp(coroutine_main_env, 1); /* jump to point=b */ } void cr_unpause(cid_t cid) { - assert_cid_state(cid, state == CR_PAUSED); debugf("cr_unpause(%zu)\n", cid); + assert_cid_state(cid, state == CR_PAUSED); coroutine_table[cid-1].state = CR_RUNNABLE; } void cr_unpause_from_intrhandler(cid_t cid) { - assert_cid_state(cid, state == CR_RUNNING || state == CR_PAUSED); debugf("cr_unpause_from_intrhandler(%zu)\n", cid); + assert_cid_state(cid, state == CR_RUNNING || state == CR_PAUSED); - switch (coroutine_table[cid-1].state) { - case CR_RUNNING: + if (coroutine_table[cid-1].state == CR_RUNNING) { assert(cid == coroutine_running); debugf("... raced, deferring unpause\n"); coroutine_table[cid-1].state = CR_PRE_RUNNABLE; - break; - case CR_PAUSED: + } else { debugf("... actual unpause\n"); coroutine_table[cid-1].state = CR_RUNNABLE; - break; - default: - assert(false); } } cid_t cr_getcid(void) { return coroutine_running; } + +/* cr_cid_info() **************************************************************/ + +#if CONFIG_COROUTINE_MEASURE_STACK + +void cr_cid_info(cid_t cid, struct cr_cid_info *ret) { + assert_cid(cid); + assert(ret); + + /* stack_cap */ + ret->stack_cap = coroutine_table[cid-1].stack_size - 2*STACK_GUARD_SIZE; + + /* stack_max */ + ret->stack_max = ret->stack_cap; + uint8_t *stack = (uint8_t *)coroutine_table[cid-1].stack; + for (;;) { + size_t i = +#if CR_PLAT_STACK_GROWS_DOWNWARD + STACK_GUARD_SIZE + ret->stack_cap - ret->stack_max +#else + ret->stack_max - 1 - STACK_GUARD_SIZE +#endif + ; + if (ret->stack_max == 0 || + stack[i] != stack_pattern[i%sizeof(stack_pattern)]) + break; + ret->stack_max--; + } + + /* stack_cur */ + uintptr_t sp; + if (cid == coroutine_running) + sp = cr_plat_get_sp(); + else + sp = coroutine_table[cid-1].sp; + assert(sp); + uintptr_t sb = (uintptr_t)coroutine_table[cid-1].stack; +#if CR_PLAT_STACK_GROWS_DOWNWARD + ret->stack_cur = (sb - STACK_GUARD_SIZE) - sp; +#else + ret->stack_cur = sp - (sb + STACK_GUARD_SIZE); +#endif +} + +#endif /* CONFIG_COROUTINE_MEASURE_STACK */ |