diff --git a/docs/sledge-states/states.dot b/docs/sledge-states/states.dot index f2ca689..6e85804 100644 --- a/docs/sledge-states/states.dot +++ b/docs/sledge-states/states.dot @@ -1,8 +1,13 @@ digraph { Uninitialized -> Initialized Initialized -> {Runnable Error} - {Runnable Running_User Preempted} -> Running_Kernel - Running_Kernel -> {Blocked Error Preempted Returned Running_User} - Returned -> Complete - Blocked -> Runnable + Runnable -> Running_Sys + Running_User -> Running_Sys [label="interrupt"] + Running_Sys -> Asleep [label="sleep"] + Running_Sys -> {Error Returned} + Running_Sys -> Running_User [label="return"] + Running_Sys -> Preempted [label="preempt"] + Preempted -> Running_User + Returned -> Complete [label="exit_success"] + Asleep -> Runnable [label="wakeup"] } diff --git a/docs/sledge-states/states.svg b/docs/sledge-states/states.svg index 0782c5d..7b036f6 100644 --- a/docs/sledge-states/states.svg +++ b/docs/sledge-states/states.svg @@ -4,148 +4,154 @@ - - + + %3 - + Uninitialized - -Uninitialized + +Uninitialized Initialized - -Initialized + +Initialized Uninitialized->Initialized - - + + Runnable - -Runnable + +Runnable Initialized->Runnable - - + + Error - -Error + +Error Initialized->Error - - + + - - -Running_Kernel - -Running_Kernel + + +Running_Sys + +Running_Sys - + -Runnable->Running_Kernel - - +Runnable->Running_Sys + + + + + +Running_Sys->Error + + - + Running_User - -Running_User + +Running_User - - -Running_User->Running_Kernel - - + + +Running_Sys->Running_User + + +return - - -Preempted - -Preempted + + +Asleep + +Asleep - + -Preempted->Running_Kernel - - +Running_Sys->Asleep + + +sleep - - -Running_Kernel->Error - - + + +Returned + +Returned - + -Running_Kernel->Running_User - - - - - -Running_Kernel->Preempted - - +Running_Sys->Returned + + - - -Blocked - -Blocked + + +Preempted + +Preempted - + -Running_Kernel->Blocked - - +Running_Sys->Preempted + + +preempt - - -Returned - -Returned - - - -Running_Kernel->Returned - - + + +Running_User->Running_Sys + + +interrupt - + -Blocked->Runnable - - +Asleep->Runnable + + +wakeup Complete - -Complete + +Complete Returned->Complete - - + + +exit_success + + + +Preempted->Running_User + + diff --git a/runtime/include/sandbox_print_perf.h b/runtime/include/sandbox_print_perf.h index e673433..2259195 100644 --- a/runtime/include/sandbox_print_perf.h +++ b/runtime/include/sandbox_print_perf.h @@ -27,7 +27,7 @@ sandbox_print_perf(struct sandbox *sandbox) sandbox->module->relative_deadline, sandbox->total_time, queued_duration, sandbox->duration_of_state[SANDBOX_UNINITIALIZED], sandbox->duration_of_state[SANDBOX_ALLOCATED], sandbox->duration_of_state[SANDBOX_INITIALIZED], sandbox->duration_of_state[SANDBOX_RUNNABLE], - sandbox->duration_of_state[SANDBOX_PREEMPTED], sandbox->duration_of_state[SANDBOX_RUNNING_KERNEL], + sandbox->duration_of_state[SANDBOX_PREEMPTED], sandbox->duration_of_state[SANDBOX_RUNNING_SYS], sandbox->duration_of_state[SANDBOX_RUNNING_USER], sandbox->duration_of_state[SANDBOX_ASLEEP], sandbox->duration_of_state[SANDBOX_RETURNED], sandbox->duration_of_state[SANDBOX_COMPLETE], sandbox->duration_of_state[SANDBOX_ERROR], runtime_processor_speed_MHz, sandbox->memory.size); diff --git a/runtime/include/sandbox_set_as_asleep.h b/runtime/include/sandbox_set_as_asleep.h index 4b52e6f..178e8be 100644 --- a/runtime/include/sandbox_set_as_asleep.h +++ b/runtime/include/sandbox_set_as_asleep.h @@ -25,7 +25,7 @@ sandbox_set_as_asleep(struct sandbox *sandbox, sandbox_state_t last_state) uint64_t now = __getcycles(); switch (last_state) { - case SANDBOX_RUNNING_KERNEL: { + case SANDBOX_RUNNING_SYS: { local_runqueue_delete(sandbox); break; } @@ -46,6 +46,6 @@ sandbox_set_as_asleep(struct sandbox *sandbox, sandbox_state_t last_state) static inline void sandbox_sleep(struct sandbox *sandbox) { - assert(sandbox->state == SANDBOX_RUNNING_KERNEL); - sandbox_set_as_asleep(sandbox, SANDBOX_RUNNING_KERNEL); + assert(sandbox->state == SANDBOX_RUNNING_SYS); + sandbox_set_as_asleep(sandbox, SANDBOX_RUNNING_SYS); } diff --git a/runtime/include/sandbox_set_as_complete.h b/runtime/include/sandbox_set_as_complete.h index c87d3d7..3c5f068 100644 --- a/runtime/include/sandbox_set_as_complete.h +++ b/runtime/include/sandbox_set_as_complete.h @@ -46,9 +46,8 @@ sandbox_set_as_complete(struct sandbox *sandbox, sandbox_state_t last_state) runtime_sandbox_total_decrement(last_state); /* Admissions Control Post Processing */ - admissions_info_update(&sandbox->module->admissions_info, - sandbox->duration_of_state[SANDBOX_RUNNING_USER] - + sandbox->duration_of_state[SANDBOX_RUNNING_KERNEL]); + admissions_info_update(&sandbox->module->admissions_info, sandbox->duration_of_state[SANDBOX_RUNNING_USER] + + sandbox->duration_of_state[SANDBOX_RUNNING_SYS]); admissions_control_subtract(sandbox->admissions_estimate); /* Terminal State Logging */ @@ -58,3 +57,10 @@ sandbox_set_as_complete(struct sandbox *sandbox, sandbox_state_t last_state) /* Do not touch sandbox state after adding to completion queue to avoid use-after-free bugs */ local_completion_queue_add(sandbox); } + +static inline void +sandbox_exit_success(struct sandbox *sandbox) +{ + assert(sandbox->state == SANDBOX_RETURNED); + sandbox_set_as_complete(sandbox, SANDBOX_RETURNED); +} diff --git a/runtime/include/sandbox_set_as_error.h b/runtime/include/sandbox_set_as_error.h index 3828eb6..a487b4f 100644 --- a/runtime/include/sandbox_set_as_error.h +++ b/runtime/include/sandbox_set_as_error.h @@ -36,8 +36,9 @@ sandbox_set_as_error(struct sandbox *sandbox, sandbox_state_t last_state) case SANDBOX_UNINITIALIZED: /* Technically, this is a degenerate sandbox that we generate by hand */ break; - case SANDBOX_RUNNING_KERNEL: { + case SANDBOX_RUNNING_SYS: { local_runqueue_delete(sandbox); + sandbox_free_linear_memory(sandbox); break; } default: { @@ -53,10 +54,20 @@ sandbox_set_as_error(struct sandbox *sandbox, sandbox_state_t last_state) runtime_sandbox_total_increment(SANDBOX_ERROR); runtime_sandbox_total_decrement(last_state); + /* Admissions Control Post Processing */ + admissions_control_subtract(sandbox->admissions_estimate); + + /* Terminal State Logging */ sandbox_print_perf(sandbox); sandbox_summarize_page_allocations(sandbox); - sandbox_free_linear_memory(sandbox); - admissions_control_subtract(sandbox->admissions_estimate); + /* Do not touch sandbox after adding to completion queue to avoid use-after-free bugs */ local_completion_queue_add(sandbox); } + +static inline void +sandbox_exit_error(struct sandbox *sandbox) +{ + assert(sandbox->state == SANDBOX_RUNNING_SYS); + sandbox_set_as_error(sandbox, SANDBOX_RUNNING_SYS); +} diff --git a/runtime/include/sandbox_set_as_preempted.h b/runtime/include/sandbox_set_as_preempted.h index 37ac2e2..46a9e83 100644 --- a/runtime/include/sandbox_set_as_preempted.h +++ b/runtime/include/sandbox_set_as_preempted.h @@ -26,7 +26,7 @@ sandbox_set_as_preempted(struct sandbox *sandbox, sandbox_state_t last_state) uint64_t now = __getcycles(); switch (last_state) { - case SANDBOX_RUNNING_USER: { + case SANDBOX_RUNNING_SYS: { current_sandbox_set(NULL); break; } @@ -43,3 +43,10 @@ sandbox_set_as_preempted(struct sandbox *sandbox, sandbox_state_t last_state) runtime_sandbox_total_increment(SANDBOX_PREEMPTED); runtime_sandbox_total_decrement(last_state); } + +static inline void +sandbox_preempt(struct sandbox *sandbox) +{ + assert(sandbox->state == SANDBOX_RUNNING_SYS); + sandbox_set_as_preempted(sandbox, SANDBOX_RUNNING_SYS); +} diff --git a/runtime/include/sandbox_set_as_returned.h b/runtime/include/sandbox_set_as_returned.h index cfe4410..0dbcdac 100644 --- a/runtime/include/sandbox_set_as_returned.h +++ b/runtime/include/sandbox_set_as_returned.h @@ -28,7 +28,7 @@ sandbox_set_as_returned(struct sandbox *sandbox, sandbox_state_t last_state) uint64_t now = __getcycles(); switch (last_state) { - case SANDBOX_RUNNING_KERNEL: { + case SANDBOX_RUNNING_SYS: { sandbox->timestamp_of.response = now; sandbox->total_time = now - sandbox->timestamp_of.request_arrival; local_runqueue_delete(sandbox); diff --git a/runtime/include/sandbox_set_as_running_kernel.h b/runtime/include/sandbox_set_as_running_sys.h similarity index 73% rename from runtime/include/sandbox_set_as_running_kernel.h rename to runtime/include/sandbox_set_as_running_sys.h index c097fa8..e140518 100644 --- a/runtime/include/sandbox_set_as_running_kernel.h +++ b/runtime/include/sandbox_set_as_running_sys.h @@ -11,10 +11,10 @@ #include "sandbox_types.h" static inline void -sandbox_set_as_running_kernel(struct sandbox *sandbox, sandbox_state_t last_state) +sandbox_set_as_running_sys(struct sandbox *sandbox, sandbox_state_t last_state) { assert(sandbox); - sandbox->state = SANDBOX_RUNNING_KERNEL; + sandbox->state = SANDBOX_RUNNING_SYS; uint64_t now = __getcycles(); switch (last_state) { @@ -39,7 +39,14 @@ sandbox_set_as_running_kernel(struct sandbox *sandbox, sandbox_state_t last_stat /* State Change Bookkeeping */ sandbox->duration_of_state[last_state] += (now - sandbox->timestamp_of.last_state_change); sandbox->timestamp_of.last_state_change = now; - sandbox_state_history_append(sandbox, SANDBOX_RUNNING_KERNEL); - runtime_sandbox_total_increment(SANDBOX_RUNNING_KERNEL); + sandbox_state_history_append(sandbox, SANDBOX_RUNNING_SYS); + runtime_sandbox_total_increment(SANDBOX_RUNNING_SYS); runtime_sandbox_total_decrement(last_state); } + +static inline void +sandbox_interrupt(struct sandbox *sandbox) +{ + assert(sandbox->state == SANDBOX_RUNNING_USER); + sandbox_set_as_running_sys(sandbox, SANDBOX_RUNNING_USER); +} diff --git a/runtime/include/sandbox_set_as_running_user.h b/runtime/include/sandbox_set_as_running_user.h index 13ee3d6..fa8832c 100644 --- a/runtime/include/sandbox_set_as_running_user.h +++ b/runtime/include/sandbox_set_as_running_user.h @@ -18,7 +18,7 @@ sandbox_set_as_running_user(struct sandbox *sandbox, sandbox_state_t last_state) uint64_t now = __getcycles(); switch (last_state) { - case SANDBOX_RUNNING_KERNEL: { + case SANDBOX_RUNNING_SYS: { assert(sandbox == current_sandbox_get()); assert(runtime_worker_threads_deadline[worker_thread_idx] == sandbox->absolute_deadline); break; @@ -46,3 +46,10 @@ sandbox_set_as_running_user(struct sandbox *sandbox, sandbox_state_t last_state) * is preemptable */ sandbox->state = SANDBOX_RUNNING_USER; } + +static inline void +sandbox_return(struct sandbox *sandbox) +{ + assert(sandbox->state == SANDBOX_RUNNING_SYS); + sandbox_set_as_running_user(sandbox, SANDBOX_RUNNING_SYS); +} diff --git a/runtime/include/sandbox_state.h b/runtime/include/sandbox_state.h index 14568ee..2dcd693 100644 --- a/runtime/include/sandbox_state.h +++ b/runtime/include/sandbox_state.h @@ -13,7 +13,7 @@ typedef enum SANDBOX_INITIALIZED, SANDBOX_RUNNABLE, SANDBOX_PREEMPTED, - SANDBOX_RUNNING_KERNEL, + SANDBOX_RUNNING_SYS, SANDBOX_RUNNING_USER, SANDBOX_ASLEEP, SANDBOX_RETURNED, diff --git a/runtime/include/scheduler.h b/runtime/include/scheduler.h index 6ecde79..0536f8c 100644 --- a/runtime/include/scheduler.h +++ b/runtime/include/scheduler.h @@ -18,7 +18,7 @@ #include "sandbox_types.h" #include "sandbox_set_as_preempted.h" #include "sandbox_set_as_runnable.h" -#include "sandbox_set_as_running_kernel.h" +#include "sandbox_set_as_running_sys.h" #include "sandbox_set_as_running_user.h" #include "scheduler_execute_epoll_loop.h" @@ -188,7 +188,7 @@ scheduler_preemptive_switch_to(ucontext_t *interrupted_context, struct sandbox * case ARCH_CONTEXT_VARIANT_FAST: { assert(next->state == SANDBOX_RUNNABLE); arch_context_restore_fast(&interrupted_context->uc_mcontext, &next->ctxt); - sandbox_set_as_running_kernel(next, SANDBOX_RUNNABLE); + sandbox_set_as_running_sys(next, SANDBOX_RUNNABLE); break; } case ARCH_CONTEXT_VARIANT_SLOW: { @@ -222,12 +222,17 @@ scheduler_preemptive_sched(ucontext_t *interrupted_context) assert(current != NULL); assert(current->state == SANDBOX_RUNNING_USER); + sandbox_interrupt(current); + struct sandbox *next = scheduler_get_next(); /* Assumption: the current sandbox is on the runqueue, so the scheduler should always return something */ assert(next != NULL); /* If current equals next, no switch is necessary, so resume execution */ - if (current == next) return; + if (current == next) { + sandbox_return(current); + return; + } #ifdef LOG_PREEMPTION debuglog("Preempting sandbox %lu to run sandbox %lu\n", current->id, next->id); @@ -236,7 +241,7 @@ scheduler_preemptive_sched(ucontext_t *interrupted_context) scheduler_log_sandbox_switch(current, next); /* Preempt executing sandbox */ - sandbox_set_as_preempted(current, SANDBOX_RUNNING_USER); + sandbox_preempt(current); arch_context_save_slow(¤t->ctxt, &interrupted_context->uc_mcontext); scheduler_preemptive_switch_to(interrupted_context, next); @@ -260,7 +265,7 @@ scheduler_cooperative_switch_to(struct sandbox *next_sandbox) switch (next_sandbox->state) { case SANDBOX_RUNNABLE: { assert(next_context->variant == ARCH_CONTEXT_VARIANT_FAST); - sandbox_set_as_running_kernel(next_sandbox, SANDBOX_RUNNABLE); + sandbox_set_as_running_sys(next_sandbox, SANDBOX_RUNNABLE); break; } case SANDBOX_PREEMPTED: { diff --git a/runtime/src/current_sandbox.c b/runtime/src/current_sandbox.c index 4082e16..c436f99 100644 --- a/runtime/src/current_sandbox.c +++ b/runtime/src/current_sandbox.c @@ -9,7 +9,7 @@ #include "sandbox_set_as_returned.h" #include "sandbox_set_as_complete.h" #include "sandbox_set_as_running_user.h" -#include "sandbox_set_as_running_kernel.h" +#include "sandbox_set_as_running_sys.h" #include "sandbox_setup_arguments.h" #include "scheduler.h" #include "software_interrupt.h" @@ -43,7 +43,7 @@ current_sandbox_sleep() assert(sandbox != NULL); switch (sandbox->state) { - case SANDBOX_RUNNING_KERNEL: { + case SANDBOX_RUNNING_SYS: { sandbox_sleep(sandbox); break; } @@ -68,6 +68,8 @@ void current_sandbox_exit() { struct sandbox *sandbox = current_sandbox_get(); + current_sandbox_set(NULL); + assert(sandbox != NULL); struct arch_context *current_context = &sandbox->ctxt; @@ -78,43 +80,33 @@ current_sandbox_exit() switch (sandbox->state) { case SANDBOX_RETURNED: - /* - * We draw a distinction between RETURNED and COMPLETED because a sandbox cannot add itself to the - * completion queue - * TODO: I think this executes when running inside the sandbox, as it hasn't yet yielded - * See Issue #224 at https://github.com/gwsystems/sledge-serverless-framework/issues/224 - */ - sandbox_set_as_complete(sandbox, SANDBOX_RETURNED); + sandbox_exit_success(sandbox); break; case SANDBOX_ERROR: + sandbox_exit_error(sandbox); break; default: panic("Cooperatively switching from a sandbox in a non-terminal %s state\n", sandbox_state_stringify(sandbox->state)); } - - current_sandbox_set(NULL); + /* Do not access sandbox after this, as it is on the completion queue! */ /* Assumption: Base Worker context should never be preempted */ assert(worker_thread_base_context.variant == ARCH_CONTEXT_VARIANT_FAST); arch_context_switch(current_context, &worker_thread_base_context); -} + /* The schduler should never switch back to completed sandboxes */ + assert(0); +} -/** - * Sandbox execution logic - * Handles setup, request parsing, WebAssembly initialization, function execution, response building and - * sending, and cleanup - */ -void -current_sandbox_start(void) +static inline struct sandbox * +current_sandbox_init() { struct sandbox *sandbox = current_sandbox_get(); assert(sandbox != NULL); - assert(sandbox->state == SANDBOX_RUNNING_KERNEL); + assert(sandbox->state == SANDBOX_RUNNING_SYS); - char *error_message = ""; - int rc = 0; + int rc = 0; sandbox_open_http(sandbox); @@ -133,14 +125,26 @@ current_sandbox_start(void) module_initialize_globals(current_module); module_initialize_memory(current_module); sandbox_setup_arguments(sandbox); + sandbox_return(sandbox); + + return sandbox; + +err: + sandbox_close_http(sandbox); + generic_thread_dump_lock_overhead(); + current_sandbox_exit(); + assert(0); +} + +static inline void +current_sandbox_fini() +{ + struct sandbox *sandbox = current_sandbox_get(); + assert(sandbox != NULL); + + char *error_message = ""; + sandbox_interrupt(sandbox); - /* Executing the function */ - int32_t argument_count = 0; - assert(sandbox->state == SANDBOX_RUNNING_KERNEL); - sandbox_set_as_running_user(sandbox, SANDBOX_RUNNING_KERNEL); - sandbox->return_value = module_entrypoint(current_module, argument_count, sandbox->arguments_offset); - assert(sandbox->state == SANDBOX_RUNNING_USER); - sandbox_set_as_running_kernel(sandbox, SANDBOX_RUNNING_USER); sandbox->timestamp_of.completion = __getcycles(); /* Retrieve the result, construct the HTTP response, and send to client */ @@ -153,24 +157,34 @@ current_sandbox_start(void) sandbox->timestamp_of.response = __getcycles(); - assert(sandbox->state == SANDBOX_RUNNING_KERNEL); + assert(sandbox->state == SANDBOX_RUNNING_SYS); sandbox_close_http(sandbox); - sandbox_set_as_returned(sandbox, SANDBOX_RUNNING_KERNEL); + sandbox_set_as_returned(sandbox, SANDBOX_RUNNING_SYS); done: /* Cleanup connection and exit sandbox */ generic_thread_dump_lock_overhead(); current_sandbox_exit(); - - /* This assert prevents a segfault discussed in - * https://github.com/phanikishoreg/awsm-Serverless-Framework/issues/66 - */ assert(0); err: debuglog("%s", error_message); - assert(sandbox->state == SANDBOX_RUNNING_KERNEL); + assert(sandbox->state == SANDBOX_RUNNING_SYS); sandbox_close_http(sandbox); - sandbox_set_as_error(sandbox, SANDBOX_RUNNING_KERNEL); goto done; } + +/** + * Sandbox execution logic + * Handles setup, request parsing, WebAssembly initialization, function execution, response building and + * sending, and cleanup + */ +void +current_sandbox_start(void) +{ + struct sandbox *sandbox = current_sandbox_init(); + struct module * current_module = sandbox_get_module(sandbox); + int32_t argument_count = 0; + sandbox->return_value = module_entrypoint(current_module, argument_count, sandbox->arguments_offset); + current_sandbox_fini(); +} diff --git a/runtime/src/local_runqueue_list.c b/runtime/src/local_runqueue_list.c index db4fe93..1e1fafa 100644 --- a/runtime/src/local_runqueue_list.c +++ b/runtime/src/local_runqueue_list.c @@ -60,7 +60,7 @@ local_runqueue_list_rotate() if (ps_list_head_one_node(&local_runqueue_list)) return; struct sandbox *sandbox_at_head = local_runqueue_list_remove_and_return(); - assert(sandbox_at_head->state == SANDBOX_RUNNING_KERNEL || sandbox_at_head->state == SANDBOX_RUNNABLE + assert(sandbox_at_head->state == SANDBOX_RUNNING_SYS || sandbox_at_head->state == SANDBOX_RUNNABLE || sandbox_at_head->state == SANDBOX_PREEMPTED); local_runqueue_list_append(sandbox_at_head); } diff --git a/runtime/src/memory/64bit_nix.c b/runtime/src/memory/64bit_nix.c index c14df8a..498b7ae 100644 --- a/runtime/src/memory/64bit_nix.c +++ b/runtime/src/memory/64bit_nix.c @@ -16,7 +16,7 @@ expand_memory(void) { struct sandbox *sandbox = current_sandbox_get(); - assert(sandbox->state == SANDBOX_RUNNING_USER || sandbox->state == SANDBOX_RUNNING_KERNEL); + assert(sandbox->state == SANDBOX_RUNNING_USER || sandbox->state == SANDBOX_RUNNING_SYS); assert(local_sandbox_context_cache.memory.size % WASM_PAGE_SIZE == 0); /* Return -1 if we've hit the linear memory max */ diff --git a/runtime/src/sandbox_state.c b/runtime/src/sandbox_state.c index 52954af..22ee7ec 100644 --- a/runtime/src/sandbox_state.c +++ b/runtime/src/sandbox_state.c @@ -9,17 +9,17 @@ const char *sandbox_state_labels[SANDBOX_STATE_COUNT] = { - [SANDBOX_UNINITIALIZED] = "Uninitialized", - [SANDBOX_ALLOCATED] = "Allocated", - [SANDBOX_INITIALIZED] = "Initialized", - [SANDBOX_RUNNABLE] = "Runnable", - [SANDBOX_PREEMPTED] = "Preempted", - [SANDBOX_RUNNING_KERNEL] = "Running Kernel", - [SANDBOX_RUNNING_USER] = "Running User", - [SANDBOX_ASLEEP] = "Asleep", - [SANDBOX_RETURNED] = "Returned", - [SANDBOX_COMPLETE] = "Complete", - [SANDBOX_ERROR] = "Error" + [SANDBOX_UNINITIALIZED] = "Uninitialized", + [SANDBOX_ALLOCATED] = "Allocated", + [SANDBOX_INITIALIZED] = "Initialized", + [SANDBOX_RUNNABLE] = "Runnable", + [SANDBOX_PREEMPTED] = "Preempted", + [SANDBOX_RUNNING_SYS] = "Running Kernel", + [SANDBOX_RUNNING_USER] = "Running User", + [SANDBOX_ASLEEP] = "Asleep", + [SANDBOX_RETURNED] = "Returned", + [SANDBOX_COMPLETE] = "Complete", + [SANDBOX_ERROR] = "Error" }; #ifdef LOG_SANDBOX_COUNT diff --git a/runtime/src/software_interrupt.c b/runtime/src/software_interrupt.c index e95ac62..0fdb263 100644 --- a/runtime/src/software_interrupt.c +++ b/runtime/src/software_interrupt.c @@ -18,7 +18,6 @@ #include "module.h" #include "panic.h" #include "runtime.h" -#include "sandbox_set_as_running_kernel.h" #include "sandbox_set_as_running_user.h" #include "sandbox_types.h" #include "scheduler.h"