From fbc84dc56566f31d897b420232088ba341810ea2 Mon Sep 17 00:00:00 2001 From: Aseda Aboagye Date: Wed, 1 Jul 2015 09:31:26 -0700 Subject: hooks: Move HOOK_INIT to after task switching. This commit changes the way in which tasks are started. Instead of having all tasks marked as ready to run upon initialization, only the hooks task is marked as ready to run. HOOK_INITs are now run at the beginning of the hooks task. After the HOOK_INITs, the hooks task calls back to enable the rest of the tasks, reschedules, and proceeds as usual. This also allows the removal of checks for task_start_called(). BUG=chrome-os-partner:27226 BRANCH=None TEST=Built and flash EC image for samus and verified that EC boot was successful as well as AP boot. Additionally, verified that charging, keyboard, tap-for-battery were all still functional. TEST=make -j buildall tests Change-Id: Iea53670222c803c2985e9c86c96974386888a4fe Signed-off-by: Aseda Aboagye Reviewed-on: https://chromium-review.googlesource.com/283657 Reviewed-by: Alec Berg Reviewed-by: Vincent Palatin Commit-Queue: Aseda Aboagye Tested-by: Aseda Aboagye --- common/hooks.c | 11 +++---- common/main.c | 3 -- core/cortex-m/task.c | 14 +++++++-- core/cortex-m0/task.c | 14 +++++++-- core/host/main.c | 1 - core/host/task.c | 81 +++++++++++++++++++++++++++++++++++++++++---------- core/nds32/task.c | 14 +++++++-- include/hooks.h | 5 ---- include/task.h | 5 ++++ 9 files changed, 113 insertions(+), 35 deletions(-) diff --git a/common/hooks.c b/common/hooks.c index c07a3d1d1c..6cca00c914 100644 --- a/common/hooks.c +++ b/common/hooks.c @@ -131,11 +131,6 @@ void hook_notify(enum hook_type type) #endif } -void hook_init(void) -{ - hook_notify(HOOK_INIT); -} - int hook_call_deferred(void (*routine)(void), int us) { const struct deferred_data *p; @@ -180,6 +175,12 @@ void hook_task(void) hook_task_started = 1; + /* Call HOOK_INIT hooks. */ + hook_notify(HOOK_INIT); + + /* Now, enable the rest of the tasks. */ + task_enable_all_tasks(); + while (1) { uint64_t t = get_time().val; int next = 0; diff --git a/common/main.c b/common/main.c index a2f86abdee..d70d987d43 100644 --- a/common/main.c +++ b/common/main.c @@ -160,9 +160,6 @@ test_mockable __keep int main(void) check_rw_signature(); #endif - /* Initialize the hook library. This calls HOOK_INIT hooks. */ - hook_init(); - /* * Print the init time. Not completely accurate because it can't take * into account the time before timer_init(), but it'll at least catch diff --git a/core/cortex-m/task.c b/core/cortex-m/task.c index 639cef9d48..09d7108e7b 100644 --- a/core/cortex-m/task.c +++ b/core/cortex-m/task.c @@ -139,9 +139,11 @@ static int need_resched_or_profiling; /* * Bitmap of all tasks ready to be run. * - * Currently all tasks are enabled at startup. + * Start off with only the hooks task marked as ready such that all the modules + * can do their init within a task switching context. The hooks task will then + * make a call to enable all tasks. */ -static uint32_t tasks_ready = (1<= 0) { - if (tasks[i].event || now.val >= tasks[i].wake_time.val) - break; + /* + * Only tasks with spawned threads are valid to be + * resumed. + */ + if (tasks[i].thread) { + if (tasks[i].event || + now.val >= tasks[i].wake_time.val) + break; + } --i; } if (i < 0) @@ -404,7 +414,7 @@ void *_task_int_generator_start(void *d) int task_start(void) { - int i; + int i = TASK_ID_HOOKS; task_register_interrupt(); @@ -414,31 +424,72 @@ int task_start(void) pthread_mutex_lock(&run_lock); + /* + * Initialize the hooks task first. After its init, it will callback to + * enable the remaining tasks. + */ + tasks[i].event = TASK_EVENT_WAKE; + tasks[i].wake_time.val = ~0ull; + tasks[i].started = 0; + pthread_cond_init(&tasks[i].resume, NULL); + pthread_create(&tasks[i].thread, NULL, _task_start_impl, + (void *)(uintptr_t)i); + pthread_cond_wait(&scheduler_cond, &run_lock); + /* + * Interrupt lock is grabbed by the task which just started. + * Let's unlock it so the next task can be started. + */ + pthread_mutex_unlock(&interrupt_lock); + + /* + * The hooks task is waiting in task_wait_event(). Lock interrupt_lock + * here so the first task chosen sees it locked. + */ + pthread_mutex_lock(&interrupt_lock); + + pthread_create(&interrupt_thread, NULL, + _task_int_generator_start, NULL); + + /* + * Tell the hooks task to continue so that it can call back to enable + * the other tasks. + */ + pthread_cond_signal(&tasks[i].resume); + pthread_cond_wait(&scheduler_cond, &run_lock); + task_enable_all_tasks_callback(); + + task_scheduler(); + + return 0; +} + +static void task_enable_all_tasks_callback(void) +{ + int i; + + /* Initialize the remaning tasks. */ for (i = 0; i < TASK_ID_COUNT; ++i) { + if (tasks[i].thread != (pthread_t)NULL) + continue; + tasks[i].event = TASK_EVENT_WAKE; tasks[i].wake_time.val = ~0ull; tasks[i].started = 0; pthread_cond_init(&tasks[i].resume, NULL); pthread_create(&tasks[i].thread, NULL, _task_start_impl, (void *)(uintptr_t)i); - pthread_cond_wait(&scheduler_cond, &run_lock); /* * Interrupt lock is grabbed by the task which just started. * Let's unlock it so the next task can be started. */ pthread_mutex_unlock(&interrupt_lock); + pthread_cond_wait(&scheduler_cond, &run_lock); } - /* - * All tasks are now waiting in task_wait_event(). Lock interrupt_lock - * here so the first task chosen sees it locked. - */ - pthread_mutex_lock(&interrupt_lock); - - pthread_create(&interrupt_thread, NULL, - _task_int_generator_start, NULL); - - task_scheduler(); +} - return 0; +void task_enable_all_tasks(void) +{ + /* Signal to the scheduler to enable the remaining tasks. */ + pthread_cond_signal(&scheduler_cond); } diff --git a/core/nds32/task.c b/core/nds32/task.c index 269513092b..baf87ffbf3 100644 --- a/core/nds32/task.c +++ b/core/nds32/task.c @@ -139,9 +139,11 @@ int need_resched; /* * Bitmap of all tasks ready to be run. * - * Currently all tasks are enabled at startup. + * Start off with only the hooks task marked as ready such that all the modules + * can do their init within a task switching context. The hooks task will then + * make a call to enable all tasks. */ -static uint32_t tasks_ready = (1<