X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fkernel%2Fao_task.c;h=0bc85d40aad2dc86c2df71ee884fb313733fbcb7;hb=HEAD;hp=e8a092aaf660fcf6bbec48706e14d2f7936e297b;hpb=1085ec5d57e0ed5d132f2bbdac1a0b6a32c0ab4a;p=fw%2Faltos diff --git a/src/kernel/ao_task.c b/src/kernel/ao_task.c index e8a092aa..048f5e67 100644 --- a/src/kernel/ao_task.c +++ b/src/kernel/ao_task.c @@ -24,18 +24,13 @@ #if HAS_STACK_GUARD #include #endif +#include #define DEBUG 0 -#define AO_NO_TASK_INDEX 0xff - -__xdata struct ao_task * __xdata ao_tasks[AO_NUM_TASKS]; -__data uint8_t ao_num_tasks; -__xdata struct ao_task *__data ao_cur_task; - -#if !HAS_TASK_QUEUE -static __data uint8_t ao_cur_task_index; -#endif +struct ao_task * ao_tasks[AO_NUM_TASKS]; +uint8_t ao_num_tasks; +struct ao_task *ao_cur_task; #ifdef ao_arch_task_globals ao_arch_task_globals @@ -61,16 +56,26 @@ static inline void ao_check_stack(void) { #define ao_task_irq_check() #endif -#if HAS_TASK_QUEUE - +#ifndef SLEEP_HASH_SIZE +#ifdef __ARM_FEATURE_IDIV__ #define SLEEP_HASH_SIZE 17 +#else +#define SLEEP_HASH_SIZE 16 +#endif +#endif + +#if SLEEP_HASH_SIZE & (SLEEP_HASH_SIZE - 1) +#define SLEEP_HASH_SHIFT 0 +#else +#define SLEEP_HASH_SHIFT 2 +#endif static struct ao_list run_queue; static struct ao_list alarm_queue; -static struct ao_list sleep_queue[SLEEP_HASH_SIZE]; +static struct ao_list ao_sleep_queue[SLEEP_HASH_SIZE]; static void -ao_task_to_run_queue(struct ao_task *task) +_ao_task_to_run_queue(struct ao_task *task) { ao_task_irq_check(); ao_list_del(&task->queue); @@ -80,11 +85,11 @@ ao_task_to_run_queue(struct ao_task *task) static struct ao_list * ao_task_sleep_queue(void *wchan) { - return &sleep_queue[(uintptr_t) wchan % SLEEP_HASH_SIZE]; + return &ao_sleep_queue[(((uintptr_t) wchan) >> SLEEP_HASH_SHIFT) % SLEEP_HASH_SIZE]; } static void -ao_task_to_sleep_queue(struct ao_task *task, void *wchan) +_ao_task_to_sleep_queue(struct ao_task *task, void *wchan) { ao_task_irq_check(); ao_list_del(&task->queue); @@ -125,10 +130,10 @@ ao_task_validate_alarm_queue(void) #define ao_task_validate_alarm_queue() #endif -uint16_t ao_task_alarm_tick; +AO_TICK_TYPE ao_task_alarm_tick; static void -ao_task_to_alarm_queue(struct ao_task *task) +_ao_task_to_alarm_queue(struct ao_task *task) { struct ao_task *alarm; ao_task_irq_check(); @@ -146,7 +151,7 @@ ao_task_to_alarm_queue(struct ao_task *task) } static void -ao_task_from_alarm_queue(struct ao_task *task) +_ao_task_from_alarm_queue(struct ao_task *task) { ao_task_irq_check(); ao_list_del(&task->alarm_queue); @@ -173,17 +178,17 @@ ao_task_exit_queue(struct ao_task *task) } void -ao_task_check_alarm(uint16_t tick) +ao_task_alarm(AO_TICK_TYPE tick) { struct ao_task *alarm, *next; ao_arch_critical( ao_list_for_each_entry_safe(alarm, next, &alarm_queue, struct ao_task, alarm_queue) { - if ((int16_t) (tick - alarm->alarm) < 0) + if ((AO_TICK_SIGNED) (tick - alarm->alarm) < 0) break; alarm->alarm = 0; - ao_task_from_alarm_queue(alarm); - ao_task_to_run_queue(alarm); + _ao_task_from_alarm_queue(alarm); + _ao_task_to_run_queue(alarm); }); } @@ -195,7 +200,7 @@ ao_task_init(void) ao_list_init(&alarm_queue); ao_task_alarm_tick = 0; for (i = 0; i < SLEEP_HASH_SIZE; i++) - ao_list_init(&sleep_queue[i]); + ao_list_init(&ao_sleep_queue[i]); } #if DEBUG @@ -287,10 +292,25 @@ ao_task_validate(void) } #endif /* DEBUG */ -#endif /* HAS_TASK_QUEUE */ +static inline void * +ao_stack_top(struct ao_task *task) +{ + uint8_t *top = &task->stack8[AO_STACK_SIZE]; + + /* Subtract off the TLS space, but keep the resulting + * stack 8-byte aligned + */ +#if USE_TLS + return top - ((_tls_size() + 7) & ~3); +#else + return top; +#endif +} + +#define AO_STACK_CANARY_VALUE 0xbaadf00dU void -ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name) __reentrant +ao_add_task(struct ao_task * task, void (*task_func)(void), const char *name) { uint8_t task_id; uint8_t t; @@ -306,55 +326,62 @@ ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *nam task->task_id = task_id; task->name = name; task->wchan = NULL; +#ifdef AO_STACK_CANARY + task->bottom_canary = AO_STACK_CANARY_VALUE; + task->top_canary = AO_STACK_CANARY_VALUE; +#endif /* * Construct a stack frame so that it will 'return' * to the start of the task */ - ao_arch_init_stack(task, start); - ao_arch_critical( -#if HAS_TASK_QUEUE - ao_task_init_queue(task); - ao_task_to_run_queue(task); + uint32_t *sp = ao_stack_top(task); +#if USE_TLS + _init_tls(sp); #endif + ao_arch_init_stack(task, sp, task_func); + ao_task_init_queue(task); + ao_arch_critical( + _ao_task_to_run_queue(task); ao_tasks[ao_num_tasks] = task; ao_num_tasks++; ); } -__data uint8_t ao_task_minimize_latency; - -/* Task switching function. This must not use any stack variables */ -void -ao_yield(void) ao_arch_naked_define +#ifdef AO_STACK_CANARY +static void +ao_check_stack_canary(void) { - ao_arch_save_regs(); - -#if HAS_TASK_QUEUE - if (ao_cur_task == NULL) - ao_cur_task = ao_tasks[ao_num_tasks-1]; + if (ao_cur_task->bottom_canary != AO_STACK_CANARY_VALUE) + ao_panic(AO_PANIC_STACK); + if (ao_cur_task->top_canary != AO_STACK_CANARY_VALUE) + ao_panic(AO_PANIC_STACK); +} #else - if (ao_cur_task_index == AO_NO_TASK_INDEX) - ao_cur_task_index = ao_num_tasks-1; +#define ao_check_stack_canary() #endif - else + +uint8_t ao_task_minimize_latency; + +/* Task switching function. */ +void +ao_yield(void) +{ + if (ao_cur_task) { #if HAS_SAMPLE_PROFILE - uint16_t tick = ao_sample_profile_timer_value(); - uint16_t run = tick - ao_cur_task->start; + AO_TICK_TYPE tick = ao_sample_profile_timer_value(); + AO_TICK_TYPE run = tick - ao_cur_task->start; if (run > ao_cur_task->max_run) ao_cur_task->max_run = run; ++ao_cur_task->yields; #endif + ao_check_stack_canary(); + ao_arch_save_regs(); ao_arch_save_stack(); } ao_arch_isr_stack(); -#if !HAS_TASK_QUEUE - if (ao_task_minimize_latency) - ao_arch_release_interrupts(); - else -#endif - ao_arch_block_interrupts(); + ao_arch_block_interrupts(); #if AO_CHECK_STACK in_yield = 1; @@ -362,45 +389,23 @@ ao_yield(void) ao_arch_naked_define /* Find a task to run. If there isn't any runnable task, * this loop will run forever, which is just fine */ -#if HAS_TASK_QUEUE /* If the current task is running, move it to the * end of the queue to allow other tasks a chance */ - if (ao_cur_task->wchan == NULL) - ao_task_to_run_queue(ao_cur_task); + if (ao_cur_task && ao_cur_task->wchan == NULL) + _ao_task_to_run_queue(ao_cur_task); for (;;) { ao_arch_memory_barrier(); if (!ao_list_is_empty(&run_queue)) break; /* Wait for interrupts when there's nothing ready */ - ao_arch_wait_interrupt(); + if (ao_task_minimize_latency) { + ao_arch_release_interrupts(); + ao_arch_block_interrupts(); + } else + ao_arch_wait_interrupt(); } ao_cur_task = ao_list_first_entry(&run_queue, struct ao_task, queue); -#else - { - __pdata uint8_t ao_last_task_index = ao_cur_task_index; - for (;;) { - ++ao_cur_task_index; - if (ao_cur_task_index == ao_num_tasks) - ao_cur_task_index = 0; - - ao_cur_task = ao_tasks[ao_cur_task_index]; - - /* Check for ready task */ - if (ao_cur_task->wchan == NULL) - break; - - /* Check if the alarm is set for a time which has passed */ - if (ao_cur_task->alarm && - (int16_t) (ao_time() - ao_cur_task->alarm) >= 0) - break; - - /* Wait for interrupts when there's nothing ready */ - if (ao_cur_task_index == ao_last_task_index && !ao_task_minimize_latency) - ao_arch_wait_interrupt(); - } - } -#endif #if HAS_SAMPLE_PROFILE ao_cur_task->start = ao_sample_profile_timer_value(); #endif @@ -410,21 +415,20 @@ ao_yield(void) ao_arch_naked_define #if AO_CHECK_STACK in_yield = 0; #endif +#if USE_TLS + _set_tls(ao_stack_top(ao_cur_task)); +#endif + ao_check_stack_canary(); ao_arch_restore_stack(); } uint8_t -ao_sleep(__xdata void *wchan) +ao_sleep(void *wchan) { -#if HAS_TASK_QUEUE - uint32_t flags; - flags = ao_arch_irqsave(); -#endif - ao_cur_task->wchan = wchan; -#if HAS_TASK_QUEUE - ao_task_to_sleep_queue(ao_cur_task, wchan); - ao_arch_irqrestore(flags); -#endif + ao_arch_critical( + ao_cur_task->wchan = wchan; + _ao_task_to_sleep_queue(ao_cur_task, wchan); + ); ao_yield(); if (ao_cur_task->wchan) { ao_cur_task->wchan = NULL; @@ -435,10 +439,9 @@ ao_sleep(__xdata void *wchan) } void -ao_wakeup(__xdata void *wchan) __reentrant +ao_wakeup(void *wchan) { ao_validate_cur_stack(); -#if HAS_TASK_QUEUE struct ao_task *sleep, *next; struct ao_list *sleep_queue; uint32_t flags; @@ -450,60 +453,41 @@ ao_wakeup(__xdata void *wchan) __reentrant ao_list_for_each_entry_safe(sleep, next, sleep_queue, struct ao_task, queue) { if (sleep->wchan == wchan) { sleep->wchan = NULL; - ao_task_to_run_queue(sleep); + _ao_task_to_run_queue(sleep); } } ao_arch_irqrestore(flags); -#else - { - uint8_t i; - for (i = 0; i < ao_num_tasks; i++) - if (ao_tasks[i]->wchan == wchan) - ao_tasks[i]->wchan = NULL; - } -#endif ao_check_stack(); } uint8_t -ao_sleep_for(__xdata void *wchan, uint16_t timeout) +ao_sleep_for(void *wchan, AO_TICK_TYPE timeout) { uint8_t ret; if (timeout) { -#if HAS_TASK_QUEUE - uint32_t flags; - flags = ao_arch_irqsave(); -#endif - /* Make sure we sleep *at least* delay ticks, which means adding - * one to account for the fact that we may be close to the next tick - */ - if (!(ao_cur_task->alarm = ao_time() + timeout + 1)) - ao_cur_task->alarm = 1; -#if HAS_TASK_QUEUE - ao_task_to_alarm_queue(ao_cur_task); - ao_arch_irqrestore(flags); -#endif + ao_arch_critical( + /* Make sure we sleep *at least* delay ticks, which means adding + * one to account for the fact that we may be close to the next tick + */ + if (!(ao_cur_task->alarm = ao_time() + timeout + 1)) + ao_cur_task->alarm = 1; + _ao_task_to_alarm_queue(ao_cur_task); + ); } ret = ao_sleep(wchan); if (timeout) { -#if HAS_TASK_QUEUE - uint32_t flags; - - flags = ao_arch_irqsave(); -#endif - ao_cur_task->alarm = 0; -#if HAS_TASK_QUEUE - ao_task_from_alarm_queue(ao_cur_task); - ao_arch_irqrestore(flags); -#endif + ao_arch_critical( + ao_cur_task->alarm = 0; + _ao_task_from_alarm_queue(ao_cur_task); + ); } return ret; } -static __xdata uint8_t ao_forever; +static uint8_t ao_forever; void -ao_delay(uint16_t ticks) +ao_delay(AO_TICK_TYPE ticks) { if (!ticks) ticks = 1; @@ -515,21 +499,17 @@ ao_exit(void) { uint8_t i; ao_arch_block_interrupts(); - ao_num_tasks--; -#if HAS_TASK_QUEUE for (i = 0; i < ao_num_tasks; i++) if (ao_tasks[i] == ao_cur_task) break; ao_task_exit_queue(ao_cur_task); -#else - i = ao_cur_task_index; - ao_cur_task_index = AO_NO_TASK_INDEX; -#endif + /* Remove task from list */ + ao_num_tasks--; for (; i < ao_num_tasks; i++) ao_tasks[i] = ao_tasks[i+1]; ao_cur_task = NULL; ao_yield(); - /* we'll never get back here */ + __builtin_unreachable(); } #if HAS_TASK_INFO @@ -537,8 +517,8 @@ void ao_task_info(void) { uint8_t i; - __xdata struct ao_task *task; - uint16_t now = ao_time(); + struct ao_task *task; + AO_TICK_TYPE now = ao_time(); for (i = 0; i < ao_num_tasks; i++) { task = ao_tasks[i]; @@ -548,7 +528,7 @@ ao_task_info(void) task->alarm ? (int16_t) (task->alarm - now) : 9999, task->name); } -#if HAS_TASK_QUEUE && DEBUG +#if DEBUG ao_task_validate(); #endif } @@ -557,12 +537,10 @@ ao_task_info(void) void ao_start_scheduler(void) { -#if !HAS_TASK_QUEUE - ao_cur_task_index = AO_NO_TASK_INDEX; -#endif ao_cur_task = NULL; #if HAS_ARCH_START_SCHEDULER ao_arch_start_scheduler(); #endif ao_yield(); + __builtin_unreachable(); }