X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fkernel%2Fao_task.c;h=0bc85d40aad2dc86c2df71ee884fb313733fbcb7;hb=HEAD;hp=dc5c19132caeb121a21b5bbe0698da713a68c9d8;hpb=2cdb1f30c49ba460b0850d23ba9c85e0336af290;p=fw%2Faltos

diff --git a/src/kernel/ao_task.c b/src/kernel/ao_task.c
index dc5c1913..048f5e67 100644
--- a/src/kernel/ao_task.c
+++ b/src/kernel/ao_task.c
@@ -24,19 +24,14 @@
 #if HAS_STACK_GUARD
 #include <ao_mpu.h>
 #endif
+#include <picotls.h>
 
 #define DEBUG	0
 
-#define AO_NO_TASK_INDEX	0xff
-
 struct ao_task * ao_tasks[AO_NUM_TASKS];
 uint8_t ao_num_tasks;
 struct ao_task *ao_cur_task;
 
-#if !HAS_TASK_QUEUE
-static uint8_t ao_cur_task_index;
-#endif
-
 #ifdef ao_arch_task_globals
 ao_arch_task_globals
 #endif
@@ -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(struct ao_task * task, void (*start)(void), const char *name) 
+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(struct ao_task * task, void (*start)(void), const char *name)
 	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++;
 		);
 }
 
+#ifdef AO_STACK_CANARY
+static void
+ao_check_stack_canary(void)
+{
+	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
+#define ao_check_stack_canary()
+#endif
+
 uint8_t	ao_task_minimize_latency;
 
-/* Task switching function. This must not use any stack variables */
+/* Task switching function. */
 void
-ao_yield(void) ao_arch_naked_define
+ao_yield(void)
 {
-	ao_arch_save_regs();
-
-#if HAS_TASK_QUEUE
-	if (ao_cur_task == NULL)
-		ao_cur_task = ao_tasks[ao_num_tasks-1];
-#else
-	if (ao_cur_task_index == AO_NO_TASK_INDEX)
-		ao_cur_task_index = ao_num_tasks-1;
-#endif
-	else
+	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,12 +389,11 @@ 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))
@@ -380,31 +406,6 @@ ao_yield(void) ao_arch_naked_define
 			ao_arch_wait_interrupt();
 	}
 	ao_cur_task = ao_list_first_entry(&run_queue, struct ao_task, queue);
-#else
-	{
-		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
@@ -414,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(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;
@@ -442,7 +442,6 @@ void
 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;
@@ -454,52 +453,33 @@ ao_wakeup(void *wchan)
 	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(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;
 }
@@ -507,7 +487,7 @@ ao_sleep_for(void *wchan, uint16_t timeout)
 static uint8_t ao_forever;
 
 void
-ao_delay(uint16_t ticks)
+ao_delay(AO_TICK_TYPE ticks)
 {
 	if (!ticks)
 		ticks = 1;
@@ -519,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
@@ -542,7 +518,7 @@ ao_task_info(void)
 {
 	uint8_t		i;
 	struct ao_task *task;
-	uint16_t	now = ao_time();
+	AO_TICK_TYPE	now = ao_time();
 
 	for (i = 0; i < ao_num_tasks; i++) {
 		task = ao_tasks[i];
@@ -552,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
 }
@@ -561,9 +537,6 @@ 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();